samagotchi 0.65.0 → 0.67.0

data/docs/testing.md

@@ -19,7 +19,7 @@ The web specs run in plain node. One that loads lit-html, itself or through a mo
 `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)`,
+never shipped; 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.
@@ -27,6 +27,11 @@ A select bound with `.value` instead reads right in both, but lit sets it before
 `llm_context_chip.js`'s `renderForm` draws twice then. Assert a kept node with `assert.ok(a === b)`: a failing
 `assert.equal` on two DOM nodes inspects the whole DOM (huge output, can stall the run).
 
+`npm test` runs every file in one process (`--test-isolation=none`; CI and local runs use Node 24): the files share
+`globalThis`, the shim's one happy-dom window and every module's state: a global a spec sets (stage_view's
+`ResizeObserver` stand-in) is there for the files after it, so set only harmless stand-ins and put anything else
+back (`t.mock` restores itself). One file: `node --test spec/web/public/NAME.test.js`.
+
 Where a composer line goes is decided twice, in Ruby (`ComposerRoute`, both terminals) and in the web
 (`composer.js#routeComposerLine`). `spec/fixtures/composer_routes.json` holds the cases both answer: rspec
 (`spec/composer_route_spec.rb`) and `npm test` (`spec/web/public/composer.test.js`) run every row. A change to
@@ -44,8 +49,10 @@ script/affected-specs A..B            # another range (A...B: from their merge-b
 
 A builder runs these while working, not the full suite: the specs the change touched, the specs named after the
 files it changed (`lib/samagotchi/foo/bar.rb` → `spec/foo/bar_spec.rb`, `bar_*_spec.rb`…), the specs that read
-docs or source as text (its `RULES`: add one when a full run catches what the names missed), 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.
+docs or source as text (its `RULES`: add one when a full run catches what the names missed), 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.
 The Ruby specs go to stdout; the node tests to run (`npm test` targets), "web changed: also run npm run e2e" and a
 hint for a hub class (named in too many specs to list) go to stderr. Nothing printed means nothing matched.
 
