samagotchi 0.35.0 → 0.36.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b598dac8dadadd4dd37861ed690d09d09926520c2295bc998def4d75c3716ea7
-  data.tar.gz: 9d30ebb820024929bbb2dc1267011af7eb5710b33a4ba9625489a74d111edfbd
+  metadata.gz: 1a970676ddf9dacd7bd644f66dcdf28f68a49c6cb24caf2bc785656cb6a2d286
+  data.tar.gz: 8babf6d8562a213f07c3053b7efde79aae43ba4d51fef8ce16b933d17894acd0
 SHA512:
-  metadata.gz: 2f40ed32d227d1017bc7abcba8ef40f5e38f2f7dd7876aa5f78a9290e5443489b8109183655a151a1345fef1fa3f3f49e5deafbac38059cdba3bec70b0585d71
-  data.tar.gz: 55aca343a9dc45e78791863286768c356e815dc1b9783993f2c4477edb991883a3c88ae208dd642137cab4c6ead58fc1d49228f201fefcd6878dd421c719af70
+  metadata.gz: 9727a14cff5153a0a061d9e787aebd0e0ea7494781e63386405b261fb4391d04bef56d4fefa346c9d0f2081d49fe7eddeadc3f6bb1b4ef8edc6478f5d273db6f
+  data.tar.gz: 3dc9840ef7eba85ea3160bb2ac84412e9be6219c4e9bdbabc89796d2ee677adeb7903d4ef1002d82cae12daefac3ca6545f1f6519466bcfda164e2c126fd699e

data/CHANGELOG.md

