samagotchi 0.33.0 → 0.35.0

data/lib/samagotchi/broadcast_command.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require_relative "config"
+require_relative "session"
+require_relative "session_inbox"
+require_relative "note_delivery"
+require_relative "broadcast/recipients"
+require_relative "broadcast/scope_card"
+require_relative "broadcast/tags"
+require_relative "cli/command"
+require_relative "cli/flags"
+
+module Samagotchi
+  # `chi broadcast`: share a note with every session it may concern,
+  # without picking them. Each recipient (Broadcast::Recipients) that shares
+  # a tag with the note (Broadcast::Tags) gets it as a context note from
+  # "broadcast"; --all gives it to every recipient. The rest are listed as
+  # skipped, with why. For the user only: refused inside a chi session.
+  class BroadcastCommand
+    include CLI::Command
+
+    SOURCE = "broadcast"
+    # Bytes kept free under SessionInbox's 16 KiB for the line each note
+    # ends with (#body).
+    BODY_ROOM = 512
+    # The longest "because" #body quotes (a link tag can be long).
+    BECAUSE_CHARS = 200
+    # The env every execute/task call exports (Tools::Builtins): set, the
+    # command runs inside a chi session, i.e. an agent runs it.
+    PARENT_ENV = "SAMAGOTCHI_PARENT_SESSION"
+
+    USAGE = <<~TEXT
+      Usage: chi broadcast [-m TEXT] [--all] [--dry-run]
+        Shares TEXT (or stdin) with the sessions it may concern, as a context
+        note from "broadcast": background the model sees on its next turn,
+        not a prompt. It starts no turn.
+        Recipients: your own sessions (not delegate children, not scratch
+        ones) that a worker or a chi REPL runs now, or that ended a turn in
+        the last broadcast.active_hours (8). One gets the note when it shares
+        a tag with it: a ticket id (PAY-123) in its branch or your prompts
+        there, a pull request (PR #42, its URL) attached to it, a link in
+        your prompts there or its attached context. The rest are skipped.
+        -m TEXT    the note; without it, stdin is read
+        --all      every recipient, tag or not
+        --dry-run  show each recipient's scope card, tags and verdict; deliver nothing
+        For you, not for an agent: refused inside a chi session.
+        One session or a few by id: chi note. See docs/broadcast.md.
+    TEXT
+
+    FLAGS = CLI::Flags.new(help: CLI::Command::HELP_WORDS, args: false) do |f|
+      f.switch "--all"
+      f.switch "--dry-run"
+      f.value "-m", "--message", key: :text
+    end
+
+    # One recipient's verdict. +match+: the tag that delivers it (nil with
+    # --all or none); +skip+: why it is skipped, else nil.
+    Verdict = Data.define(:recipient, :match, :skip) do
+      def deliver? = skip.nil?
+    end
+
+    # @param argv [Array<String>] the arguments after "broadcast"
+    # @param active_hours [Numeric, nil] broadcast.active_hours (config)
+    # @param ticket_pattern [String, nil] broadcast.ticket_pattern (config)
+    def initialize(argv, stdin: $stdin, stdout: $stdout, stderr: $stderr, state_dir: nil, env: ENV, now: Time.now,
+                   active_hours: Config.get("broadcast.active_hours"), ticket_pattern: Config.get("broadcast.ticket_pattern"))
+      @argv = argv.dup
+      @stdin = stdin
+      @stdout = stdout
+      @stderr = stderr
+      @state_dir = state_dir || Session.default_state_dir
+      @env = env
+      @now = now
+      @active_hours = active_hours || 8
+      @ticket = Broadcast::Tags.ticket_regexp(ticket_pattern, warn: ->(line) { @stderr.puts("chi broadcast: #{line}") })
+    end
+
+    # @return [Integer] exit status: 0 done (skipped sessions included),
+    #   1 refused, nothing to send to or a delivery failed, 2 usage
+    def run
+      options = parse
+      return options if options.is_a?(Integer)
+
+      unless @env[PARENT_ENV].to_s.empty?
+        error_line("chi broadcast: chi broadcast is for your user, not an agent")
+        return 1
+      end
+
+      text = utf8(options[:text] || read_stdin)
+      return usage_error("no note text: pass -m TEXT or pipe it in") unless text
+
+      begin
+        text = SessionInbox.checked_text(text)
+        limit = SessionInbox::NOTE_MAX_BYTES - BODY_ROOM
+        if text.bytesize > limit
+          raise SessionInbox::NoteRejected, "the note is #{text.bytesize} bytes; a broadcast takes up to #{limit} " \
+                                            "(16 KiB less room for the line chi adds)"
+        end
+      rescue SessionInbox::NoteRejected => e
+        error_line("chi broadcast: #{e.message}")
+        return 1
+      end
+
+      broadcast(text, all: options[:all], dry_run: options[:dry_run])
+    end
+
+    private
+
+    def command_name = "chi broadcast"
+
+    def parse
+      parsed = parse_flags(FLAGS, @argv)
+      parsed.is_a?(Integer) ? parsed : parsed.options
+    end
+
+    # @return [Integer] exit status
+    def broadcast(text, all:, dry_run:)
+      recipients = Broadcast::Recipients.list(state_dir: @state_dir, active_hours: @active_hours, now: @now)
+      if recipients.empty?
+        error_line("chi broadcast: no sessions to send to: none runs now or ended a turn in the last " \
+                   "#{format_hours(@active_hours)} (chi sessions list --scope=all)")
+        return 1
+      end
+
+      note_tags = Broadcast::Tags.of_text(text, from: "note", ticket: @ticket)
+      cards = recipients.to_h { |r| [r.id, Broadcast::ScopeCards.build(r, state_dir: @state_dir, ticket: @ticket)] }
+      verdicts = recipients.map { |r| verdict(r, cards.fetch(r.id), note_tags, all: all) }
+      verdicts = verdicts.select(&:deliver?) + verdicts.reject(&:deliver?)
+
+      @stdout.puts("broadcast#{" (dry run: nothing is delivered)" if dry_run}  #{headline(text)}")
+      @stdout.puts("note tags: #{note_tags.empty? ? "none" : note_tags.map(&:label).join(" · ")}") if dry_run
+      return dry_run(verdicts, cards) if dry_run
+
+      deliver_all(verdicts, text)
+    end
+
+    def verdict(recipient, card, note_tags, all:)
+      return Verdict.new(recipient: recipient, match: nil, skip: "open in a chi REPL") if recipient.repl?
+
+      match = Broadcast::Tags.match(note_tags, card.tags)
+      skip = "no tag match (not checked: no triage yet)" unless all || match
+      Verdict.new(recipient: recipient, match: match, skip: skip)
+    end
+
+    def dry_run(verdicts, cards)
+      verdicts.each do |v|
+        @stdout.puts(line(v.recipient, v.deliver? ? "would get it" : "skipped", reason(v), width: 12))
+        @stdout.puts(cards.fetch(v.recipient.id).to_s.gsub(/^/, "          "))
+      end
+      delivered = verdicts.count(&:deliver?)
+      @stdout.puts("would deliver #{delivered} · skipped #{verdicts.size - delivered}")
+      0
+    end
+
+    def deliver_all(verdicts, text)
+      ok = true
+      lines = verdicts.map do |v|
+        next [v.recipient, false, "skipped", v.skip] unless v.deliver?
+
+        result = NoteDelivery.deliver(v.recipient.id, text: body(text, v.match), source: SOURCE, state_dir: @state_dir)
+        next [v.recipient, false, "skipped", "open in a chi REPL"] unless result.delivered?
+
+        [v.recipient, true, "delivered", "#{reason(v)}#{"; waits for its next start" if result.status == :waits}"]
+      rescue SessionInbox::NoteRejected, SystemCallError => e
+        ok = false
+        [v.recipient, false, "failed", e.message]
+      end
+      lines.sort_by.with_index { |(_, delivered), i| [delivered ? 0 : 1, i] }.each do |recipient, _, word, why|
+        @stdout.puts(line(recipient, word, why))
+      end
+      delivered = lines.count { |_, d| d }
+      @stdout.puts("delivered #{delivered} · skipped #{lines.size - delivered}")
+      ok ? 0 : 1
+    end
+
+    # What a recipient gets: the user's text first (the terminal's "note
+    # from broadcast: …" line shows its start), then a line saying when it
+    # was shared (a session with no worker may read it days later; the
+    # note's header has the time only) and why it reached this session. No
+    # instruction: the system prompt says what a broadcast note asks.
+    def body(text, match)
+      shared = "Shared by your user on #{@now.localtime.strftime("%Y-%m-%d %H:%M")}"
+      return "#{text}\n(#{shared} with every active session.)" unless match
+
+      because = match.because
+      because = "#{because[0, BECAUSE_CHARS - 1]}…" if because.length > BECAUSE_CHARS
+      "#{text}\n(#{shared} with the sessions it may concern; it reached you because #{because}.)"
+    end
+
+    def reason(verdict)
+      verdict.skip || verdict.match&.reason || "--all"
+    end
+
+    def line(recipient, word, why, width: 9) = "#{recipient.short_id}  #{word.ljust(width)}  #{why}"
+
+    # The note's first line, quoted and cut, for the output's head.
+    def headline(text)
+      lines = text.lines
+      first = lines.first.to_s.strip
+      first = "#{first[0, 59]}…" if first.length > 60
+      first = "#{first} …" if lines.size > 1 && !first.end_with?("…")
+      "\"#{first}\""
+    end
+
+    def format_hours(hours)
+      value = hours.to_f
+      "#{value == value.round ? value.round : value} #{value == 1 ? "hour" : "hours"}"
+    end
+
+    # Only a pipe or a file is read, as chi note does: a terminal or a
+    # socket a launcher passes down may never close.
+    def read_stdin
+      return nil if @stdin.respond_to?(:tty?) && @stdin.tty?
+
+      if @stdin.respond_to?(:stat)
+        stat = @stdin.stat
+        return nil unless stat.pipe? || stat.file?
+      end
+
+      @stdin.read
+    end
+
+    # The note as UTF-8 whatever the locale says (see NoteCommand#utf8).
+    def utf8(text)
+      text&.dup&.force_encoding(Encoding::UTF_8)&.scrub
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+---
+name: coordinator
+version: 0.1.2
+scope: system
+description: "Coordinate parallel work: the coordinator skill (split the work, one worktree and child session per task, check each report, ask before each merge), /coordinate <goal> and /children"
+trust_level: reviewed
+files:
+  skill_coordinator.md:
+    sha256: sha256:b21067c3f152c8dfd1b1f70001c6654ad1911616543a36b625727fb13d4ce3f6
+    description: "Coordinate parallel work: split it, delegate each task wait:false in its own worktree (cwd:), check each report, ask the user before each merge"
+plugin:
+  file: plugin.rb
+  sha256: sha256:5173faeb6311984ad4f2a40b9052dcc577a90790fc5c5a8409b95d4f114e66a7
+requires_chi: ">= 0.34.0"

data/lib/samagotchi/bundles/coordinator/plugin.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+# The coordinator bundle (docs/plugins.md, The coordinator bundle): chi as a
+# coordinator of parallel work. Its skill_coordinator memory holds the steps
+# (split the work, one worktree and a wait: false delegate per task, check
+# each report, ask before each merge); this plugin adds two commands.
+#
+# /children [all] shows this session's children as a card, newest first:
+# state, branch, the last reply and whether it was reported (ChildrenStatus
+# through ctx.sessions.children), with a Stop button per running or waiting
+# child and Refresh. `all` adds archived children. The card has one id, so
+# Refresh and Stop replace it. It is read on demand: no thread, no polling.
+#
+# /children stop <id> stops one of this session's own children
+# (ctx.sessions.stop, by session id) and shows the card again.
+#
+# /coordinate <goal> asks the model, in this session, to follow the skill
+# for the goal. A REPL session (--no-shared) takes no messages: the request
+# is shown for the user to send.
+#
+# A child is asked before it changes anything outside its worktree by chi
+# itself (the core child-boundary guardrail), in every mode: nothing to set up.
+class Plugin
+  CARD_ID = "children"
+  # A card takes 6 actions: Refresh and up to 5 Stops.
+  MAX_STOPS = 5
+  STOPPABLE = %w[running waiting].freeze
+  TEXT_CHARS = 80
+  USAGE = "usage: /children [all] | /children stop <id>"
+  COORDINATE_USAGE = "usage: /coordinate <goal> — chi splits it into tasks, one child session and worktree each"
+
+  def initialize(_settings = {}); end
+
+  def register(chi)
+    chi.command "/children", "this session's child sessions: state, branch, last reply; all, stop <id>",
+                anytime: true do |args, ctx|
+      children_command(args.to_s.strip, ctx)
+    end
+    chi.command "/coordinate", "run work in parallel: chi splits <goal> into tasks, each in a child session and worktree",
+                anytime: true do |args, ctx|
+      coordinate(args.to_s.strip, ctx)
+    end
+  end
+
+  private
+
+  def children_command(args, ctx)
+    verb, rest = args.split(/\s+/, 2)
+    case verb
+    when nil then show(ctx, all: false)
+    when "all" then rest.to_s.empty? ? show(ctx, all: true) : USAGE
+    when "stop" then rest.to_s.strip.empty? ? USAGE : stop(rest.strip, ctx)
+    else USAGE
+    end
+  end
+
+  # The card, made or replaced; nil, so the command adds no text of its own.
+  def show(ctx, all:, note: nil)
+    children = ctx.sessions.children(all: all)
+    title = "children of #{ctx.session_id.to_s[0, 8]}"
+    title += " (#{children.size})" unless children.empty?
+    body = children.empty? ? "no children" : children.map { |child| line(child) }.join("\n")
+    body = "#{note}\n\n#{body}" if note
+    refresh = all ? "/children all" : "/children"
+    stops = children.select { |child| STOPPABLE.include?(child[:state]) }.first(MAX_STOPS)
+                    .map { |child| { label: "Stop #{child[:short_id]}", command: "/children stop #{child[:short_id]}" } }
+    ctx.card(id: CARD_ID, title: title, body: body, actions: [{ label: "Refresh", command: refresh }, *stops])
+    nil
+  end
+
+  # - `ab12cd34` · running · fix/flaky · "fix the flaky spec…"
+  # - `9a8b7c6d` · done · feat/x · reported · "All 12 specs pass…"
+  # - `77aa66bb` · waiting (approval) · open it: chi --attach 77aa66bb
+  def line(child)
+    parts = ["`#{child[:short_id]}`", child[:waiting] ? "waiting (#{child[:waiting]})" : child[:state]]
+    parts << child[:branch] if child[:branch]
+    parts << "fork" unless child[:delegate]
+    parts << "archived" if child[:archived]
+    if child[:waiting]
+      parts << "open it: chi --attach #{child[:short_id]}"
+    elsif child[:last_reply]
+      parts << (child[:reported] ? "reported" : "not reported yet")
+      parts << quote(child[:last_reply])
+    elsif !child[:title].to_s.strip.empty?
+      parts << quote(child[:title])
+    end
+    "- #{parts.join(" · ")}"
+  end
+
+  def stop(id, ctx)
+    stopped = ctx.sessions.stop(id)
+    show(ctx, all: false, note: "stopped #{stopped[0, 8]}")
+  rescue Samagotchi::Plugin::Sessions::Error => e
+    "/children stop: #{e.message}"
+  end
+
+  def coordinate(goal, ctx)
+    return COORDINATE_USAGE if goal.empty?
+
+    request = "Read the skill_coordinator memory and follow it for this goal:\n\n#{goal}"
+    begin
+      ctx.sessions.send(ctx.session_id, request)
+    rescue Samagotchi::Plugin::Sessions::Error => e
+      return "/coordinate: #{e.message}. Send this yourself:\n\n#{request}"
+    end
+    "asked chi to coordinate it; a running turn gets it at its next step"
+  end
+
+  def quote(text)
+    line = text.to_s.gsub(/\s+/, " ").strip
+    line = "#{line[0, TEXT_CHARS - 1]}…" if line.length > TEXT_CHARS
+    "\"#{line}\""
+  end
+end

data/lib/samagotchi/bundles/coordinator/skill_coordinator.md

@@ -0,0 +1,60 @@
+# Skill: coordinator
+
+Use when the user hands over work with several independent parts, or asks to "run it in parallel",
+"delegate", "coordinate". The user decides; you do the legwork and keep them in the loop briefly.
+
+## Steps
+1. Find the repository's default branch, <default> below: `git symbolic-ref --short
+   refs/remotes/origin/HEAD` (drop the `origin/`), else `main` or `master`, whichever exists; ask the
+   user if unsure. Split the work into independent tasks (at most session.max_children at once,
+   default 4). Tell the user the split in a few lines and go on unless they object.
+2. For each task: from your own folder, `git worktree add ../<repo>-<task> -b <type>/<task>` with
+   execute; then `delegate` with `wait: false`, `cwd:` that worktree's absolute path, and a
+   self-contained task. The task starts with "Work only in <absolute worktree path>: every cd, read,
+   write, test and commit goes there, never the project root" and says what to report (the result,
+   evidence: commands and what they printed, what isn't done) and "commit on the branch, don't merge,
+   don't push".
+3. Tell the user what started (one line per child: its id, branch and task) and end your turn or keep
+   talking. Don't call delegate_result: chi brings each child's reply as a delegate report, also when
+   you are idle.
+4. On each report, check it before telling the user: `git -C <worktree> log --oneline <default>..` and
+   `git diff --stat <default>...<branch>`; run the tests the child names (execute with cwd: the worktree).
+   Say the result in one or two lines: done and verified / done with doubts / failed.
+5. Then one of: a follow-up (`delegate session: <id>`, narrower, `wait: false`; then end your turn:
+   its report comes by itself, so don't wait for it with delegate_result or task_wait), stop it
+   (`chi sessions stop <session id>` with execute; task_stop is for task ids, not children; the user
+   can use /children), or tell the user it is ready to merge.
+6. Merging is the user's call: ask (ask_user_question) per branch, "Merge <branch> into <default>?".
+   Before merging, in your own folder: `git branch --show-current` must print <default> (if it
+   doesn't, stop and ask the user; don't switch branches yourself); then check <default>:
+   `git log --oneline -3 <default>` and `git merge-base --is-ancestor <branch> <default>`; if the branch is already in, say so and don't merge
+   again. Merge with `git merge --ff-only <branch>` yourself, in your own folder. If that fails, ask the
+   child to rebase its branch on <default> (a follow-up that says "rebase only, don't merge") or ask the
+   user; don't rebase it from here (the branch is checked out in the child's worktree). Children
+   never merge. Never push unless asked.
+7. Clean up only a branch that was merged or that the user said to drop: stop its child
+   (`chi sessions stop <session id>`), then `git worktree remove ../<repo>-<task>`, then
+   `git branch -d <branch>` (in that order: a branch checked out in a worktree can't be deleted). If
+   `-d` refuses, say why to the user; never `-D` unless they say so. Remove only worktrees and
+   branches you created in this session. Every other branch stays as it is, its child, worktree and
+   branch too (the user said "keep it", or didn't say): leave them and tell the user they remain.
+8. When all are done, report: what merged, what didn't and why, what you cleaned up and what remains,
+   follow-ups found but not fixed. Report only what the commands' output showed: a step you planned
+   but didn't run, or whose output you didn't see, is not done; say so.
+
+## Gotchas
+- Children are asked before changing anything outside their worktree (your checkout, a sibling's):
+  the user approves it on the child's card. Still check where commits landed (step 4).
+- Never kill processes by a pid from a file or an old note; stop children with `chi sessions stop
+  <session id>` (execute) and background tasks with task_stop (task ids only: it doesn't stop a child).
+- A child's tool approvals go to the user on the child's card; tell the user when a report says a
+  child waits for one.
+- A report is the child's claim: verify it (step 4) before telling the user it is done, and check
+  where its commits landed: `git log --oneline <default>..<branch>` has them and `git status` in your own
+  folder is clean. A child that worked in your folder instead of its worktree: tell the user.
+- Don't send a follow-up to a child that is still running; wait for its report.
+- Don't start more children than the user asked for.
+
+## Changelog
+- 2026-10-06 created (coordinator bundle 0.1.0)
+- 2026-10-06 clean up only merged or dropped branches; report only what commands showed (0.1.2)

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

@@ -1,10 +1,10 @@
 ---
 name: dev
-version: 0.2.0
+version: 0.3.0
 scope: system
 description: "Developer tools"
 trust_level: reviewed
-requires_chi: ">= 0.32.0"
+requires_chi: ">= 0.34.0"
 includes:
 - known-names
 - mcp
@@ -12,3 +12,4 @@ includes:
 - skills
 - source-links
 - github-pr
+- coordinator

data/lib/samagotchi/bundles/guardrails/guardrails/rules.yml

@@ -128,6 +128,17 @@ rules:
     scopes: [once]
     reason: attaches a command chi will run every few minutes, outside the guardrails
 
+  # ── chi broadcast: for the user, not an agent ─────────────────────────
+  # chi broadcast refuses to run inside a session (SAMAGOTCHI_PARENT_SESSION
+  # is set there), but an agent can unset that; this asks every time, and
+  # only the user may allow it. Quoted words and continuations still match.
+  - id: chi-broadcast
+    tool: shell
+    command: '\bchi["'']?[\s\\]+["'']?broadcast\b'
+    verdict: ask
+    scopes: [once]
+    reason: shares a note with every session it may concern; chi broadcast is for the user, not an agent
+
   # ── answering chi's own questions around chi answer ───────────────────
   # A parent agent answers a child's approval with chi answer, which holds it
   # to guardrails.parent_approvals. These shapes go around that: chi --attach

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

@@ -1,8 +1,8 @@
 ---
 name: guardrails
-version: 0.6.0
+version: 0.7.0
 scope: system
-description: Optional default guardrail rules (git push/rewrites, rm -rf wide, curl | sh, git hooks, chi's own config and attached context from the shell, chi context add --cmd, answering chi around chi answer; in strict mode also git rebase and writes and git in another checkout outside the session's repo), asks only small models get (git checkout --/restore, git stash drop), and a note for the model
+description: Optional default guardrail rules (git push/rewrites, rm -rf wide, curl | sh, git hooks, chi's own config and attached context from the shell, chi context add --cmd, chi broadcast, answering chi around chi answer; in strict mode also git rebase and writes and git in another checkout outside the session's repo), asks only small models get (git checkout --/restore, git stash drop), and a note for the model
 trust_level: reviewed
 # models: in small-models.yml (guardrails.small_models) needs 0.8.1; git: in rules.yml needs 0.17.0;
 # skip_read_only:, touches:, rm: and modes: need 0.20.0

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

@@ -1,11 +1,11 @@
 ---
 name: mcp
-version: 0.4.4
+version: 0.4.5
 scope: system
 description: "Tools from MCP servers (stdio): each server in config.yml bundles: mcp: servers: runs for the session, its tools are mcp_<server>_<tool>; /mcp lists them"
 trust_level: reviewed
 files: {}
 plugin:
   file: plugin.rb
-  sha256: sha256:05543038e2950a5391655184f57a1028133eda8ca05f9e46e5cd2eddc3e9e608
-requires_chi: ">= 0.8.0"
+  sha256: sha256:1ebedc86cd21c918766c794015b6bd16c397c0f7e2734d939d8310d446b8a9a1
+requires_chi: ">= 0.33.0"

data/lib/samagotchi/bundles/mcp/plugin.rb

@@ -31,6 +31,7 @@
 require "digest"
 require "json"
 require "open3"
+require "samagotchi/process_group"
 require "time"
 require "shellwords"
 require "tmpdir"
@@ -59,6 +60,9 @@ class Plugin
     class Dead < Error; end
 
     POLL_SECONDS = 0.1
+    # How long close waits for the server after closing its stdin, after
+    # TERM, and after KILL.
+    STOP_GRACE_SECONDS = 1
 
     attr_reader :pid
 
@@ -136,14 +140,15 @@ class Plugin
     end
 
     # End the process: stdin closed first (most servers leave then), then
-    # TERM and KILL to its process group.
+    # TERM and KILL to its process group (chi's ProcessGroup), a second's
+    # grace each.
     def close
       @mutex.synchronize { @closing = true }
       [@stdin].each { |io| io.close unless io.closed? }
-      unless @wait.join(1)
-        signal("TERM")
-        signal("KILL") unless @wait.join(1)
-        @wait.join(1)
+      unless @wait.join(STOP_GRACE_SECONDS)
+        Samagotchi::ProcessGroup.stop(@pid, grace: STOP_GRACE_SECONDS, poll: STOP_GRACE_SECONDS,
+                                            stopped: -> { !@wait.alive? }, wait: ->(seconds) { @wait.join(seconds) })
+        @wait.join(STOP_GRACE_SECONDS)
       end
       [@stdout, @stderr].each { |io| io.close unless io.closed? }
       [@reader, @err_reader].each { |t| t.join(1) }
@@ -234,12 +239,6 @@ class Plugin
       @on_exit&.call(reason) unless closing
     end
 
-    def signal(name)
-      Process.kill(name, -@pid)
-    rescue Errno::ESRCH, Errno::EPERM
-      nil
-    end
-
     def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
   end
 

data/lib/samagotchi/bundles/source-links/hooks/source_links.rb

@@ -8,7 +8,9 @@ require "open3"
 # web, each ref in the answer becomes a link (`[JIRA-123](https://…)`,
 # through event[:present]: display only, the model's text stays as it was,
 # and it survives a reload). Every UI also gets one line right after the
-# turn, the terminals' only view of the links:
+# turn, the terminals' only view of the links (marked fallback_for:
+# :display when the answer links every URL it names, so the web with
+# markdown on leaves it out; needs chi 0.35.0):
 #
 #   sources: JIRA JIRA-123 → https://myjira.com/browse/JIRA-123, JIRA JIRA-10 → https://myjira.com/browse/JIRA-10
 #
@@ -48,8 +50,8 @@ require "open3"
 # of these stays text (warned at load).
 #
 # The note is not stored in the conversation: it is an event, replayed by a
-# UI only while the session's worker lives (a reload keeps it; a stopped
-# worker loses it). The links are stored as the answer's display. A ref in
+# UI with the session's cards (a reload keeps it, after the worker stopped
+# too: cards.json). The links are stored as the answer's display. A ref in
 # code (a `span` or a fenced block) or in a markdown link is not linked in
 # the answer. The hook is inert until sources are configured.
 class SourceLinks
@@ -114,17 +116,34 @@ class SourceLinks
     return if text.nil? || text.empty?
 
     hits = occurrences(text[0, MAX_SCAN])
-    if @note
-      found = collect(hits)
-      event[:notify]&.call(line(found), level: :info) unless found.empty?
-    end
-    # The answer as shown: the model's text unless an earlier hook changed
-    # it (then its offsets differ, so it is scanned again).
-    event[:present]&.call { |shown| link(shown, shown == text ? hits : nil) }
+    linked = present_links(event[:present], text, hits)
+    return unless @note
+
+    found = collect(hits)
+    return if found.empty?
+
+    # The display links every URL the note names: the note only stands in
+    # for it, and a UI that renders the display's links leaves it out.
+    covered = linked && found.all? { |_name, _ref, url| linked.key?(url.downcase) }
+    event[:notify]&.call(line(found), level: :info, fallback_for: covered ? :display : nil)
   end
 
   private
 
+  # Links the refs in the answer as shown: the model's text unless an
+  # earlier hook changed it (then its offsets differ, so it is scanned
+  # again). The URLs it linked (downcased, as #collect dedups), or nil when
+  # the display didn't take them (no event[:present], nothing to present, or
+  # the presenter rejected the text).
+  def present_links(present, text, hits)
+    return nil unless present
+
+    linked = {}
+    ours = nil
+    shown = present.call { |display| ours = link(display, display == text ? hits : nil, linked) }
+    ours.nil? || shown != ours ? nil : linked
+  end
+
   # The content of the last `role: "model"` message, or nil. Handles both
   # string- and symbol-keyed messages. A turn that ended without a visible
   # answer stores a `kind: turn_note` system message instead, so the role
@@ -198,8 +217,8 @@ class SourceLinks
 
   # +text+ with each ref as a markdown link, every occurrence; the part
   # beyond MAX_SCAN stays as it is. +hits+ are the scan of that text when
-  # the caller has it.
-  def link(text, hits = nil)
+  # the caller has it; +linked+ gets each linked URL, downcased.
+  def link(text, hits = nil, linked = {})
     head = text[0, MAX_SCAN]
     hits ||= occurrences(head)
     out = +""
@@ -208,6 +227,7 @@ class SourceLinks
       next if hit[:quiet] || hit[:start] < pos # two sources on one ref: the first wins
 
       out << head[pos...hit[:start]] << "[#{hit[:ref].gsub(/[\[\]]/) { |c| "\\#{c}" }}](#{link_target(hit[:url])})"
+      linked[hit[:url].downcase] = true
       pos = hit[:finish]
     end
     return text if pos.zero?

data/lib/samagotchi/bundles/source-links/manifest.yml

@@ -1,14 +1,15 @@
 ---
 name: source-links
-version: 0.3.4
+version: 0.4.0
 scope: system
 description: Links source refs (JIRA tickets, GitHub issues, …) in the model's answer — inline links in the web, and a one-line note after the turn (note false turns it off); sources are configured patterns
 trust_level: reviewed
+requires_chi: ">= 0.35.0"
 files:
-  source_links.md: sha256:aebd37f1e25491780994ecc4afc20ed6e8db32b724dc038302bb050177efada8
+  source_links.md: sha256:1670a3051b67610f41a680fc8e61bc1c99657a87f0f32121d040e05512896748
 hooks:
   source_links.rb:
-    sha256: sha256:c93269964ebc824b5f15ab60db81a458facd50de61446c550f254ea4c68964e2
+    sha256: sha256:8ce4d11659f4bc151167f99e47299c0f6ef246797c9167c609c1699e3edea2e5
     event: after_turn
     on_error: log
     priority: 90

data/lib/samagotchi/bundles/source-links/source_links.md

@@ -1,5 +1,5 @@
 # Source links
 
-The `source-links` bundle's `after_turn` hook links the source refs (a JIRA ticket, a GitHub issue, …) in your answers. In the web, each ref in the answer becomes a link; that is how the answer is **shown**, not what you wrote: your own message keeps the plain ref. A `sources: NAME ref → url, …` line right after an answer is the same hook's note, which every UI shows (the terminals only see this line). The line is **not part of the conversation**: it is an event, so it is not in the session file and you cannot refer back to it. A UI replays it while the session's worker lives (a page reload keeps it; a stopped worker loses it).
+The `source-links` bundle's `after_turn` hook links the source refs (a JIRA ticket, a GitHub issue, …) in your answers. In the web, each ref in the answer becomes a link; that is how the answer is **shown**, not what you wrote: your own message keeps the plain ref. A `sources: NAME ref → url, …` line right after an answer is the same hook's note (the terminals only see this line). The web leaves it out when markdown is on and the answer links every ref it names; otherwise every UI shows it. The line is **not part of the conversation**: it is an event, so it is not in the session file and you cannot refer back to it. A UI replays it with the session's cards (a page reload keeps it, after the worker stopped too).
 
 The refs come from the `bundles: source-links:` section of config.yml: each source is a `prefix:` + `base_url:` pair (simple) or a `pattern:` regex + `url:` template (full form), plus an optional `max:` for refs per line and `note: false` to drop the line (the web links stay). A `url:` template can take the project's own repo from its git remote, so a bare `#12` links to this project's issue and `owner/repo#12` to that repo's. With no sources configured the hook does nothing. A ref already inside a URL is not linked again, and a ref in code or in a markdown link is not linked in the answer.

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

@@ -5,6 +5,6 @@ Another chi session (the parent) gave you this task. It reads only your last mes
 - Finish the task in this turn if you can. End with one reply the parent can act on without asking back: the result first, then evidence (paths, commands run and what they printed), then anything you could not verify or finish.
 - Do only what the task asks. A question ("why does this spec fail?", "what calls X?", "check whether…") gets a report, not file changes: say what you found and what change you would make, and leave making it to the parent. Edit files only when the task asks you to change, fix, add or write something, and then only the files that takes.
 - The parent may send follow-up messages later; each one is a new turn in this same session, with what you did so far.
-- Work in the directory you were started in. Don't change config, install bundles, edit managed files or write memories unless the task asks for it.
+- Work in the directory you were started in: every cd, read, edit, test and commit stays in it (in a linked worktree, never the repository's other checkouts). Don't change config, install bundles, edit managed files or write memories unless the task asks for it.
 - You can't delegate further. Don't start other chi sessions, and send notes only to the parent.
 - If you are blocked, stop and say so in the reply with the exact question. Use ask_user_question only when the task says the user is watching.