samagotchi 0.32.0 → 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/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/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.

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

@@ -1,11 +1,11 @@
 ---
 name: samagotchi-system
-version: 0.32.0
+version: 0.34.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:
   identity.md: sha256:29c2f7df9f6c5acbc5ec17000a4490741e55e426af15ca0d81c8706edd9bd027
-  self_map.md: sha256:8b05db6989662e4409b34d73ce4368588c874501e6e917e6dee70dfb1e3f5157
+  self_map.md: sha256:eb017702746f9aad96404d9982a3c27bec717906fa2a14175ab207ad6f843f72
   config_modification_protocol.md: sha256:ec0b0c7023dbf03b93879e51cd5cdc38b22d43a2e5984ee11e8542ace077c3be
-  memory_guide.md: sha256:17126f5adb9ef7b33c40e920ef339388c8c8c045b38a7de825b08760604db4e4
-  delegated.md: sha256:eaaf66830d3ab1346c75812a5fc8fcb9d3dbaa6a3f6bcf47c103155d96e415b5
+  memory_guide.md: sha256:63d5d7f7d704e6ce7e28dd99e532b714c1b9f7acf548092404248d8ca5385b80
+  delegated.md: sha256:aedaa1e756a244904c5560fff0424e06fb468bbdcb0358bccefe321d67cd2614

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

@@ -15,7 +15,7 @@ This memory teaches you (the agent) how to use Samagotchi memories — persisten
 | `system` | `$XDG_CONFIG_HOME/samagotchi/memories/`, default `~/.config/samagotchi/memories/` (`MemoryPaths.system_dir`) | User-wide preferences, identity, cross-project knowledge |
 | `project` | `<system dir>/projects/<basename>_<hash>/` (`MemoryPaths.project_dir`: `basename(root)` + 8-char `MD5(root)`, root = `MemoryPaths.project_root`) | Repo-specific conventions, workflow, stack decisions |
 
-- The project root is the git repository: its common git dir, which every linked worktree shares. All worktrees and subdirectories of one repository share one project folder; the system prompt shows the resolved root and folder. Outside a repository the root is the working directory. A separate clone is a different project.
+- The project root is the git repository: its common git dir, which every linked worktree shares. All worktrees and subdirectories of one repository share one project folder; the system prompt shows that folder (not the root: in a linked worktree, work stays in the worktree). Outside a repository the root is the working directory. A separate clone is a different project.
 - `index.md` lives in each scope dir and contains auto-managed lines like `- **name** · scope · date · bytes — description`; a memory a bundle installed adds `· from <bundle>` before the description. Your free-form sections in `index.md` are preserved but managed lines are owned by `memory_write` (and refreshed when `write`/`edit` change a memory's file).
 
 ## Tools you have

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

@@ -30,8 +30,10 @@
   `chi send --new --wait -m TEXT` starts a session the user can watch in the web and prints its
   answer (exit 3: it waits for the user's answer); see "Starting a session".
 - `delegate` hands a task to a child session that runs in parallel and returns only its final
-  reply (`delegate_result` waits for it; with `wait: false` chi brings the reply to me by itself
-  as a delegate report when the child ends its turn; `session:` sends a follow-up to a child). A child is a
+  reply (`wait: false` is the usual way: I end my turn or keep talking with my user, and chi
+  brings the reply to me by itself as a delegate report when the child ends its turn, starting a
+  turn for it if I'm idle; `delegate_result` only when this turn can't go on without the reply;
+  `session:` sends a follow-up to a child). A child is a
   normal session: it shows in `chi sessions list` with `↳ <parent>`, and the user can steer it
   with `chi --attach <id>`. While I wait for a child, its tool approvals go to my user as my own
   approvals (I see only how each was answered); see `docs/sessions.md` "Delegating".

data/lib/samagotchi/child_reports.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require_relative "client_id"
 require_relative "session"
 require_relative "session_inbox"
 require_relative "reply_wait"
@@ -29,6 +30,13 @@ module Samagotchi
     # Turns an idle parent runs for reports in a row with no human input.
     MAX_WAKES_KEY = "session.max_wakes"
     MAX_WAKES_DEFAULT = 10
+    # How long a leaving worker waits for the parent wakes it started
+    # (#await_wakes): a wake only spawns a worker, well under a second.
+    WAKE_JOIN_SECONDS = 5
+
+    # The wake threads #ring started in this process, until #await_wakes.
+    @wakes = []
+    @wakes_mutex = Mutex.new
 
     module_function
 
@@ -70,15 +78,29 @@ module Samagotchi
     def wake_parent(parent_id, state_dir:, wake:)
       return if SessionManager.session_owner(parent_id, state_dir: state_dir)
 
-      if wake
-        wake.call(parent_id)
-      else
-        Thread.new do
-          SessionManager.wake_for_report(parent_id, state_dir: state_dir)
-        rescue StandardError => e
-          Log.warn(:worker, "delegate_wake_failed", parent: parent_id[0, 8], error: e.class.name, msg: e.message)
-        end
+      return wake.call(parent_id) if wake
+
+      thread = Thread.new do
+        SessionManager.wake_for_report(parent_id, state_dir: state_dir)
+      rescue StandardError => e
+        Log.warn(:worker, "delegate_wake_failed", parent: parent_id[0, 8], error: e.class.name, msg: e.message)
       end
+      @wakes_mutex.synchronize { @wakes = @wakes.select(&:alive?) << thread }
+      thread
+    end
+
+    # Waits up to +timeout+ for the parent wakes this process started: a
+    # worker's teardown, since its process exits right after (a crash's
+    # ring comes just before it) and an exit kills a wake midway, before
+    # it spawned the parent's worker.
+    # @return [Integer] the wakes still running after it
+    def await_wakes(timeout = WAKE_JOIN_SECONDS)
+      threads = @wakes_mutex.synchronize { @wakes.tap { @wakes = [] } }
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+      threads.each { |thread| thread.join([deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC), 0].max) }
+      left = threads.count(&:alive?)
+      Log.warn(:worker, "delegate_wakes_left", count: left) if left.positive?
+      left
     end
   end
 
@@ -93,7 +115,6 @@ module Samagotchi
   # failed: the next turn reads the same rings again.
   class ChildReports
     SOURCE = Steer::DELEGATE_REPORT
-    CLIENT_PREFIX = Steer::CHILD_CLIENT_PREFIX
 
     # A report for the model: the text delegate_result would return
     # (DelegateWait.finish, its report variant), the cursor it moves the child to,
@@ -101,7 +122,7 @@ module Samagotchi
     # itself, with delegate_result, leaves it alone).
     Report = Data.define(:child_id, :text, :before, :after, :rings) do
       def line(mark: nil) = Steer::Line.new(text: text, source: ChildReports::SOURCE, mark: mark)
-      def origin = { client_id: "#{ChildReports::CLIENT_PREFIX}#{child_id[0, 8]}" }
+      def origin = { client_id: "#{ClientId::CHILD_PREFIX}#{child_id[0, 8]}" }
     end
 
     def initialize(session_id:, state_dir:)

data/lib/samagotchi/children_status.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "session"
+require_relative "archive_store"
+require_relative "memory_paths"
+require_relative "reply_wait"
+require_relative "tools/delegate"
+require_relative "tools/delegate_cursor"
+
+module Samagotchi
+  # Loaded on first use: session_manager requires terminal_ui, which
+  # requires KernelLoop and so the tools (a require cycle otherwise).
+  autoload :SessionManager, File.expand_path("session_manager", __dir__)
+
+  # A parent's children as `/children` and the glance views show them: one
+  # Child per child session, read from the files layer 1 already writes
+  # (the session JSON, its output/ replies, the parent's delegates.json).
+  # Nothing here runs git or a subprocess.
+  module ChildrenStatus
+    # One child of a session.
+    # @!attribute state [String] waiting, running, failed, stopped, done or
+    #   idle (STATES, in the order they are decided)
+    # @!attribute waiting [String, nil] what it waits for: question,
+    #   approval, hook or continue
+    # @!attribute delegate [Boolean] a `delegate` child; false for a fork
+    # @!attribute branch [String, nil] the branch checked out in its folder
+    #   (a short sha when detached); nil outside git
+    # @!attribute last_reply [String, nil] the first line of its newest reply
+    # @!attribute reported [Boolean] the parent was already given that reply
+    #   (a delegate report or a wait); false when there is none
+    Child = Data.define(:id, :short_id, :title, :state, :waiting, :live, :delegate, :cwd, :branch,
+                        :last_reply, :last_reply_at, :reported, :updated_at, :archived)
+
+    # The glance views' numbers: children running, waiting for an answer,
+    # and with a reply the parent wasn't given yet.
+    Counts = Data.define(:running, :waiting, :unreported) do
+      def self.none = new(running: 0, waiting: 0, unreported: 0)
+    end
+
+    STATES = %w[waiting running failed stopped done idle].freeze
+
+    module_function
+
+    # Every child of +parent_id+, newest first: delegates and forks (a fork
+    # is delegate: false), archived ones only with +include_archived+. Scans
+    # every session (SessionManager.children_of): for on-demand use.
+    # @return [Array<Child>]
+    def of(parent_id, state_dir:, include_archived: false)
+      cursors = Tools::DelegateCursors.read(parent_id, state_dir: state_dir)
+      SessionManager.children_of(parent_id, state_dir: state_dir).filter_map do |row|
+        next if row[:archived] && !include_archived
+
+        session = load(row[:id], state_dir: state_dir)
+        session && child(session, row, cursors, state_dir: state_dir)
+      end
+    end
+
+    # The cheap path for the glance views: only the children in the
+    # parent's delegates.json (one Session.load and an owner check each, no
+    # scan). Its keys can also name a fork the model passed to delegate
+    # session: or a deleted child: only live delegates of this parent count,
+    # archived ones don't.
+    # @return [Counts]
+    def counts(parent_id, state_dir:)
+      cursors = Tools::DelegateCursors.read(parent_id, state_dir: state_dir)
+      children = cursors.keys.filter_map do |id|
+        session = load(id, state_dir: state_dir)
+        next unless session&.delegate? && session.parent_id == parent_id
+        next if ArchiveStore.archived?(Session.session_dir(id, state_dir: state_dir))
+
+        child(session, summary_of(session, state_dir: state_dir), cursors, state_dir: state_dir)
+      end
+      Counts.new(running: children.count { |c| c.state == "running" },
+                 waiting: children.count { |c| c.state == "waiting" },
+                 unreported: children.count { |c| c.last_reply && !c.reported })
+    end
+
+    # @param row [Hash] a children_of row, or summary_of's keys
+    # @param cursors [Hash] the parent's delegates.json
+    def child(session, row, cursors, state_dir:)
+      reply = ReplyWait.newest_reply(session.id, state_dir: state_dir)
+      cursor = Tools::DelegateCursors.get_from(cursors, session.id)
+      Child.new(id: session.id, short_id: session.id[0, 8], title: row[:preview].to_s,
+                state: state_of(session, row, reply), waiting: row[:waiting], live: !!row[:live],
+                delegate: session.delegate?, cwd: session.working_directory, branch: branch(session.working_directory),
+                last_reply: reply && first_line(session.id, reply, state_dir: state_dir),
+                last_reply_at: reply && reply_time(reply), reported: !reply.nil? && cursor.reply_file == reply,
+                updated_at: session.updated_at, archived: !!row[:archived])
+    end
+    private_class_method :child
+
+    def state_of(session, row, reply)
+      return "waiting" if row[:waiting]
+      return "running" if Tools::Delegate.running?(row)
+      return "stopped" if session.status == Session::STATUS_STOPPED
+
+      outcome = session.last_turn.is_a?(Hash) ? session.last_turn["outcome"] : nil
+      return "failed" if session.status == Session::STATUS_ERROR || outcome == "failed"
+      return "done" if outcome == "completed" && reply
+
+      "idle"
+    end
+    private_class_method :state_of
+
+    # The keys of a children_of row that state_of and child read, for a
+    # session counts loaded itself.
+    def summary_of(session, state_dir:)
+      live = SessionManager.worker_live?(session.id, state_dir: state_dir)
+      { live: live, busy: live && session.status == Session::STATUS_RUNNING, status: session.status,
+        updated_at: session.updated_at, waiting: session.waiting_question(live: live)&.dig(:kind),
+        preview: session.last_prompt.to_s }
+    end
+    private_class_method :summary_of
+
+    # The branch from the folder's own HEAD file (a linked worktree's is
+    # under .git/worktrees/<name>), read without git.
+    # @return [String, nil]
+    def branch(cwd)
+      dir = MemoryPaths.git_dir(cwd.to_s)
+      head = dir && File.read(File.join(dir, "HEAD"), 512).strip
+      return nil if head.nil? || head.empty?
+
+      head.start_with?("ref:") ? head.delete_prefix("ref:").strip.delete_prefix("refs/heads/") : head[0, 8]
+    rescue SystemCallError
+      nil
+    end
+    private_class_method :branch
+
+    def first_line(id, file, state_dir:)
+      text = File.read(File.join(ReplyWait.reply_dir(id, state_dir: state_dir), file), 4096)
+      text.each_line.map(&:strip).find { |line| !line.empty? }.to_s
+    rescue SystemCallError
+      nil
+    end
+    private_class_method :first_line
+
+    # Reply files are named by the local time they were written
+    # (SessionInbox.write_output, %Y%m%d%H%M%S then nanoseconds).
+    # @return [Time, nil] nil for a name that isn't one
+    def reply_time(file)
+      Time.strptime(File.basename(file, ".txt")[0, 14], "%Y%m%d%H%M%S")
+    rescue ArgumentError, TypeError
+      nil
+    end
+    private_class_method :reply_time
+
+    def load(id, state_dir:)
+      return nil unless Session.exist?(id, state_dir: state_dir)
+
+      Session.load(id, state_dir: state_dir)
+    rescue ArgumentError
+      nil
+    end
+    private_class_method :load
+  end
+end

data/lib/samagotchi/client_id.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # Who sent a turn, a line or an answer: its client_id, as a turn's origin,
+  # an input file and the events carry it. The one table of the ids chi
+  # makes, and of which of them are a human's input (#human?). No requires,
+  # so any file can use it.
+  module ClientId
+    # A web tab (web:<random>, per tab); web:restart, the page's Restart.
+    WEB_PREFIX = "web:"
+    WEB_RESTART = "web:restart"
+    # An attached chi TUI: tui:<pid>.
+    TUI_PREFIX = "tui:"
+    # chi send's turns and commands.
+    CLI_SEND = "cli:send"
+    # chi answer's answers (a parent agent's, Guardrails::ParentApprovals).
+    CLI_ANSWER = "cli:answer"
+    # chi restart.
+    CLI_RESTART = "cli:restart"
+    # A delegating parent's task or follow-up: delegate:<parent8>.
+    DELEGATE_PREFIX = "delegate:"
+    # A delegate child's report (ChildReports): child:<child8>.
+    CHILD_PREFIX = "child:"
+    # A turn chi ran because an attached context source changed:
+    # context:<name> (Worker's context wake).
+    CONTEXT_PREFIX = "context:"
+    # chi's own turns; system:reminder, the turn queued when reminders are due.
+    SYSTEM_PREFIX = "system:"
+    REMINDER = "system:reminder"
+    # A plugin's message (Plugin::Sessions#send).
+    PLUGIN = "plugin"
+    # A relayed answer (RelayVerifier): relay:<parent8>.
+    RELAY_PREFIX = "relay:"
+
+    # Input a human typed: a web tab, a chi TUI, chi send, and nil (a
+    # worker's initial prompt; a web client may send none). An allowlist:
+    # delegates, plugins, reminders, context changes and any id chi doesn't
+    # know are not.
+    HUMAN_PREFIXES = [WEB_PREFIX, TUI_PREFIX].freeze
+    HUMAN_IDS = [CLI_SEND].freeze
+
+    module_function
+
+    # Whether +client_id+ (a turn's or a line's origin) is a human's input.
+    def human?(client_id)
+      return true if client_id.nil?
+
+      id = client_id.to_s
+      HUMAN_IDS.include?(id) || HUMAN_PREFIXES.any? { |prefix| id.start_with?(prefix) }
+    end
+  end
+end

data/lib/samagotchi/context_absorber.rb

@@ -118,7 +118,8 @@ module Samagotchi
       if sub.seen != snapshot.revision
         args = { name: name, hint: hint, summary: snapshot.summary, changes: snapshot.serial - sub.seen_serial }
         found = delivery(name, text_note_id(name, snapshot), self.class.updated_text(**args), now, seen(sub, snapshot))
-        return found unless snapshot.wake
+        # Any revision since the one the session last saw may have asked.
+        return found unless snapshot.wake_serial.to_i > sub.seen_serial
 
         return found.with(wake_note: found.note.merge(text: self.class.updated_text(**args, wake: true)))
       end