@@ -65,6 +72,13 @@ It runs `git worktree add ../samagotchi-NAME -b BRANCH main`, then `npm ci --pre
 `npm test` and `npm run e2e` work there right away (Ruby gems and Playwright's browsers are shared: nothing else
 to install). It refuses when the folder or the branch already exists.
 
+## The desktop helper's build specs
+
+`SAMAGOTCHI_MACOS_BUILD=1 bundle exec rspec spec/desktop` also compiles the macOS helper (`:macos_build`, needs the
+Command Line Tools) and runs `ChiHelper` against a fake kitty and, when a `tmux` is on PATH, a real one (private
+`-L` servers under a temp `TMUX_TMPDIR`, killed after). CI skips them, and `script/affected-specs` doesn't pick them
+for a Swift change: run them by hand after editing `lib/samagotchi/desktop/macos/`.
+
 ## Integration specs
 
 Examples tagged `:integration` (`spec/integration/`, the "with LLM access" part of `spec/hooks/integration_spec.rb`)

data/lib/samagotchi/bootstrap/probe.rb

@@ -9,6 +9,7 @@ require_relative "../version"
 require_relative "../llm/openai_chat"
 require_relative "../llm/http"
 require_relative "../llm/api_key"
+require_relative "../host_keys"
 require_relative "../redacted_inspect"
 
 module Samagotchi
@@ -229,10 +230,10 @@ module Samagotchi
       end
 
       # One attempt through LLM::HTTP (User-Agent, the key's Bearer header),
-      # any status returned as is. A key whose variable is not set sends no
-      # header: the server's 401 then says one is needed.
+      # any status returned as is. A key neither its variable nor the
+      # Keychain holds sends no header: the server's 401 then says one is needed.
       def send_request(uri, request, key_env, read_timeout:)
-        key = key_env && !@env[key_env].to_s.strip.empty? ? LLM::ApiKey.for(key_env, host: uri.host, env: @env) : nil
+        key = key_env && HostKeys.fetch(key_env, env: @env) ? LLM::ApiKey.for(key_env, host: uri.host, env: @env) : nil
         LLM::HTTP.new(label: uri.host, open_timeout: @timeout, read_timeout: read_timeout, api_key: key,
                       retry_policy: LLM::HTTP::RetryPolicy.none)
                  .fetch(uri, request, retries: false, check_status: false, log_fields: { purpose: "probe" })

data/lib/samagotchi/bootstrap_command.rb

@@ -4,6 +4,7 @@ require "rbconfig"
 require_relative "config"
 require_relative "model_profile"
 require_relative "host_registry"
+require_relative "host_keys"
 require_relative "bootstrap/probe"
 require_relative "bootstrap/config_writer"
 require_relative "bootstrap/bundles"
@@ -87,7 +88,7 @@ module Samagotchi
 
       key_env = options[:key_env]
       if key_env && unset?(key_env)
-        fail!("#{key_env} is not set; export it first (the API key; chi only writes its name)")
+        fail!("#{key_env} is not set; #{export_hint(key_env, "first")} (the API key; chi only writes its name)")
         return @exit
       end
 
@@ -187,7 +188,7 @@ module Samagotchi
       key_env = @stdin.gets.to_s.strip
       return fail!("no variable given") if key_env.empty?
       return fail!("#{key_env} isn't a variable name") unless key_env.match?(ConfigFile::ENV_NAME_RE)
-      return fail!("#{key_env} is not set; export it and run chi bootstrap again") if unset?(key_env)
+      return fail!("#{key_env} is not set; #{export_hint(key_env, "and run chi bootstrap again")}") if unset?(key_env)
 
       result = @probe.classify(result.candidate, key_env: key_env)
       return fail!("#{host} refused the key in #{key_env} (HTTP #{result.status})") if result.kind == :needs_key
@@ -433,7 +434,16 @@ module Samagotchi
       @stdin.respond_to?(:tty?) && @stdin.tty?
     end
 
-    def unset?(name) = @env[name].to_s.strip.empty?
+    # Neither the variable nor the Keychain (HostKeys) holds the key.
+    def unset?(name) = HostKeys.fetch(name, env: @env).nil?
+
+    # "export it first", or on macOS "export it or store it in the Keychain
+    # (security …) first".
+    def export_hint(name, tail)
+      return "export it #{tail}" unless HostKeys.available?
+
+      "export it or store it in the Keychain (#{HostKeys.store_command(name)}) #{tail}"
+    end
 
     def fail!(message)
       @stderr.puts("chi bootstrap: #{message}")

data/lib/samagotchi/bridge/ring_buffer.rb

@@ -40,11 +40,6 @@ module Samagotchi
         end
       end
 
-      # @return [Integer, nil] the highest seq buffered so far.
-      def last_seq
-        @mutex.synchronize { @events.last&.[](:seq) }
-      end
-
       # @return [Integer, nil] the lowest seq buffered so far.
       def oldest_seq
         @mutex.synchronize { @events.first&.[](:seq) }

data/lib/samagotchi/bridge.rb

@@ -374,7 +374,10 @@ module Samagotchi
 
         Thread.new { handle_connection(client) }.tap do |t|
           t.report_on_exception = false
-          @connection_threads << t
+          # The ended connections' threads go as a new one comes, so a
+          # long-lived worker's list holds its open connections only. A new
+          # Array: #await_answers and #stop may be walking the old one.
+          @connection_threads = @connection_threads.select(&:alive?) << t
         end
       end
     rescue StandardError => e
@@ -606,13 +609,13 @@ module Samagotchi
 
       record, error = Tools::TaskRuntime.get_record(task_id)
       return [{}, 404, { error: "task_not_found", task_id: task_id }] if error
-      return [{}, 409, { error: "not_running", status: record["status"], task_id: task_id }] unless record["status"] == "running"
+      return [{}, 409, { error: "not_running", status: record.status, task_id: task_id }] unless record.running?
 
       Log.info(:bridge, "task_stop", task_id: task_id)
       record, error = Tools::TaskRuntime.stop_task(task_id, by: "user")
       return [{}, 500, { error: "bridge_error", detail: error }] if error
 
-      [{}, 200, { status: record["status"], stop_reason: record["stop_reason"], task_id: task_id }]
+      [{}, 200, { status: record.status, stop_reason: record.stop_reason, task_id: task_id }]
     end
 
     # The tasks this session started: its history's (created_ids_in) and

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

@@ -1,22 +1,23 @@
 ---
 name: claude-peer
-version: 0.1.0
+version: 0.3.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"
+    sha256: sha256:9293740f3e1afa0fc2eff381f2c6406087598205df351abd22b4459a3bcb5d0e
+    description: "Send a part of the work to the paired Claude Code session (claude_send): only when the user asks, or to reply to its answer in a peer turn; validate, context or question; Claude's answer comes as the claude-review context"
 plugin:
   file: plugin.rb
-  sha256: sha256:bf5a95eb125ba4831466e177295bdaba1f625e255b027cea1e59992310d8300e
+  sha256: sha256:74960c46f4b98a453a6c6b16a53a4e9cb76752e6df1deecf55784fc7a0e616ce
 scripts:
   pair: sha256:033f1fc6a644950b57e71865253526a0a487bb4c9fd5a61bb89d031b65f40417
-  chi-peer-SKILL.md: sha256:f35f726b1a86091ff69d289e8dd58794ac6f44879a63630fcc88d69867c56e20
+  chi-peer-SKILL.md: sha256:753b609bca01877d46e6b1c3c5b74edba745433cbe33a86702d3ab75bc3f7107
 # 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"
+# The plugin needs Samagotchi::Plugin::Peer and chi.peer_source (chi 0.67.0).
+requires_chi: ">= 0.67.0"

data/lib/samagotchi/bundles/claude-peer/plugin.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
 
-require "fileutils"
 require "io/wait"
 require "json"
-require "open3"
 require "socket"
-require "tempfile"
-require "time"
+require "samagotchi/plugin/peer"
 
 # claude-peer (docs/plugins.md, The claude-peer bundle): a live link between
 # this chi session and a Claude Code session the user works with. Claude
@@ -42,22 +39,28 @@ require "time"
 # being the user's consent: the copy happens in-process, where no guardrail
 # sees it. The skill is scripts/chi-peer-SKILL.md beside this file, with the
 # installed scripts/pair path and the payload folder written in.
-class Plugin
+#
+# In the web, selecting text offers "Confirm with Claude" (chi.annotation;
+# skipped on a chi without it, 0.62–0.65): it fills the composer with
+# `/claude validate` and the quote, for the user to add what to confirm.
+# Such a text is titled by its first quoted line, not the quote's
+# `From your thinking:` label.
+#
+# What the peer bundles share (the tool, the command, the cards, payloads)
+# is Samagotchi::Plugin::Peer; this class has Claude's strings and the
+# socket transport.
+class Plugin < Samagotchi::Plugin::Peer
   INBOX = "claude-inbox"
   REVIEW = "claude-review"
-  KINDS = %w[validate context question].freeze
-  # A part up to this long goes inline: Claude reads it with no file access.
-  INLINE_CHARS = 4_000
-  # A part longer than this is refused (Claude takes ~1M; a send is a part,
-  # not a session).
-  MAX_CHARS = 200_000
-  TITLE_CHARS = 80
-  SLUG_CHARS = 40
+  BUNDLE = "claude-peer"
+  NAME = "Claude"
+  APP = "Claude Code"
+  COMMAND = "/claude"
+  TOOL = "claude_send"
   # The socket must take the line within this long.
   WRITE_SECONDS = 5
   # The Claude Code version the wire format was checked on.
   CHECKED_ON = "Claude Code 2.1.296"
-  LAST_SEND = "last-send.json"
   STATUS_CARD = "claude"
   SKILL_CARD = "claude-skill"
   USAGE = "usage: /claude — whether a Claude Code session is paired; /claude validate <text> | context <text> — send " \
@@ -66,17 +69,15 @@ class Plugin
   # The shipped bundle keeps scripts/ beside plugin.rb; an installed one
   # has plugin/plugin.rb and scripts/ beside plugin/.
   SCRIPTS_DIRS = [File.join(__dir__, "scripts"), File.expand_path("../scripts", __dir__)].freeze
-  SKILL_FILE = "chi-peer-SKILL.md"
-  PAIR_PLACEHOLDER = "__CHI_PEER_PAIR__"
-  PAYLOADS_PLACEHOLDER = "__CHI_PEER_PAYLOADS__"
-  DIFF_LINES = 20
 
-  TOOL_DESCRIPTION = "Send a part of this session's work (a plan step, a diff, a finding, your last answer) to the " \
-                     "Claude Code session paired with it (the claude-inbox context), for Claude to validate, to take " \
-                     "as context, or to answer a question about. Only when the user asks for it. Needs a paired " \
-                     "Claude Code session: without one it fails, and the user pairs from Claude. Claude's answer " \
-                     "comes back later as the claude-review context (a validate's wakes you): don't wait or poll. " \
-                     "Never send secrets or the whole conversation."
+  TOOL_DESCRIPTION = "Send a part of this session's work (a plan step, a diff, a finding, your " \
+                     "last answer) to the Claude Code session paired with it (the claude-inbox " \
+                     "context), for Claude to validate, to take as context, or to answer a " \
+                     "question about. Only when the user asks for it, or to reply to its answer " \
+                     "in a peer turn. Needs a paired Claude Code session: without one it fails, " \
+                     "and the user pairs from Claude. Claude's answer comes back later as the " \
+                     "claude-review context (a validate's wakes you): don't wait or poll. Never " \
+                     "send secrets or the whole conversation."
   TOOL_PARAMS = {
     kind: { type: "string", enum: KINDS, required: true,
             description: "validate: check this part and answer with a verdict; context: for Claude to know, no " \
@@ -88,268 +89,40 @@ class Plugin
                          "functions or diff range to look at. A long text goes to a file Claude reads" }
   }.freeze
 
-  # A send that didn't happen; the message says why, for the model or the user.
-  class SendError < StandardError; end
-
-  def initialize(_settings = {})
-    @lock = Mutex.new
-    # The running turn's history before it (nil between turns), and the
-    # last completed answer this process saw.
-    @before_turn = nil
-    @last_answer = nil
-  end
-
-  def register(chi)
-    chi.tool "claude_send", TOOL_DESCRIPTION, params: TOOL_PARAMS, label: "sent to Claude",
-                                              preview: ->(args) { "#{args["kind"]}: #{args["title"]}" } do |args, ctx|
-      sent = deliver(ctx, kind: args["kind"].to_s, title: args["title"].to_s, text: args["text"].to_s)
-      "#{sent}. #{follow_up(args["kind"].to_s)}"
-    rescue SendError => e
-      "Error: #{e.message}"
-    end
-    chi.command "/claude", "the paired Claude Code session: status; validate|context <text>, last: send to it; " \
-                           "install-skill: install Claude's chi-peer skill", anytime: true do |args, ctx|
-      claude(args.to_s.strip, ctx)
-    end
-    chi.on(:before_turn) do |event|
-      @lock.synchronize { @before_turn = Array(event[:messages]) }
-    end
-    chi.on(:after_turn) do |event|
-      answer = completed_answer(event[:messages]) if event[:status].to_s == "completed"
-      @lock.synchronize do
-        @before_turn = nil
-        @last_answer = answer if answer
-      end
-    end
-  end
-
-  # Sends +text+ to the paired Claude: the header, then the text inline or
-  # a payload file's path. Records it as the last send.
-  # @return [String] what was sent ("sent to Claude: validate · title, inline")
-  # @raise [SendError]
-  def deliver(ctx, kind:, title:, text:)
-    raise SendError, "kind must be one of #{KINDS.join(", ")}" unless KINDS.include?(kind)
-    raise SendError, "nothing to send: the text is empty" if text.strip.empty?
-    if text.length > MAX_CHARS
-      raise SendError, "the text is #{text.length} chars, over #{MAX_CHARS}: send a part, not a session"
-    end
-
-    id = ctx.session_id or raise SendError, "this session has no id yet: send after its first turn"
-    socket = socket_path(ctx)
-    title = one_line(title.strip.empty? ? text.strip.lines.first : title)
-    body, where = if text.length <= INLINE_CHARS
-                    [text, "inline"]
-                  else
-                    path = write_payload(ctx, id, title, text)
-                    ["payload: #{path} (#{text.lines.size} lines, #{text.length} chars)", path]
-                  end
-    post(socket, line("chi #{id[0, 8]} · #{kind} · #{title}\n#{body}"))
-    record(ctx, id, kind: kind, title: title, chars: text.length, payload: where == "inline" ? nil : where)
-    "sent to Claude: #{kind} · #{title}#{" (the text in #{where})" unless where == "inline"}"
-  end
-
   # The one JSON line Claude Code's inbox socket takes.
   def line(content) = "#{JSON.generate(type: "user", message: { role: "user", content: content })}\n"
 
   private
 
-  def claude(args, ctx)
-    verb = args.split(/\s+/, 2).first
-    # The rest as typed: a pasted selection keeps its lines.
-    rest = args.sub(/\A\S+\s*/, "")
-    case verb
-    when nil then status(ctx)
-    when "validate", "context" then rest.strip.empty? ? USAGE : send_text(ctx, verb, rest)
-    when "last" then rest.empty? ? send_last(ctx) : USAGE
-    when "install-skill" then install_skill(ctx, yes: rest == "--yes")
-    else USAGE
-    end
-  end
-
-  def send_text(ctx, kind, text)
-    "#{deliver(ctx, kind: kind, title: text.strip.lines.first.to_s, text: text)}; Claude's answer comes as the " \
-      "claude-review context"
-  rescue SendError => e
-    "/claude: #{e.message}"
-  end
-
-  def send_last(ctx)
-    answer, before = @lock.synchronize { [@last_answer, @before_turn] }
-    answer ||= completed_answer(before || ctx.messages)
-    return "/claude last: no completed answer to send yet (the last turn has none); /claude context <text> sends a text" unless answer
-
-    deliver(ctx, kind: "context", title: "chi's last answer: #{answer.strip.lines.first}", text: answer)
-  rescue SendError => e
-    "/claude: #{e.message}"
-  end
-
-  # The answer a completed turn left: the history's last message when it
-  # is the model's (a cancelled, failed or empty turn ends in a turn note),
-  # after any notes that joined between turns; its thinking left out.
-  def completed_answer(messages)
-    last = Array(messages).reverse.find { |message| !(role(message) == "system" && kind(message) != "turn_note") }
-    return nil unless last && role(last) == "model" && !field(last, :interrupted) && !field(last, :tool_calls)
-
-    text = field(last, :content)
-    text = text.filter_map { |part| field(part, :text) if part.is_a?(Hash) }.join("\n") if text.is_a?(Array)
-    text = text.to_s.gsub(%r{<think>.*?</think>}m, "").strip
-    text.empty? ? nil : text
-  end
-
-  # The session's attached sources; none when they can't be read (chi 0.62
-  # raises for a new session not saved yet; a corrupt session file).
-  def sources(ctx)
-    ctx.context.list
-  rescue ArgumentError, SystemCallError
-    []
-  end
-
-  def role(message) = field(message, :role).to_s
-  def kind(message) = field(message, :kind).to_s
-  def field(hash, key) = hash.is_a?(Hash) ? hash[key] || hash[key.to_s] : nil
-
-  # The status card; nil, so the command adds no text.
-  def status(ctx)
-    id = ctx.session_id
-    sources = id ? sources(ctx) : []
-    inbox, review = [INBOX, REVIEW].map { |name| sources.find { |source| source[:name] == name } }
-    socket = inbox && inbox[:hint].to_s.strip
-    lines = if socket.nil? || socket.empty?
-              ["**not paired.** In Claude Code, install the chi-peer skill (Install skill below), then tell Claude " \
-               "\"pair with chi #{id.to_s[0, 8]}\"."]
-            else
-              there = File.socket?(socket) ? "there" : "**missing**: that Claude session ended or restarted, pair again"
-              ["**paired** with a Claude Code session", "socket: `#{socket}` (#{there})"]
-            end
-    lines << "last send: #{last_send_line(ctx, id)}" if id && last_send(ctx, id)
-    lines << "last answer (claude-review): #{review_line(review)}" if review
-    lines << "The inbox's format is undocumented: checked on #{CHECKED_ON}. A Claude that bypasses permissions " \
-             "holds peer messages for approval."
-    ctx.card(id: STATUS_CARD, title: "claude-peer: #{lines.first.start_with?("**paired") ? "paired" : "not paired"}",
-             body: lines.join("\n\n"), actions: [{ label: "Refresh", command: "/claude" },
-                                                 { label: "Install skill", command: "/claude install-skill" }])
-    nil
-  end
-
-  def last_send(ctx, id)
-    path = File.join(ctx.data_dir, "sessions", id, LAST_SEND)
-    File.file?(path) ? JSON.parse(File.read(path)) : nil
-  rescue JSON::ParserError, SystemCallError
-    nil
-  end
-
-  def last_send_line(ctx, id)
-    sent = last_send(ctx, id)
-    where = sent["payload"] ? "in `#{sent["payload"]}`" : "inline"
-    "#{ago(sent["at"])} · #{sent["kind"]} · #{sent["title"]} (#{sent["chars"]} chars, #{where})"
+  # The paired Claude's inbox socket: the claude-inbox context's hint.
+  def check_hint!(hint)
+    raise SendError, "claude-inbox's hint isn't a socket path (#{hint}): pair again from Claude" unless hint.start_with?("/")
   end
 
-  # The summary needs chi 0.63.0 (ctx.context.list's summary:).
-  def review_line(review)
-    return "none yet" unless review[:fetched_at]
-
-    [review[:summary], ago(review[:fetched_at])].compact.join(" · ")
+  def paired_lines(socket)
+    there = File.socket?(socket) ? "there" : "**missing**: that Claude session ended or restarted, pair again"
+    ["**paired** with a Claude Code session", "socket: `#{socket}` (#{there})"]
   end
 
-  def ago(stamp)
-    seconds = (Time.now - Time.iso8601(stamp.to_s)).to_i
-    if seconds < 60 then "just now"
-    elsif seconds < 3600 then "#{seconds / 60} min ago"
-    elsif seconds < 86_400 then "#{seconds / 3600} h ago"
-    else Time.iso8601(stamp).localtime.strftime("%Y-%m-%d %H:%M")
-    end
-  rescue ArgumentError
-    stamp.to_s
+  def transport_line
+    "The inbox's format is undocumented: checked on #{CHECKED_ON}. A Claude that bypasses permissions holds peer " \
+      "messages for approval."
   end
 
-  # /claude install-skill [--yes]
-  def install_skill(ctx, yes:)
-    source = SCRIPTS_DIRS.map { |dir| File.join(dir, SKILL_FILE) }.find { |path| File.file?(path) }
-    return "/claude install-skill: this bundle has no scripts/#{SKILL_FILE}; reinstall it (chi bundle install claude-peer --force)" unless source
-
-    text = File.read(source).gsub(PAIR_PLACEHOLDER, File.join(File.dirname(source), "pair"))
-                            .gsub(PAYLOADS_PLACEHOLDER, tilde(ctx.data_dir))
-    target = File.join(claude_dir, "skills", "chi-peer", "SKILL.md")
-    yes ? write_skill(ctx, target, text) : skill_card(ctx, target, text)
-  end
-
-  def skill_card(ctx, target, text)
-    current = File.file?(target) ? File.read(target) : nil
-    state = if current.nil? then "Not installed yet."
-            elsif current == text then "Installed and up to date."
-            else "Installed, and different from this bundle's (Replace overwrites it):\n\n```diff\n#{diff(target, text)}\n```"
-            end
+  def setup_paragraph(ctx)
     rule = "Read(#{tilde(ctx.data_dir)}/**)"
-    body = ["Claude Code's side: it pairs (`pair with chi <id>`), answers validates and replies into chi.",
-            "target: `#{target}`", state,
-            "So Claude isn't asked before reading a long part's file, add `#{rule}` to Claude Code's permissions " \
-            "(`permissions.allow` in its settings.json); chi doesn't change Claude's settings."]
-    actions = if current == text
-                []
-              else
-                [{ label: current ? "Replace" : "Install", command: "/claude install-skill --yes" }]
-              end
-    ctx.card(id: SKILL_CARD, title: "Claude's chi-peer skill", body: body.join("\n\n"), actions: actions)
-    nil
-  end
-
-  def write_skill(ctx, target, text)
-    FileUtils.mkdir_p(File.dirname(target))
-    File.write(target, text)
-    ctx.card(id: SKILL_CARD, title: "Claude's chi-peer skill",
-             body: "Installed `#{target}`. In Claude Code, say \"pair with chi #{ctx.session_id.to_s[0, 8]}\".")
-    nil
-  rescue SystemCallError => e
-    "/claude install-skill: couldn't write #{target}: #{e.message}"
+    "So Claude isn't asked before reading a long part's file, add `#{rule}` to Claude Code's permissions " \
+      "(`permissions.allow` in its settings.json); chi doesn't change Claude's settings."
   end
 
   # Claude Code's config folder: CLAUDE_CONFIG_DIR, else ~/.claude.
-  def claude_dir
+  def peer_dir
     dir = ENV.fetch("CLAUDE_CONFIG_DIR", "").strip
     dir.empty? ? File.join(Dir.home, ".claude") : File.expand_path(dir)
   end
 
-  # The first lines of `diff -u installed new`.
-  def diff(target, text)
-    Tempfile.create(["chi-peer", ".md"]) do |file|
-      file.write(text)
-      file.flush
-      out, = Open3.capture2("diff", "-u", "--label", "installed", "--label", "this bundle's", target, file.path)
-      lines = out.lines
-      lines = lines.first(DIFF_LINES) + ["… #{lines.size - DIFF_LINES} more lines\n"] if lines.size > DIFF_LINES
-      lines.join.chomp
-    end
-  rescue SystemCallError
-    "(diff isn't there to show how)"
-  end
-
-  def tilde(path)
-    home = Dir.home
-    path.start_with?("#{home}/") ? "~#{path.delete_prefix(home)}" : path
-  end
-
-  def follow_up(kind)
-    case kind
-    when "context" then "Claude takes it in; it answers only if something in it is wrong."
-    else "Claude's answer comes as an update of the claude-review context; don't wait or poll."
-    end
-  end
-
-  # The paired Claude's inbox socket: the claude-inbox context's hint.
-  def socket_path(ctx)
-    inbox = sources(ctx).find { |source| source[:name] == INBOX }
-    hint = inbox && inbox[:hint].to_s.strip
-    if hint.nil? || hint.empty?
-      raise SendError, "no claude-inbox: pair from Claude (install its skill with /claude install-skill, then " \
-                       "tell Claude \"pair with chi #{ctx.session_id.to_s[0, 8]}\")"
-    end
-    raise SendError, "claude-inbox's hint isn't a socket path (#{hint}): pair again from Claude" unless hint.start_with?("/")
-
-    hint
-  end
-
-  def post(socket, data)
-    UNIXSocket.open(socket) { |conn| write_all(conn, data) }
+  def post(socket, text)
+    UNIXSocket.open(socket) { |conn| write_all(conn, line(text)) }
   rescue Errno::ENOENT, Errno::ECONNREFUSED, Errno::ENOTSOCK
     raise SendError, "that Claude session is gone (no inbox at #{socket}): pair again from Claude"
   rescue SystemCallError, IOError => e