@@ -8,6 +8,37 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.36.0] - 2026-10-07
+
+### Added
+
+- `memory_write` with `name`, `scope` and `description` but no `content` changes only that memory's index line and
+  leaves its file as it is (see [docs/memory.md](docs/memory.md)).
+- `memory_write` with `name`, `scope` and `remove: true` removes a memory: its file (and model overlays) move to the
+  bundle trash, which `chi bundle trash` lists and empties, and its index line goes; a line left after the file was
+  deleted by hand goes too. A memory a bundle installed is refused (`chi bundle uninstall` owns it).
+- The coordinator bundle (0.2.0) keeps a project memory `handoff_<epic>` with what git and the session list can't
+  rebuild (the split, your decisions, its verdicts, follow-ups), its status in the index description, and resumes
+  from it in a new session after checking git and the session list; `/coordinate resume` picks up an open handoff.
+  When the work is done it marks the handoff DONE and asks whether to remove it. See
+  [docs/plugins.md](docs/plugins.md#the-coordinator-bundle).
+- The guardrails bundle (0.8.0) asks before every memory removal (`memory-remove`, once at a time). Guardrail rules
+  take `memory: remove`.
+- In the web, a file reference in an answer (`lib/foo.rb:28`, `lib/foo.rb:28-34`, in inline code too) links to that
+  line of the pull request the session reviews: the PR attached to it or named in your messages (a delegate child's
+  task too). Inside a changed hunk it opens the PR's Files changed view at the line, highlighted; elsewhere the file
+  at the PR's head. Display only; `bundles: github-pr: line_links: false` turns it off (github-pr 0.2.0; run
+  `chi update`). See [docs/context.md](docs/context.md#line-links).
+- `/mcp` shows roughly how many tokens each MCP server's tool definitions take in every request, and the total
+  (mcp 0.5.0; run `chi update`). See [docs/plugins.md](docs/plugins.md#the-mcp-bundle).
+
+### Fixed
+
+- `memory_write` with a blank `description` keeps the stored one instead of wiping it; a multi-line description is
+  written on one line (it left orphan lines in `index.md`), and one longer than 200 characters is refused.
+
+Update with `chi update` (coordinator 0.2.0 and guardrails 0.8.0, which need chi 0.36.0; github-pr 0.2.0, mcp 0.5.0).
+
 ## [0.35.0] - 2026-10-06
 
 ### Added
@@ -1751,7 +1782,8 @@ and long-lived sessions.
 - A macOS desktop helper (`chi desktop install`): a "Send to chi" Service and a
   hotkey panel that send selected text or the clipboard to your sessions.
 
-[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.35.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.36.0...HEAD
+[0.36.0]: https://github.com/dm1try/samagotchi/compare/v0.35.0...v0.36.0
 [0.35.0]: https://github.com/dm1try/samagotchi/compare/v0.34.0...v0.35.0
 [0.34.0]: https://github.com/dm1try/samagotchi/compare/v0.33.0...v0.34.0
 [0.33.0]: https://github.com/dm1try/samagotchi/compare/v0.32.0...v0.33.0

data/docs/context.md

@@ -184,6 +184,43 @@ It needs [`gh`](https://cli.github.com), logged in (`gh auth login`).
 - It wakes for a review requesting changes, checks turning red, and the PR
   merged or closed. Comments alone never wake.
 
+### Line links
+
+In the web, a file reference in an answer links to that line of the pull
+request the session reviews: `lib/foo.rb:28` and `lib/foo.rb:28-34`, also in
+inline code (`` `lib/foo.rb:28` ``). The model writes plain references; the
+links are display only (the model's text stays as it was), and terminals
+show the answer as it is.
+
+- **Which PR**: the session's attached PRs (the branch's, `chi context add
+  <PR URL>`, "+ URL") and the PR URLs in your messages, newest first (a
+  delegate child's task counts: a parent that names the PR there gets links
+  in the child's answers). PR URLs in tool output or answers don't count.
+- **Which file**: a file the PR changes, by its path, a renamed file's old
+  path, a bare name only one PR file has (`source_links.rb:28`), or an
+  absolute path into a checkout (a child's worktree). Any other file isn't
+  linked, nor is a path several of the session's PRs change.
+- **Where to**: the line in the PR's **Files changed**, highlighted, when it
+  is inside a changed hunk (a removed file: on its old side); else the file
+  at the PR's head commit (a removed one: at its base), which has every
+  line.
+- Code blocks, markdown links and URLs are left alone.
+- The PR's files are read with `gh api` in the background when a turn
+  starts (and when a PR is attached while it runs), at most once a minute,
+  and read again only when the PR's head moved; the answer is linked from
+  what was read.
+  So the first answer of a very short turn may come without links, and
+  after a push links may be a few lines off until the next read. Without
+  `gh` or its login, nothing is linked.
+
+Turn it off:
+
+```yaml
+bundles:
+  github-pr:
+    line_links: false
+```
+
 ## Safety
 
 A command source runs **outside the guardrails gate**, every few minutes,

data/docs/guardrails.md

@@ -244,7 +244,12 @@ guardrails:
       scopes: [once, session, rule]
 ```
 
-A rule gives at least one of `tool`, `command`, `path`, `git`, `touches` and `rm`.
+A rule gives at least one of `tool`, `command`, `path`, `git`, `touches`, `rm` and `memory`.
+
+`memory: remove` matches a `memory_write` with `remove: true` (it moves a
+memory into the bundle trash). Nothing else asks about it: a memory's file is
+never outside the repo (below), so without such a rule any session, a delegate
+child included, removes a memory unasked.
 
 `rm: outside_tmp` (shell tools) matches a command whose `rm -r -f` reaches
 outside the tmp folders (`$TMPDIR`, `/tmp`, `/var/tmp`): every such `rm` in a
@@ -408,7 +413,7 @@ rules (`models: small`) are untagged, so they ask a small model in both modes.
 leaves out `(strict only)`.
 
 A rule in config.yml that uses a key this chi doesn't know yet (`modes:`,
-`touches:`, `rm:`, `skip_read_only:` before 0.20) doesn't parse, and a rule
+`touches:`, `rm:`, `skip_read_only:` before 0.20, `memory:` before 0.36) doesn't parse, and a rule
 that doesn't parse denies every tool call (see Failing closed). Bundles say
 which chi they need (`requires_chi`), so their rules don't hit this.
 
@@ -429,7 +434,10 @@ hooks, approvals, bundles or attached context sources, or a `.git/hooks`
 time: a command chi will run every few minutes outside the guardrails; see
 [Attached context](context.md#safety)); `chi broadcast` (`chi-broadcast`,
 once at a time and only by the user: it is the user's command, which also
-refuses to run inside a session; see [Broadcast](broadcast.md)); and answering chi's
+refuses to run inside a session; see [Broadcast](broadcast.md)); removing a
+memory with `memory_write remove: true` (`memory-remove`, once at a time:
+a delegate child could otherwise remove its parent's handoff unasked; see
+[Memory](memory.md)); and answering chi's
 questions around `chi answer`: `chi --attach` or `chi -p` with stdin from a
 pipe, a here-string or a file (`chi-answer-piped`), and `curl`/`wget` to a
 session's `/answer` route (`chi-answer-http`), both once or for the session.

data/docs/hooks.md

@@ -424,7 +424,7 @@ stripped of surrounding whitespace, except file text, an edit's
 | `write` | — | `path` | `content` |
 | `edit` | — | `path` | `old_text`, `new_text`, `start_line`, `end_line` |
 | `memory_read` | `name` | — | `scope` |
-| `memory_write` | — | `name` | `content`, `scope`, `description`, `current_model_only` |
+| `memory_write` | — | `name` | `content`, `scope`, `description`, `current_model_only`, `remove` |
 | `task_create` | `command` | — | `cwd`, `env` |
 | `task_get` | `id` or `task_id` | — | — |
 | `task_list` | — | — | — |

data/docs/memory.md

@@ -15,6 +15,9 @@ Tool behavior:
 - If `scope` is provided (`project` or `system`), only that scope is read.
 - If `scope` is omitted, read falls back from project to system.
 - `memory_write`: `scope` is required (`project` or `system`). The entry name is passed via the `name` parameter (not `path` — the file tools use `path`). On success, the return value includes the full file path. For a small change to an existing memory (a step, a line) the model is told to `edit` that file rather than rewrite it all with `memory_write`.
+- `memory_write`'s `description` is the managed `index.md` line's text: one line (whitespace and newlines collapse to single spaces), at most 200 characters (longer is refused, since every session's prompt for the repo carries it). A missing or blank one keeps the line's description.
+- `memory_write` with `name`, `scope` and `description` but no `content` changes only that entry's index line (its size and date are refreshed; the date becomes today) and leaves the file as it is: a skill that keeps its status in a memory's description changes it without resending the body. The memory must exist in that scope; the form is refused for `index` and with `current_model_only`.
+- `memory_write` with `name`, `scope` and `remove: true` (no content, description or `current_model_only`) removes a memory: its file and its model overlays (`<name>.<key>.md`, not a dotted memory with an index line of its own) move into one dir of the bundle trash, `memory-<name>-<time>` under `memories/.bundles/.trash/`, which `chi bundle trash` lists and empties, and its index line is dropped. When the file is already gone (deleted by hand), the dangling line is dropped alone. A memory a bundle owns (an installed bundle's record lists it, or its line says `· from <bundle>`) is refused: `chi bundle uninstall` removes it. `index` can't be removed. The guardrails bundle's `memory-remove` rule asks before every removal, once at a time (see [Guardrails](guardrails.md#the-guardrails-bundle)).
 - `write`/`edit` that change a `*.md` right in a scope dir refresh its managed `index.md` line (date, bytes; the description is kept), as `memory_write` does. A memory created with `write` gets a line with no description; any other `.md` written there gets a line too. Model overlays (`<name>.<key>.md` next to `<name>.md`), files in another project's folder and files changed by `execute` are left out.
 
 ## Model-Specific Memory Overlays

data/docs/plugins.md

@@ -836,6 +836,13 @@ bundles:
   closed, then TERM and KILL go to the server's process group.
 - **`/mcp`** (anytime) shows a card with the servers, their state (cached
   (not started), running with its pid, failed, stopped) and their tools.
+  A cached or running server's line says roughly how many tokens its tool
+  definitions take (`~4,232 tokens`), and the last line totals the servers
+  whose tools the model has: what every request carries. It is an estimate:
+  the definitions' JSON as the chat API gets it (`api: openai`), divided by
+  4. The native prompts (Gemma, Qwen) render a flatter schema, so there they
+  take less. The log records each server's estimate when it changes
+  (`mcp_tools_estimated`).
 - The server's stderr goes to the debug log (`plugins` records, bundle=mcp).
 - **Guardrails.** A rule's `tool:` can be a glob, so one rule covers every
   MCP tool:
@@ -1137,7 +1144,9 @@ nothing without `gh`, a repository or an open PR), and resolves PR URLs for
 `chi context add` and the web's "+ URL". Its script prints the PR as text
 and a summary of what changed in counts, authors and states only; it wakes
 the session for a review requesting changes, checks turning red, or the PR
-merged or closed. See [Attached context](context.md#github-prs-the-github-pr-bundle).
+merged or closed. In the web, a `path:line` in an answer links to that line
+of the session's PR ([Line links](context.md#line-links)). See [Attached
+context](context.md#github-prs-the-github-pr-bundle).
 
 ## The coordinator bundle
 
@@ -1163,10 +1172,27 @@ by themselves there.
   agent may have merged the branch already), merges `--ff-only` and never
   pushes unless you ask. After a merge it stops the
   child and removes only the worktrees and branches it made.
+- **A handoff memory.** The conversation is lost when the session ends, so
+  the skill keeps a project memory `handoff_<epic-slug>` with only what git
+  and the session list can't rebuild: the split (branch, worktree, child id
+  per task), your decisions, its verdicts and the follow-ups. Its index
+  description is the status, descriptive only and naming the session that
+  owns it ("OPEN coordinator handoff calc-v2 (session ab12cd34): 2/3 merged",
+  later "DONE: …"): every session in the repo sees that line. The model saves
+  a decision there before acting on it, and changes the status with
+  `memory_write`'s description-only form. When everything is done it marks
+  the handoff DONE and asks whether to remove it (`memory_write remove:
+  true`, which the guardrails bundle asks you to confirm). Children are told
+  not to touch it.
+- **Resume.** A new coordinator session (or one asked "where were we?")
+  reads the open handoff, checks it against git and the session list (git
+  wins; mismatches are reported) and goes on from the first open step.
 - **`/coordinate <goal>`** sends this session a turn asking the model to
   follow the skill for the goal (in a `--no-shared` REPL it shows the text to
   send yourself). Asking "do this in parallel" works too: the index line leads
-  the model to the skill.
+  the model to the skill. **`/coordinate resume`** asks it to resume this
+  project's open handoff; with several open it shows a card with a Resume
+  action each (`/coordinate resume <name>` picks one), with none it says so.
 - **`/children [all]`** shows the session's children as a card, newest first,
   one line each: `` `ab12cd34` · running · fix/flaky · "fix the flaky spec" ``,
   `` `9a8b7c6d` · done · feat/x · reported · "All 12 specs pass" `` (`not

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"

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: