samagotchi 0.34.0 → 0.36.0

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

@@ -18,6 +18,13 @@
 # for the goal. A REPL session (--no-shared) takes no messages: the request
 # is shown for the user to send.
 #
+# /coordinate resume picks up a coordinator handoff: the open handoff_*
+# memories of this project (an index line whose description doesn't start
+# with DONE, its file there). One: the model is asked to resume it (the
+# skill's step 0); several: a card with a Resume action each
+# (/coordinate resume <name>); none: says so. It reads the project's
+# memories folder, nothing else.
+#
 # 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
@@ -27,7 +34,12 @@ class Plugin
   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"
+  COORDINATE_USAGE = "usage: /coordinate <goal> — chi splits it into tasks, one child session and worktree each; " \
+                     "/coordinate resume [name] — pick up an open handoff"
+  RESUME_CARD_ID = "coordinate-resume"
+  # A card takes 6 actions.
+  MAX_RESUMES = 6
+  HANDOFF_LINE = /^- \*\*(handoff_[^*\s]+)\*\*(.*)$/
 
   def initialize(_settings = {}); end
 
@@ -36,7 +48,8 @@ class Plugin
                 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",
+    chi.command "/coordinate", "run work in parallel: chi splits <goal> into tasks, each in a child session and worktree; " \
+                               "resume: pick up an open handoff",
                 anytime: true do |args, ctx|
       coordinate(args.to_s.strip, ctx)
     end
@@ -97,13 +110,68 @@ class Plugin
   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}"
+    verb, rest = goal.split(/\s+/, 2)
+    # "resume" and at most a name; "resume the old work" is a goal.
+    return resume(rest.to_s.strip, ctx) if verb == "resume" && !rest.to_s.strip.match?(/\s/)
+
+    ask(ctx, "Read the skill_coordinator memory and follow it for this goal:\n\n#{goal}",
+        "asked chi to coordinate it; a running turn gets it at its next step")
+  end
+
+  # /coordinate resume [name]
+  def resume(name, ctx)
+    open = open_handoffs(ctx)
+    if name.empty?
+      return "no open coordinator handoff (handoff_* memory) in this project" if open.empty?
+      return resume_card(open, ctx) if open.size > 1
+
+      name = open.first[:name]
+    end
+    name = "handoff_#{name}" unless name.start_with?("handoff_")
+    unless open.any? { |handoff| handoff[:name] == name }
+      return "/coordinate resume: no open handoff #{name} in this project (#{open.empty? ? "none is open" : "open: #{open.map { |h| h[:name] }.join(", ")}"})"
+    end
+
+    ask(ctx, "Read the skill_coordinator memory and resume the coordinator handoff #{name}: follow the skill's " \
+             "Resume (step 0) before anything else.",
+        "asked chi to resume #{name}; a running turn gets it at its next step")
+  end
+
+  def resume_card(open, ctx)
+    body = open.map { |handoff| "- #{handoff[:name]}#{" — #{handoff[:description]}" unless handoff[:description].empty?}" }
+    actions = open.first(MAX_RESUMES).map do |handoff|
+      { label: "Resume #{handoff[:name].delete_prefix("handoff_")}", command: "/coordinate resume #{handoff[:name]}" }
+    end
+    ctx.card(id: RESUME_CARD_ID, title: "open handoffs (#{open.size})", body: body.join("\n"), actions: actions)
+    nil
+  end
+
+  # The project's handoff_* memories whose index line isn't DONE, in index
+  # order: [{name:, description:}]. A line without its file is left out.
+  def open_handoffs(ctx)
+    dir = Samagotchi::MemoryPaths.scope_dir("project", cwd: ctx.cwd)
+    index = File.join(dir.to_s, "index.md")
+    return [] unless File.file?(index)
+
+    File.read(index, encoding: "UTF-8").each_line.filter_map do |line|
+      match = line.chomp.match(HANDOFF_LINE) or next
+      description = match[2].split(" — ", 2)[1].to_s.strip
+      next if description.match?(/\ADONE\b/i)
+      next unless File.file?(File.join(dir, "#{match[1]}.md"))
+
+      { name: match[1], description: description }
+    end
+  rescue SystemCallError
+    []
+  end
+
+  def ask(ctx, request, done)
     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"
+    done
   end
 
   def quote(text)

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

@@ -3,6 +3,43 @@
 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.
 
+## Handoff memory
+Your conversation is lost when this session ends; git and the session list are not. Keep a handoff in a
+project-scope memory named `handoff_<epic-slug>` (the epic or goal in a few lowercase words joined by
+`-`, e.g. `handoff_calc-v2`). Create it with memory_write (scope: project). Its description is the status:
+one line under 200 characters that names its owner and says where things stand, never what to do (every
+session in this repo sees it, children too): "OPEN coordinator handoff calc-v2 (session <your id>): 2/3
+merged, docs kept (user)", later "DONE: …". Change the body with `edit` on the memory's file (in the
+Project memories folder), and after every change of state change the status with memory_write name,
+scope and description only (no content). It holds ONLY what git and the session list can't rebuild:
+- Goal: the goal in one line and the split (task → branch, worktree, child session id).
+- Decisions: what the user said per branch (merge / keep / drop / "don't touch X"), their words short.
+- Verdicts: your verdict per report (verified / doubts / failed) and why, in one line.
+- Follow-ups: found but not fixed.
+Not commit lists, diffs, test output or anything a git command shows again. Update it right after:
+the split started (step 3), each verdict (step 4), each user decision (an ask_user_question answer or a
+plain message: save it before you act on it), each merge or cleanup (steps 6, 7). Before you end a turn
+in which any of these changed, check the memory and its description have it. Short: under 40 lines.
+One handoff per epic: never write another epic's handoff_* memory.
+
+## Resume (step 0)
+Before step 1, look at the project memory index for `handoff_*` entries not marked DONE (`/coordinate
+resume` picks one for the user). If one is open and the user's request continues it, or doesn't name new
+work ("hi", "what's next?", "where were we?"), do all of this before you answer:
+1. Read this skill if you haven't in this session, and memory_read the handoff: its body is the state,
+   not the index line (that line is from when this session started). Then rebuild the truth:
+   `git worktree list`, `git branch --list`, for each branch in it `git log --oneline <default>..<branch>`
+   and `git merge-base --is-ancestor <branch> <default>`, and the list_sessions tool for the child ids
+   on record (not listed is not proof a child is gone).
+2. Git and the sessions are the truth; the memory is your notes. Tell the user, per branch: its state
+   now, the decision and verdict on record, and every mismatch (merged by hand, worktree gone, branch
+   deleted, a child that ended without a verdict on record), in one short list.
+3. Update the memory and its description to match the truth (keep the decisions; mark the mismatches;
+   the owner is now you), then go on from the first open step. Don't redo a merge or cleanup git shows
+   done.
+If the request is a new goal, say which handoffs are open (one line each) and go on with a new
+`handoff_<slug>` of its own; don't touch the others.
+
 ## 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