@@ -368,39 +141,4 @@ class Plugin
       data = data.byteslice(written..)
     end
   end
-
-  # sessions/<id>/<HHMMSS>-<slug>.md under the bundle's data dir, readable
-  # by its owner only.
-  def write_payload(ctx, id, title, text)
-    dir = session_dir(ctx, id)
-    base = "#{Time.now.strftime("%H%M%S")}-#{slug(title)}"
-    path = File.join(dir, "#{base}.md")
-    n = 1
-    path = File.join(dir, "#{base}-#{n += 1}.md") while File.exist?(path)
-    File.open(path, "w", 0o600) { |file| file.write(text) }
-    path
-  rescue SystemCallError => e
-    raise SendError, "couldn't write the payload file: #{e.message}"
-  end
-
-  def session_dir(ctx, id)
-    File.join(ctx.data_dir, "sessions", id).tap { |dir| FileUtils.mkdir_p(dir) }
-  end
-
-  def record(ctx, id, **send)
-    entry = { at: Time.now.utc.iso8601, **send }
-    @lock.synchronize { File.write(File.join(session_dir(ctx, id), LAST_SEND), JSON.generate(entry)) }
-  rescue SystemCallError => e
-    ctx.log.info(:last_send_not_saved, error: e.message)
-  end
-
-  def slug(title)
-    slug = title.downcase.gsub(/[^a-z0-9]+/, "-").gsub(/\A-+|-+\z/, "")[0, SLUG_CHARS].delete_suffix("-")
-    slug.empty? ? "part" : slug
-  end
-
-  def one_line(text)
-    line = text.to_s.gsub(/\s+/, " ").strip
-    line.length > TITLE_CHARS ? "#{line[0, TITLE_CHARS - 1]}…" : line
-  end
 end

data/lib/samagotchi/bundles/claude-peer/scripts/chi-peer-SKILL.md

@@ -59,6 +59,9 @@ permissions.
   `file:line` where you can), what is missing, one improvement if it matters,
   and a last line `VERDICT: OK` / `VERDICT: CHANGES` / `VERDICT: UNSURE (why)`.
   Verify claims against the code; say what you did not check.
+- A **validate** whose title you answered before is a follow-up round: chi
+  fixed what you flagged, or disagrees. Check it again and answer the same
+  way; say `VERDICT: OK` once you are satisfied (chi stops the round on it).
 - **context**: take it in for your own work. No reply, unless something in it
   contradicts what you know: then reply with that.
 - **question**: answer it briefly.
@@ -80,9 +83,11 @@ EOF
 - `wake` for a validate or a question (chi asked and is waiting); no `wake`
   for a reply to context.
 - Each answer replaces the last (chi keeps the latest one), so start the
-  summary with the title you are answering.
-- Use `chi send -m "..." <id>` instead only when chi should act on it as a
-  user-style instruction, or the user asks for it.
+  summary with the title you are answering, and end it with your verdict
+  (`VERDICT OK`, `VERDICT CHANGES` or `VERDICT UNSURE`): chi doesn't wake for
+  an OK.
+- Never answer a chi message with `chi send`: it counts as the user typing,
+  outside the round's limit. Use it only when the user asks you to.
 
 ## Don't loop