samagotchi 0.34.0 → 0.36.0

data/lib/samagotchi/bridge/card_store.rb

@@ -201,7 +201,7 @@ module Samagotchi
       end
 
       def add_notice(event)
-        notice = event.slice(:type, :hook, :text, :level)
+        notice = event.slice(:type, :hook, :text, :level, :fallback_for)
         if event[:between_turns] || !@running
           push(notice.merge(in_turn: false, turns: @turns_done))
         else

data/lib/samagotchi/bridge/turn_notice.rb

@@ -10,7 +10,7 @@ module Samagotchi
     # here, and draw it with the handler that drew it live, where it was.
     module TurnNotice
       FIELDS = {
-        hook_notice: %i[hook text level],
+        hook_notice: %i[hook text level fallback_for],
         empty_answer_retry: %i[iteration attempt of stopped_by malformed],
         steer_cut: %i[iteration source],
         question_requested: %i[pending_question],

data/lib/samagotchi/broadcast/recipients.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "../session"
+
+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__)
+
+  module Broadcast
+    # A session a broadcast may concern.
+    # @!attribute project [String, nil] its git project's root
+    # @!attribute live [Boolean] a worker runs it now
+    # @!attribute owner [String, nil] "worker", "tui" (a chi REPL, which
+    #   takes no notes) or nil
+    Recipient = Data.define(:id, :short_id, :project, :cwd, :desc, :live, :owner) do
+      def repl? = owner == "tui"
+    end
+
+    # Who a broadcast goes to: the user's own sessions, not delegate
+    # children (their parent relays what concerns them) and not scratch
+    # ones, that a worker or a chi REPL runs now or that ended a turn in
+    # the last +active_hours+. Forks count: they are the user's sessions.
+    # Archived sessions don't; test runs only when chi runs as one.
+    module Recipients
+      module_function
+
+      # @return [Array<Recipient>] newest first
+      def list(state_dir:, active_hours:, include_tests: Session.test_session_env?, now: Time.now)
+        cutoff = now - (active_hours.to_f * 3600)
+        SessionManager.session_summaries(include_tests: include_tests, state_dir: state_dir).filter_map do |row|
+          next if row[:delegate] || row[:scratch]
+          next unless row[:live] || row[:owner] == "tui" || active_since?(row, cutoff, state_dir)
+
+          Recipient.new(id: row[:id], short_id: row[:short_id], project: row[:project], cwd: row[:cwd],
+                        desc: row[:desc], live: row[:live], owner: row[:owner])
+        end
+      end
+
+      # The user's last turn there ended after +cutoff+. updated_at moves on
+      # every save (a note absorbed, a resume), so it counts only for a
+      # session with no turn recorded; it is never older than the last
+      # turn's end, so an older one rules the session out unread.
+      def active_since?(row, cutoff, state_dir)
+        return false unless (time(row[:updated_at]) || Time.at(0)) >= cutoff
+
+        session = Session.summary_from_file(Session.session_file(row[:id], state_dir: state_dir))
+        last_turn = session&.last_turn
+        ended = last_turn.is_a?(Hash) ? time(last_turn["ended_at"] || last_turn[:ended_at]) : nil
+        (ended || time(row[:updated_at])) >= cutoff
+      end
+      private_class_method :active_since?
+
+      def time(value)
+        value && Time.iso8601(value.to_s)
+      rescue ArgumentError
+        nil
+      end
+      private_class_method :time
+    end
+  end
+end

data/lib/samagotchi/broadcast/scope_card.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "pathname"
+require_relative "../session"
+require_relative "../context_note"
+require_relative "../context_sources"
+require_relative "../git_head"
+require_relative "../recap_store"
+require_relative "tags"
+
+module Samagotchi
+  module Broadcast
+    # What a broadcast knows about one recipient, from local state only:
+    # where it works, what it was started for, its recap, its last prompt
+    # and its tags. Built fresh for each broadcast, never stored; P2's
+    # triage model reads #to_s.
+    # @!attribute folder [String, nil] the session's folder relative to its
+    #   project ("../app-fix" for a worktree), nil when it is the project
+    #   root; outside a project the whole path, ~ for home
+    # @!attribute tags [Array<Tag>]
+    ScopeCard = Data.define(:id, :project, :folder, :branch, :title, :tags, :started, :recap, :recent) do
+      def to_s
+        where = [("folder #{folder}" if folder), ("branch #{branch}" if branch)].compact.join(", ")
+        lines = ["project: #{project || "none"}#{" (#{where})" unless where.empty?}"]
+        lines << "title:   #{title}" unless title.to_s.empty?
+        lines << "tags:    #{tags.map(&:label).join(" · ")}" unless tags.empty?
+        lines << "started: #{started}" unless started.to_s.empty?
+        lines << "recap:   #{recap}" unless recap.to_s.empty?
+        lines << "recent:  #{recent}" unless recent.to_s.empty?
+        lines.join("\n")
+      end
+    end
+
+    # Builds a ScopeCard for a Recipient.
+    module ScopeCards
+      STARTED_CHARS = 300
+      RECAP_CHARS = 400
+      RECENT_CHARS = 200
+
+      module_function
+
+      # @param recipient [Recipient]
+      # @param ticket [Regexp] the ticket pattern (Tags.ticket_regexp)
+      # @return [ScopeCard]
+      def build(recipient, state_dir:, ticket:)
+        session = Session.load(recipient.id, state_dir: state_dir)
+        prompts = user_texts(session.messages)
+        branch = GitHead.branch(session.working_directory)
+        sources = ContextSources.attached(session.id, project_root: session.project_root, state_dir: state_dir)
+                                .map { |attached| [attached.name, attached.source.hint] }
+        ScopeCard.new(id: session.id, project: recipient.project && File.basename(recipient.project),
+                      folder: folder(session.working_directory, recipient.project), branch: branch,
+                      title: recipient.desc, tags: Tags.of_session(branch: branch, messages: prompts, sources: sources,
+                                                                   ticket: ticket),
+                      started: cut(prompts.first, STARTED_CHARS),
+                      recap: cut(RecapStore.read(Session.session_dir(session.id, state_dir: state_dir))&.dig(:text),
+                                 RECAP_CHARS),
+                      recent: cut(session.last_prompt, RECENT_CHARS))
+      end
+
+      # The user's own messages, as text (an image part leaves its text).
+      def user_texts(messages)
+        messages.filter_map do |message|
+          next unless message[:role].to_s == "user"
+
+          content = message[:content]
+          text = if content.is_a?(Array)
+                   content.filter_map { |part| part.is_a?(Hash) ? part[:text] || part["text"] : nil }.join("\n")
+                 else
+                   content.to_s
+                 end
+          text unless text.strip.empty?
+        end
+      end
+      private_class_method :user_texts
+
+      def folder(cwd, project)
+        return ContextNote.home_relative(cwd) if project.nil?
+        return nil if cwd.to_s == project.to_s
+
+        Pathname.new(cwd.to_s).relative_path_from(Pathname.new(project.to_s)).to_s
+      rescue ArgumentError
+        cwd
+      end
+      private_class_method :folder
+
+      def cut(text, limit)
+        line = text.to_s.gsub(/\s+/, " ").strip
+        line.length > limit ? "#{line[0, limit - 1]}…" : line
+      end
+      private_class_method :cut
+    end
+  end
+end

data/lib/samagotchi/broadcast/tags.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Samagotchi
+  module Broadcast
+    # A cheap, deterministic marker found in a note or about a session: a
+    # ticket id, a pull request, a link. A tag the note and a session share
+    # delivers the note there without asking a model (the fast path).
+    # @!attribute kind [String] "ticket", "pr" or "link"
+    # @!attribute value [String] "PAY-123"; "#42" or "acme/shop#42"; a
+    #   link's host and path ("notion.so/team/checkout-v2")
+    # @!attribute from [String] where it was found: "note", "branch",
+    #   "messages" (the user's prompts) or "context <name>" (an attached
+    #   context source)
+    Tag = Data.define(:kind, :value, :from) do
+      def label = "#{kind} #{value}"
+
+      # Same kind and value; a pr with no repo matches the same number in
+      # any repo.
+      def matches?(other)
+        return false unless kind == other.kind
+        return value == other.value unless kind == "pr"
+
+        number, repo = Tags.pr_parts(value)
+        other_number, other_repo = Tags.pr_parts(other.value)
+        number == other_number && (repo.nil? || other_repo.nil? || repo == other_repo)
+      end
+    end
+
+    # A tag of the note and the session tag it matched.
+    Match = Data.define(:note_tag, :session_tag) do
+      # For the broadcast's output: "ticket PAY-123 matches (branch)".
+      def reason = "#{note_tag.label} matches (#{session_tag.from})"
+
+      # For the note the session gets: "ticket PAY-123 matches your branch".
+      def because
+        tag = session_tag
+        case tag.from
+        when "branch" then "#{note_tag.label} matches your branch"
+        when "messages" then "#{note_tag.label} is in your user's messages too"
+        else "#{note_tag.label} matches your attached #{tag.from}"
+        end
+      end
+    end
+
+    # Tags from text, a branch and attached context, and the first match
+    # between a note's and a session's.
+    module Tags
+      DEFAULT_TICKET_PATTERN = '\b[A-Z][A-Z0-9]+-\d+\b'
+      # Words the default ticket pattern would take that are no ticket.
+      NOT_TICKETS = %w[UTF SHA ISO IEC RFC GPT AES RSA ECMA ES HTTP TLS SSL MD IPV X].freeze
+      URL_RE = %r{https?://[^\s<>()\[\]{}"'`|]+}
+      PR_URL_RE = %r{\A(?:www\.)?github\.com/([^/]+/[^/]+)/pull/(\d+)}i
+      PR_TEXT_RE = /\bPR\s?#(\d+)\b/i
+      PR_SOURCE_RE = /\Apr-(\d+)\z/
+      # The order matches are looked for in: the most specific first.
+      KINDS = %w[ticket pr link].freeze
+
+      module_function
+
+      # broadcast.ticket_pattern as a Regexp; nil, empty or invalid → the
+      # default (an invalid one is reported through +warn+).
+      # @return [Regexp]
+      def ticket_regexp(pattern, warn: nil)
+        return Regexp.new(DEFAULT_TICKET_PATTERN) if pattern.to_s.strip.empty?
+
+        Regexp.new(pattern.to_s)
+      rescue RegexpError => e
+        warn&.call("broadcast.ticket_pattern #{pattern.inspect} is not a valid pattern (#{e.message}); using the default")
+        Regexp.new(DEFAULT_TICKET_PATTERN)
+      end
+
+      # @return [Array<Tag>] the tags in +text+ (a note, the user's prompts)
+      def of_text(text, from:, ticket: ticket_regexp(nil))
+        text = text.to_s
+        found = tickets(text, ticket, from: from)
+        found += text.scan(PR_TEXT_RE).map { |(number)| Tag.new(kind: "pr", value: "##{number}", from: from) }
+        text.scan(URL_RE).each { |url| found += of_url(url, from: from) }
+        found.uniq
+      end
+
+      # A session's tags: its branch (matched whatever its case: branches
+      # are often lowercase), the user's messages, its attached context
+      # (a pr-<n> source and every source's URL hint).
+      # @param sources [Array<Array(String, String)>] [name, hint] pairs
+      # @return [Array<Tag>]
+      def of_session(branch:, messages:, sources:, ticket: ticket_regexp(nil))
+        found = tickets(branch.to_s, Regexp.new(ticket.source, ticket.options | Regexp::IGNORECASE), from: "branch")
+        found += messages.flat_map { |text| of_text(text, from: "messages", ticket: ticket) }
+        sources.each do |name, hint|
+          from = "context #{name}"
+          from_hint = hint.to_s.scan(URL_RE).flat_map { |url| of_url(url, from: from) }
+          number = name.to_s[PR_SOURCE_RE, 1]
+          # pr-<n> with no PR URL in its hint: the number alone, any repo
+          found << Tag.new(kind: "pr", value: "##{number}", from: from) if number && from_hint.none? { |t| t.kind == "pr" }
+          found += from_hint
+        end
+        found.uniq { |tag| [tag.kind, tag.value] }
+      end
+
+      # The first session tag a note tag matches, tickets first, then pull
+      # requests, then links.
+      # @return [Match, nil]
+      def match(note_tags, session_tags)
+        KINDS.each do |kind|
+          note_tags.each do |tag|
+            next unless tag.kind == kind
+
+            hit = session_tags.find { |other| tag.matches?(other) }
+            return Match.new(note_tag: tag, session_tag: hit) if hit
+          end
+        end
+        nil
+      end
+
+      # "acme/shop#42" → ["42", "acme/shop"]; "#42" → ["42", nil].
+      def pr_parts(value)
+        repo, number = value.to_s.split("#", 2)
+        [number, repo.to_s.empty? ? nil : repo.downcase]
+      end
+
+      def tickets(text, regexp, from:)
+        text.to_enum(:scan, regexp).filter_map do
+          id = Regexp.last_match(0).upcase
+          next if NOT_TICKETS.include?(id.split("-", 2).first)
+
+          Tag.new(kind: "ticket", value: id, from: from)
+        end
+      end
+      private_class_method :tickets
+
+      # A link's host and path, without the scheme, www., the query, the
+      # fragment or a trailing slash; a pull request URL is a pr tag too. A
+      # bare host ("https://github.com/") says too little to be a tag.
+      def of_url(url, from:)
+        uri = URI.parse(url.sub(/[.,;:!?]+\z/, ""))
+        host = uri.host.to_s.downcase.delete_prefix("www.")
+        path = uri.path.to_s.chomp("/")
+        return [] if host.empty? || path.empty?
+
+        link = "#{host}#{path}"
+        tags = [Tag.new(kind: "link", value: link, from: from)]
+        if (pr = link.match(PR_URL_RE))
+          tags.unshift(Tag.new(kind: "pr", value: "#{pr[1].downcase}##{pr[2]}", from: from))
+        end
+        tags
+      rescue URI::Error
+        []
+      end
+      private_class_method :of_url
+    end
+  end
+end

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

@@ -1,14 +1,15 @@
 ---
 name: coordinator
-version: 0.1.2
+version: 0.2.0
 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"
+description: "Coordinate parallel work: the coordinator skill (split the work, one worktree and child session per task, check each report, ask before each merge, a handoff memory to resume from), /coordinate <goal>, /coordinate resume 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"
+    sha256: sha256:a24b91ae27737027125cc0d627bf31edbacdd1be842f4daf82ddf062c9160413
+    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; resume from a handoff_* memory"
 plugin:
   file: plugin.rb
-  sha256: sha256:5173faeb6311984ad4f2a40b9052dcc577a90790fc5c5a8409b95d4f114e66a7
-requires_chi: ">= 0.34.0"
+  sha256: sha256:2b11a24f22398f4d00132c2342f7c02eacfc6cec0e517e8241a17241affc8ca7
+# the handoff memory needs memory_write's description-only form and remove: (0.36.0)
+requires_chi: ">= 0.36.0"