@@ -13,34 +50,43 @@ Use when the user hands over work with several independent parts, or asks to "ru
    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".
+   don't push, don't write or edit any handoff_* memory".
 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
+   Say the result in one or two lines: done and verified / done with doubts / failed. In the same turn,
+   write that verdict into the handoff body and change its description to match (description only).
+5. Then one of (a user's decision about it goes into the handoff first): 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>?".
+6. Merging is the user's call: ask (ask_user_question) per branch, "Merge <branch> into <default>?", and
+   save the answer in the handoff before you act on it.
    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
+   never merge. Never push unless asked. Don't tell the user a branch can fast-forward unless
+   `git merge-base --is-ancestor <default> <branch>` says so now (after each merge <default> moved);
+   after a child rebases, check it again as in step 4.
+7. Clean up only a branch that was merged or that the user said to drop (that decision saved in the
+   handoff first): 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
+   `-d` refuses, say why to the user; never `-D` unless they say so. If `git worktree remove` refuses
+   over untracked or ignored files, show `git -C <worktree> status --short --ignored` and ask; never
+   `rm -rf`. 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.
+   but didn't run, or whose output you didn't see, is not done; say so. Then set the handoff's
+   description to "DONE: …" and ask the user whether to remove it (memory_write name, scope and
+   remove: true).
 
 ## Gotchas
 - Children are asked before changing anything outside their worktree (your checkout, a sibling's):
@@ -58,3 +104,5 @@ Use when the user hands over work with several independent parts, or asks to "ru
 ## 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)
+- 2026-10-07 handoff memory with its status in the description, resume (step 0, /coordinate resume),
+  save decisions first, fast-forward and worktree-remove checks, remove the handoff when done (0.2.0)

data/lib/samagotchi/bundles/github-pr/manifest.yml

@@ -1,8 +1,8 @@
 ---
 name: github-pr
-version: 0.1.0
+version: 0.2.0
 scope: system
-description: Attaches the branch's open GitHub pull request to a session as context (and any PR URL with chi context add or the web's "+ URL"); the agent gets a note when reviews, comments, checks or its state change
+description: Attaches the branch's open GitHub pull request to a session as context (and any PR URL with chi context add or the web's "+ URL"); the agent gets a note when reviews, comments, checks or its state change; in the web, a path:line in an answer links to that line of the PR
 trust_level: reviewed
 requires_chi: ">= 0.32.0"
 needs:
@@ -11,7 +11,7 @@ needs:
   hint: brew install gh, then gh auth login
 plugin:
   file: plugin.rb
-  sha256: sha256:b825731983a402d0cd006a17236794ef03e31ab1b160e853756f4d63b295f664
+  sha256: sha256:f8b9794f84681f3a16a4d49da3b857a59fec3ccdc2d0a2b16d1192fd2a26bdf3
 scripts:
   pr_context.rb: sha256:a883d2780e89c68c0d7b6d5e0fcb22c273f17bb167e79064e0e99db6bd2ee6f0
 context_providers: