@erclx/canon 5.45.0 → 5.46.0

package/claude/skills/role-reviewer/REQUIREMENT.md

@@ -7,79 +7,29 @@ description: What a dispatched reviewing session is, what it writes and reads, t
 
 ## Gap
 
-Without this skill, review is the one stage of the loop that does not fan out.
-Planning goes to `role-planner` sessions and building to `role-worker` sessions,
-while every first pass still runs inside the controlling session with several
-pull requests held in one context. A loop is as parallel as its narrowest stage,
-so a wave of planners and workers ends in a queue at review however wide the
-first two stages run.
+Without this skill, review is the one stage that does not fan out. Every first pass runs inside the controlling session with several pull requests in one context, and that session skims the docs a branch touches. A cold session reviewing one pull request finds what it missed.
 
-Holding many pull requests at once is also what makes the warm pass shallow. In
-a blind trial on 2026-09-25, a cold session reviewing one pull request found two
-real stale-count findings on a branch the controlling session had closed clean
-while holding eight, because that session read the source diff closely and
-skimmed the docs the branch touched. A live trial the same day dispatched three
-first passes to cold sessions, and on the one pull request both sides read, the
-cold pass found a finding the warm pass missed and showed one of the warm pass's
-own findings wrong.
-
-Every one of those launches restated the reviewer's bounds by hand: write the
-comment alone, no worktree, no branch, no board write, no fix, no direct draft
-lift.
-Each is a property of the role rather than of the pull request, so each dispatch
-reproduced them from memory, the shape `role-planner` was written to retire on
-the planning side.
-
-Three bounds matter more than the rest. A reviewer asked to fix what it found
-has reviewed its own change afterwards, and nothing recovers the independent
-read. A reviewer posting `## Review closed` is one step from readying the pull
-request by hand, which skips the gates `canon pr lift` reads, and `review-pr`
-Step 5 reports a merge recommendation that reads as permission when the body is
-silent. A reviewer with no checkout reading a file
-off the main worktree reads the trunk, so every finding it files there is about
-a tree the pull request never changed.
-
-Routing through the controlling session costs that session the most. Until
-2026-10-12 each review round passed through it four times: the pass announced to
-it, the dispatch to the worker, the worker's answer, and the re-review request.
-Every one of those is a turn that reads the whole wave's context, and the
-reviewer and the worker each already knew what the other needed next.
+Each launch also restates the reviewer's bounds, though they belong to the role. A reviewer asked to fix has reviewed its own change, and one posting a close is a step from readying the pull request, skipping the gates `canon pr lift` reads. One with no checkout reads the trunk, so its findings describe a tree the pull request never changed.
 
 ## Must
 
-- Assert what a reviewing session is, what it may write, and how long the role lasts, since `review-pr` carries the pass and no body carries the role that runs it when dispatched
-- Bound the writes to the comment `review-pr` posts and the body file it names, or for a UI reviewer to what `review-ui` posts and drives from, and name the tracked file, branch, worktree, board, and commit as outside them
-- Send every file read a finding rests on to `git show <head>:<path>` at the head `review-pr` resolved, since the main worktree holds the trunk
-- Name what the pass reads, the diff, the plan, the task's outcomes, the rules, and `review-craft`, and what it leaves, the author's argument and the worker's session, since the independence is what the trials measured
-- Read the cross-branch facts a launch carries as inputs rather than findings, since the controller's wave-level read reaches this session only through the brief
-- Refuse the fix, a draft lift by any route but `canon pr lift`, and the merge, whoever asks, and name who owns each, since each has a sender who will ask
-- Run `canon pr lift` after posting a close, since the verb reads every gate itself and a reviewer's close is the moment the last of them can turn clear
-- Send the `review-address` dispatch to the worker on an open pass, carrying the number, the heading, `review-pr` Step 5's count line, and this session's sessionId, and fall back to the controller when no worker resolves, since every hop through the controller costs it a turn that reads the whole wave's context
-- Message the controller on a close with the reason `canon pr lift` returned, unless the reason names the other review as still open, since that refusal needs nothing from anyone
-- Owe a message before a block becomes an interactive prompt, since a session already waiting on input never reaches the tool round an inbound message drains at
-- Keep a re-review with the reviewer that took the first pass while it is live, so the second pass keeps the read the first paid for
-- Defer the addressee resolution to `session-relay` and keep only the last-rung inference, which discriminates as it does for a planner because a reviewer holds no feature branch either
+- The role is asserted, with writes bounded to the comment and body file the pass posts, and the tracked file, branch, worktree, board, and commit named as outside them
+- Every file read a finding rests on goes through `git show <head>:<path>` at the resolved head, and launch-carried cross-branch facts are inputs
+- The fix, a draft lift by any route but `canon pr lift`, and the merge are refused whoever asks, naming each owner, and the lift runs after a close is posted
+- An open pass sends the worker the `review-address` dispatch and this session's id, else the controller the cause, and a close sends the lift's reason unless the other review is open or missing
+- A re-review stays with the reviewer that took the first pass while it is live, and a block is messaged before it becomes an interactive prompt
 
 ## Must not
 
-- Restate `review-pr`'s steps, threshold, headings, or marker, since the controller's poll routes on them and a second copy is a second source
-- Restate `review-craft`'s criteria, which apply to every reviewer alike rather than varying by role
-- Restate a boundary `role-orchestrator`, `role-worker`, or `role-planner` states about itself
-- Report progress through the channel, which rebuilds on the sender's side the poll the announcement exists to retire
-- Post outside `review-pr` and `review-ui`, since every reader of the review headings breaks at once when one pass invents its own
-- Be a skill nothing invokes but its author typing the name. `orchestrator-reviewer-launch.md` names it on the reviewer launch the way `orchestrator-launch.md` names `role-planner` on a planning one, so a stretch where only a typed invocation reaches it is the signal that the role never took.
-
-## Guards
-
-- Plan or task does not resolve from where the session stands: report it unreadable and name the main-root path, rather than reviewing as though the branch had no plan
-- Asked by anyone to fix, ready the pull request directly, or merge: refuse, name who owns the act, and file the defect in the comment when the ask was a fix
-- Launch named no controlling session and an operator is present: ask which row to address rather than inferring
-- Launch named no controlling session and nobody is present: infer from the sessions holding no feature branch, report the candidates when more than one comes back, and say the addressee was inferred
+- Restate `review-pr`'s steps and headings, `review-craft`'s criteria, or a boundary another role states about itself
+- Report progress through the channel, or post outside `review-pr` and `review-ui`
+- Review as though the branch had no plan when it does not resolve, and instead report it unreadable naming the main-root path
+- Exist for the author to type its name, since a stretch where only a typed invocation reaches it signals the role never took
 
 ## Out of scope
 
-- The pass itself, its scoping, its body, and its post, which `review-pr` owns
-- What a review looks for and how much evidence a finding needs, which `review-craft` owns
-- The cross-branch pass per wave and the decision of which pull requests take a dispatched reviewer, which `role-orchestrator` holds
-- Answering the review, which `review-address` owns in the worker's session
+- The pass itself, its scope, body, and post, which `review-pr` owns
+- What a review looks for, which `review-craft` owns
+- The cross-branch pass per wave and which pull requests take a reviewer, which `role-orchestrator` owns
+- Answering the review, which `review-address` owns
 - The mechanical addressee resolution, which `session-relay` owns

package/claude/skills/role-reviewer/SKILL.md

@@ -59,7 +59,11 @@ Send it to the worker holding the branch as `review-pr` Step 5 returns an open `
 - Carry the pull request number, the heading, that step's count line verbatim, and this session's own sessionId for the worker's reply
 - Resolve the worker with `canon sessions list --branch <branch> --json`, where `<branch>` is the pull request's head branch
 - Send to it only when exactly one session comes back with its confidence reading `confirmed`
-- On zero, on any other count or confidence, or on a refusal, send the same message to the controller, saying no worker resolved
+- On zero, on any other count or confidence, or on a refusal, send the same message to the controller, naming the cause the roster read gives
+  - Say the roster rests on sockets from another pid namespace, so the worker may be live and unconfirmed, when a row reads `via: "socket"` or an empty roster carries a `foreignDead` count above zero
+  - Say the roster rests on a pid answering alone, since start times could not be read, when the confidence reads `unverified` and no row reads `via: "socket"`
+  - Say no worker resolved only for a `confirmed` roster of zero rows, and name the count and confidence for any other
+  - Name the refusal and what the verb returned when `canon sessions list` refused, since a refusal has no roster to read
 
 ### The close
 

package/claude/skills/role-worker/REQUIREMENT.md

@@ -14,7 +14,7 @@ The channel fails on the worker's side. Blocks open prompts nobody is attached t
 ## Must
 
 - Session scratch resolves at the main worktree root, and a plan that fails to resolve is reported unreadable from there rather than absent
-- The pull request announcement carries the number, the branch, the task, the reach, and any row the build turned up, and a painted diff has its preview server running before the pull request opens
+- The announcement carries the number, branch, task, reach, any uncleared spend, and any row the build turned up, and a painted diff has its preview server running before the pull request opens
 - A block goes out as a message before it becomes a prompt, a fan-in member's done message carries its branch and head commit, and a review wait that times out reaches the controller
 - The plan's scope freezes at dispatch, and a late ask is sorted into a defect, a follow-up row, or an addition on the operator's word
 - A refusal of an instruction the tree contradicts carries its evidence, and a talk launch puts its judgment calls to the operator in the session

package/claude/skills/role-worker/SKILL.md

@@ -93,6 +93,8 @@ Announce the pull request as the ship chain's pull request step returns, carryin
 - Say the reach was unread rather than clear when the installed binary carries no such subcommand, and leave the undeclared list to the pull request
 - Carry a row this build turned up with its title, origin, and surface. Send it alone only when the session ends before a pull request opens.
 
+Name any billed run the Testing section needs that the operator has not cleared, so the controller asks before the first review. Leave it out when no spend is owed or it is cleared, and send no second message for it.
+
 ### A fan-in member
 
 A member of a fan-in set opens no pull request, so its done message stands in for the announcement. `auto-ship` sends it after the push.

package/claude/skills/script-screencast/REQUIREMENT.md

@@ -7,34 +7,28 @@ description: Why a recording script ships pre-seeded rather than blank, what the
 
 ## Gap
 
-Without this skill, a recording plan arrives as a wall of blank fields, so the user fills a template instead of editing a draft and the work the skill was meant to do lands back on them. The opposite failure costs more. A session that skips discovery guesses the audience, the length, and the hero moment, then writes five beats for a video nobody asked for, and every one of them has to be thrown away rather than edited.
+Without this skill, a recording plan arrives as blank fields, so the user fills a template instead of editing a draft. The opposite failure costs more. A session skipping discovery guesses the audience, the length, and the hero moment, and writes beats that get thrown away. What surrounds the take surfaces only at compose time.
 
-A draft that names the recording software, the editing software, or the window manager pins the script to one machine and one person's setup, so it stops being reusable the moment anyone else records. And re-invoking to refine silently overwrites the edits the user made in the file, which is the one failure that destroys work rather than wasting it.
+A draft naming the recording software, the editing software, or the window manager pins the script to one person's setup. Re-invoking to refine silently overwrites the edits the user made in the file, which destroys work rather than wasting it.
 
 ## Must
 
-- Read project context and recent commits before proposing, since what shipped recently is usually the subject
-- Ask exactly four discovery questions, each carrying a default derived from that context
-- Wait for answers rather than reading silence as acceptance
-- Pre-seed every section with concrete content so the draft is shippable as written and the user edits down
-- Derive the slug from the topic and the discovery answers
-- Write to `demos/<slug>/beats.md` at the project root, the committed folder the rest of the demo lives in, and print that path on its own line
-- Seed a wrap section naming intro, outro, and music with a default each, so the choice of what surrounds the take is made at draft time rather than discovered at compose time
+- Project context and recent commits are read before proposing, and exactly four discovery questions each carry a default derived from them
+- The run waits for answers rather than reading silence as acceptance
+- Every section is pre-seeded with concrete content, so the draft ships as written and the user edits down
+- The draft lands at `demos/<slug>/beats.md` at the project root, with the slug derived from the topic and the answers, and its path printed on its own line
+- A wrap section names intro, outro, and music with a default each
 
 ## Must not
 
 - Name recording software, editing software, fonts, or window managers
 - Record, edit video, or generate captions
 - Re-run against an existing draft to refine it, since re-running overwrites
-- Infer the hero moment without asking, which is the beat the whole script is built around
-
-## Guards
-
-- No topic provided: stop rather than guessing what is being recorded
+- Infer the hero moment without asking, or guess the topic when none is given
 
 ## Out of scope
 
 - Producing the recording, which `record-screencast` owns
-- Refining an existing draft, which is a direct edit of the file
 - Slide decks, which `make-deck` owns
-- Where the recording ships, which the draft lists and the user decides
+- Refining an existing draft, which a direct edit of the file owns
+- Where the recording ships, which the user owns

package/claude/skills/search-craft/REQUIREMENT.md

@@ -7,51 +7,27 @@ description: Why a session needs a thinking step before an outside search, deriv
 
 ## Gap
 
-Without this skill, a session reaching outside the project runs one generic `WebSearch` and takes what ranks highest. Nothing in the toolkit says how to search, and the two procedures that require an outside source, `plan-groundwork` and `write-doc`'s wiki kind, give no route to one.
+A session reaching outside the project runs one generic `WebSearch` and takes what ranks highest. Open results skew to third-party pages, two summaries of the same query can disagree on a fact, and an advocacy source can lean the answer. Scoped to authorities the session names itself, the same query returns primary sources.
 
-The miss is measured. On 2026-10-02 two queries ran twice each with identical text, once open and once with `allowed_domains` set to authorities the session derived itself with no list to consult.
-
-- `css container queries browser support`: 1 of 9 open results came from MDN, and that one was a blog post rather than the reference page. The rest were third-party pages, three of them thin guides. Scoped to MDN, web.dev, and caniuse, 10 of 10 results were primary sources.
-- The two summaries disagreed on a fact. The open one said Firefox shipped style queries in version 128, and the scoped one, reading caniuse, said 151. A direct fetch of the caniuse table returned 151, so a session that searched once would have reported the wrong version.
-- `effect of minimum wage increase on employment evidence`: the open set mixed journals with advocacy groups and its summary leaned one way. Scoped to five authorities the session named, being a research bureau's working papers, the economists' professional association, a working-paper index, a policy institute, and a legislature's budget office, 7 of 9 results were working papers or official analysis, and the summary carried both the near-zero and the negative estimates.
-- 2 of the 9 scoped economics results came from a domain outside the allow list, so the filter is not strict.
-
-The authorities in both pairs were named by the session unprompted once it was asked to, which is the argument for a method over a list. Two queries at one run each show the effect exists and do not size it.
-
-Access is a second gap a session cannot derive. Probed on 2026-10-02, Reddit refused its JSON search with a 403 and refused `WebFetch`, while its RSS feed answered 200. X redirected `curl` to a login page and returned 402 to `WebFetch`, so no free route reaches it. Re-probed on 2026-10-04, Reddit's RSS feed, its search feed, and its JSON listing and search all answered 403, so the feed that answered two days earlier no longer does.
+Access is a second gap a session cannot derive. Some sites refuse a fetch, a feed that answered once stops answering, and a free route to others does not exist. `plan-groundwork` and `write-doc` require an outside source and give no route to one.
 
 ## Must
 
-- Name the field, or two, before a query is written
-- Derive the field's authorities from the kind of body it trusts, and search for who they are first when unsure
-- Run the query scoped to those authorities and open beside it, prefer the scoped result on a conflict, and say in the output that the two disagreed
-- Use the open result for practitioner write-ups and news the authorities do not publish
-- Warn that the domain filter is not strict, so a scoped result has its domain checked before it is cited
-- Prefer a public API over a fetched and summarized page where one exists, since the API returns the dates, authors, and identifiers a citation needs
-- Carry a dated access note grown only from a failure a session hit, and stop to ask the operator before any paid or logged-in route
-- Close with the practice skill's excuses, red flags, and closing checklist, answering "the model already knows the good sites" and "one search was enough"
-- Be loaded from the sourcing steps of `plan-groundwork` and `write-doc`'s wiki kind, each reporting when the skill does not resolve
+- Name the field before a query is written, and derive its authorities from the kind of body the field trusts
+- Run the query scoped to those authorities and open beside it, prefer the scoped result on a conflict, and say the two disagreed
+- Check a scoped result's domain before citing it, since the filter is not strict
+- Prefer a public API over a fetched page where one exists, and keep an access note grown from failures a session hit, dated by the commit that adds each line
+- Stop for the operator before a paid or logged-in route, and close with the practice skill's excuses, red flags, checklist, and the sources adopted and declined with the reason for each
 
 ## Must not
 
-- Name a site as the destination for a category of question. An example authority appears only inside the method as an illustration of deriving one, marked as such. A line reading "for economics, use X" is the catalog the operator ruled out and a reviewer reads against this line.
-- Ship code. Access code a session needs repeatedly becomes a `canon` verb, never a script in the skill.
-- Restate citation format, which belongs to the surface writing the citation
+- Name a site as the destination for a category of question, outside an example marked as an illustration of deriving one
+- Ship code, since access code a session needs repeatedly becomes a `canon` verb
 - Suggest scraping behind a login or a paywall
 
 ## Out of scope
 
-- The form a citation takes: the procedure or standard writing it
-- A Claude Code subject: a direct fetch of `https://code.claude.com/docs/llms.txt` and the `.md` page it names, as `write-doc`'s wiki sourcing step already does
+- The form a citation takes, which the procedure writing it owns
+- Sourcing a Claude Code subject, which `write-doc` owns through its wiki sourcing step
 - Image generation, which makes a picture rather than finding a source
-- Loading on every web search rather than on a research-shaped request: a hook matching `WebSearch`, planned on its own
-- Whether a session already scopes searches without the skill, which only a run on a fresh research request without it would show
-
-## Measured
-
-2026-10-03, one Sonnet run of the toolkit's own sandbox scenario for this skill, a housing brief asking for linked notes and a prompt for the strongest evidence on whether rent control reduces housing supply. The skill sat in the project's skill folder and the run was allowed the skill, search, and fetch tools.
-
-- No `Skill` call fired, so the description did not route a plain research request to the body.
-- The run searched four times with no domain filter, naming authors and journals from recall, then fetched the papers' own pages. It never named the field, so the scenario's field pattern failed and the arm went red on one of its assertions.
-
-The arm shows the trigger is the gap rather than the body: a session that never loads the skill cannot follow it. The pointers from `plan-groundwork` and `write-doc`'s wiki kind reach only those procedures, and the hook matching `WebSearch` is the route for every other search. One run on one model shows the miss exists and does not size it.
+- Loading on every web search rather than a research-shaped request, which a hook matching `WebSearch` owns

package/claude/skills/search-craft/SKILL.md

@@ -44,7 +44,7 @@ This skill carries the step before the search. Work out where the field's author
 
 ## Access note
 
-Each line is a claim measured once, and `${CLAUDE_SKILL_DIR}/REQUIREMENT.md` records the date under its Gap. Sites change their blocking without notice, so re-check a line before relying on it. Add a line only for a failure a session actually hit, and record the date it hit in the requirement beside it.
+Each line is a claim measured once, and the commit that adds it carries the date. Sites change their blocking without notice, so re-check a line before relying on it. Add a line only for a failure a session actually hit.
 
 - Reddit refuses its RSS feed and its JSON search alike with a 403. `WebFetch` is refused for the site, so no keyless route reaches it.
 - X answers nothing without paying or a login. `curl` redirects to a login page and `WebFetch` returns 402.

package/claude/skills/search-craft/references/adopted.md

@@ -5,7 +5,7 @@ description: Which comparable research skills this skill was read against, what
 
 # Adopted and declined
 
-Three third-party research skills were read before this one was written. None of them was imported, and most of the body rests on paired searches measured in this skill's `REQUIREMENT.md` rather than on any of them. A later session extending the skill adds to this file rather than re-arguing an item settled here.
+Three third-party research skills were read before this one was written. None of them was imported, and most of the body rests on paired open and scoped searches run against this skill's own question rather than on any of them. A later session extending the skill adds to this file rather than re-arguing an item settled here.
 
 ## Adopted
 
@@ -37,6 +37,6 @@ None of the three is one, and each earns its keep on access and cost instead. A
 
 ## Stated by no source
 
-**Naming the field and deriving its authorities.** No comparable skill takes a thinking step before searching. The step rests on the paired open and scoped searches recorded in `REQUIREMENT.md` under `Gap`, where the scoped run returned primary sources and caught a wrong version number the open run carried.
+**Naming the field and deriving its authorities.** No comparable skill takes a thinking step before searching. The step rests on paired open and scoped searches, where the scoped run returned primary sources and caught a wrong version number the open run carried.
 
 **Preferring a public API over a fetched page.** It rests on the same probes, where the scholarly and reference APIs returned the dates, authors, and identifiers a citation needs and a fetched page returned a summary.

package/claude/skills/session-compact/REQUIREMENT.md

@@ -7,36 +7,26 @@ description: Why a plain session needs a handoff surface that is not the task bo
 
 ## Gap
 
-Without this skill, a session facing a compaction reaches for `session-map`, which writes `.canon/tasks/session-<slug>.md`. The board carries four such files today, and `session-resume` drops them by name prefix to read the real rows, so a reader works around a misplacement on every run.
+Without this skill, a session facing a compaction reaches for `session-map`, which writes onto the task board in the orchestrator's shape. That shape runs a drift check against a start commit nothing records and fills a `## State` section, so a session that shipped nothing pays for both and leaves a file every board reader filters out.
 
-`session-map` also carries the orchestrator's shape: a drift check against a start commit nothing records, a step for role sections, and a `## State` section. A session that shipped nothing pays all three to leave one note behind, and the `session-map` skill's `references/session.md` already names a `## State` filled from the tree as non-conforming, which is the failure that shape invites.
-
-Sessions also write the wrong thing into a handoff. They restate the tree, which survives a compaction, and omit what each decision beat, which does not.
+Sessions also write the wrong thing into a handoff. They restate the tree, which survives a compaction, and omit what each decision beat, which does not. A session about to move machines finds no surface naming the push and export it needs first.
 
 ## Must
 
-- Write to `.canon/compact/`, outside the task board and outside scratch.
-- Carry a stated shape for the note, so what belongs in it is not re-derived per session.
-- Require a citation for every claim, and a rejected alternative beside every decision.
-- Decline in one line where the session holds nothing a compaction would destroy.
-- Name `canon records push` then `canon sessions export` in the report when the caller asked to move the session to another machine, since this is the step a session takes before it moves and no other skill names either verb.
+- The note lands in `.canon/compact/`, outside the task board and outside scratch, and in a stated shape
+- Every claim carries a citation, and every decision carries the alternative it rejected
+- A session holding nothing a compaction would destroy gets a one-line decline rather than a padded note
+- A caller who asked to move the session gets `canon records push` then `canon sessions export` named in the report
+- The skill keeps a caller of its own beyond an operator typing it, being the `PreCompact` hook naming it on a manual compaction
 
 ## Must not
 
-- Write a task row, a plan, or anything under `.canon/tasks/`.
-- Write a `## State` section, or any section a reader could fill from `git status`.
-- Run a drift check or recover a start commit. Both belong to the role that ships code.
-- Lose its caller. The `PreCompact` hook names this skill on a manual compaction, and that hook plus an operator typing it are the two callers the third creation question asks for. A hook edit that names another skill leaves one caller, which is a reason to revisit this skill rather than to keep it.
-
-## Guards
-
-- No repository is required. The slug comes from the work, so a session outside git still writes a note.
-- `.canon/` resolves at the main worktree root. From a linked worktree the write goes through the shell, since the file-editing tools refuse that path.
-- Decline rather than pad. A note a reader finds is a note a reader trusts.
-- The note is backed up by `canon records push`, which carries every top-level `.canon/` folder, and the push is a run someone makes. Until it runs, or where no remote is configured, the note sits on one disk. The skill's report does not say so on an ordinary note, since it would restate a run the operator owns on every note. A caller who named a move is the exception, because the push is then the step the move depends on rather than a reminder, and the line prints on that report alone.
+- Write a task row, a plan, or anything under `.canon/tasks/`
+- Write a `## State` section, or any section a reader could fill from `git status`
+- Run a drift check or recover a start commit, which belong to the role that ships code
 
 ## Out of scope
 
-- The orchestrator's handoff, which carries a drift check and a board row: `canon:session-map`. The two skills are held apart by role, so a plain session belongs here and a session holding `canon:role-orchestrator` belongs there.
-- Reading a handoff back: `canon:session-resume`, which reads `.canon/compact/` ahead of the older task-board form.
-- A decision a groundwork track owns, which belongs in that track's `06-decision.md`: `canon:plan-groundwork`.
+- The orchestrator's handoff with its drift check and board row, which `session-map` owns
+- Reading a handoff back, which `session-resume` owns
+- A decision a groundwork track owns, which `plan-groundwork` owns in that track's decision file

package/claude/skills/session-map/REQUIREMENT.md

@@ -7,44 +7,28 @@ description: Why the write procedure needs a board-side route for the orchestrat
 
 ## Gap
 
-Without this skill, the standard governing the pre-compaction handoff carries a complete numbered write procedure and nothing routes a session to it. The reading half already works, since the resume path opens the newest map and leads its report with it, so a file nobody is routed to write is read by a surface built to find it.
+Without this skill, the standard for the board-side handoff carries a full write procedure and nothing routes a session to it, though the resume path reads the newest map first. The only other routed writer is the orchestrator role, which hands a plain session a section it cannot fill.
 
-The only routed writer belongs to the orchestrator role. It disables model invocation, asserts that role on invocation, and adds a section for decisions taken under delegated authority, so a plain feature session that reaches it receives a section it cannot fill and a review poll it does not run.
-
-The drift step is the one most specific to session length and the easiest to skip. It reads the commit the session started from, nothing on the machine records that commit, and a route that names the step without naming how to recover the ref ships an instruction nobody can follow.
-
-A step that reads a surface a project may not carry gets skipped on the reasoning that it has nothing to act on. A cold session run against a project with no `.claude/` tree skipped the drift step and wrote its own rationale into the map, so the step the route exists to carry did not run on the first test from outside. The skip is worst where it looks most defensible, and a session that takes it quietly leaves a map indistinguishable from a conforming one.
-
-A body that restates the sections, the frontmatter, or the numbered steps becomes a second source that drifts from the standard, which is the failure the split between the role writer and the core was made to remove rather than move.
+The drift step reads a start commit nothing on the machine records, so naming the step without its recovery ships an instruction nobody can follow. Where the step's surface is missing, a session skips it as having nothing to act on and leaves a map that looks conforming. A body restating the standard drifts from it.
 
 ## Must
 
-- Write for an orchestrating session, or on a request naming the session map or the board, without asserting a role the session does not hold
-- Cite the standard for the filename, the frontmatter, the sections, the numbered procedure, and the citation rule rather than restating any of them
-- Run the drift step and state how to recover the ref it reads from how long the session has run
-- Record what the drift verb names, and read a refusal as the boundary of what the verb can read
-- Resolve the folder at the main worktree root, and write the file whole from the shell where the editing tools refuse that root
-- Fall back to the branchless filename on an empty slug rather than stopping
-- Leave model invocation enabled, so a session that has dropped its routing still reaches this by description
+- An orchestrating session, or a request naming the session map or the board, reaches the write without the skill asserting a role the session does not hold
+- The filename, frontmatter, sections, numbered steps, and citation rule come from the standard by citation, never restated
+- The drift step runs, its start ref is recovered from how long the session has run, and what the verb names or refuses is recorded as the boundary of what it read
+- The file lands whole at the main worktree root, through the shell where the editing tools refuse that root, under the branchless filename when the slug is empty
+- Model invocation stays enabled, so a session that has dropped its routing still reaches the write by description
 
 ## Must not
 
-- Restate the standard's sections, frontmatter, or numbered steps
 - Skip a step by predicting what its skill or verb would have answered, rather than running it and recording what came back
-- Assert a role, or add a role's section to a map written by a session holding no such role
+- Add a role's section to a map written by a session holding no such role
 - Take the worktree-local copy the editing tools offer in place of the main-root path
-- Summarize the board, the task files, or the work that shipped, each of which is carried by an artifact a compaction leaves standing
-
-## Guards
-
-- Not a git repository: stop, since the filename comes from the branch
-- Empty slug: fall back rather than stop, since the reasoning is worth more than the name
-- The drift verb refusing: record the boundary under standing cautions and keep writing
+- Summarize the board, the task files, or the shipped work, each of which survives a compaction on its own
+- Write a map outside a git repository, since the filename comes from the branch
 
 ## Out of scope
 
-- The handoff a plain session writes before a compaction, which is a note outside the board with no drift step and no `## State`: `session-compact`. Both skills once claimed the phrases "write the handoff" and "about to compact", so this description narrows to the orchestrator and to a request naming the map or the board, and a plain session belongs to `session-compact`.
-- Reading a handoff back at the start of the next session: `session-resume`
-- The sections a role adds over the core three, which belong to that role's own surface. `role-orchestrator` owns the orchestrator's and cites this route for the generic half.
-- Validating a written map against the standard, which no record kind covers, so a conforming shape rests on the standard being followed
-- Firing the write without being asked, which is a question about what the harness supports and is measured on its own track
+- The note a plain session writes before a compaction, outside the board and with no drift step, which `session-compact` owns
+- Reading a handoff back at the start of the next session, which `session-resume` owns
+- The orchestrator's sections over the core three, which `role-orchestrator` owns

package/claude/skills/session-relay/REQUIREMENT.md

@@ -1,76 +1,32 @@
 ---
 name: session-relay
-description: Why a standalone skill with no firing condition never fired, why the first inline draft repeated the same protocol in two bodies, why the missing sender identity sat unaddressed through both attempts, and why the two guards that scoped it to a session holding a role and no send tool came off
+description: Why sending to another session is one skill any session reaches, why it resolves the address and names the sender, and why the message body and the addressee stay with the caller
 ---
 
 # Session relay requirement
 
 ## Gap
 
-Without this skill, every session that owes another session a message resolves
-the addressee itself. `role-worker` and `role-planner` each state the messages
-owed and each carried the resolution inline, and a session holding neither role
-carried it nowhere, so the mechanical half of the send existed in two copies
-plus however many a roleless caller improvised.
+Without this skill, every session that owes another a message resolves the addressee itself, so one protocol lives in each role body and in whatever a roleless session improvises, and a fix reaching one copy misses the rest. A skill matched only by request never fires, so firing rests on the pointer in each role's channel section.
 
-A standalone skill was proposed for the gap and declined the same day. It fired
-on no condition of its own, since nothing routes a session to a skill matching
-no request and reaching for no artifact, so a skill built to close the gap never
-closed it. That history is why the pointer inside each role's
-`## The channel` section still matters: it is a section both bodies read at
-session start rather than one reached by request match alone, and it is what
-makes the firing survive.
-
-The first draft of this plan closed the gap with a paragraph drafted inline,
-once inside `role-worker` and once inside `role-planner`. The operator overrode
-that call: two bodies carrying identical protocol text is the shared-surface
-case, since a later
-fix reaching one copy and not the other diverges silently.
-
-Neither attempt named who the relay is from. A message an operator relays by
-hand needs a sender as much as an addressee, and the standalone draft and the
-inline draft both composed a body and an addressee with no line stating whose
-turn produced it.
-
-Scoping the skill to a session holding a role and no send tool left two holes
-rather than one. A session holding neither role had no `## The channel` section
-to carry the pointer and was refused outright on arrival. A session that held a
-role and a send tool was refused too, which left the resolution ladder
-duplicated in both role bodies for the ordinary case. Both guards came off
-together, since the mechanics are the same whichever route carries the text.
-
-No governance rule carries the addressing or the reason for the order, so this
-body is the only surface stating either for a session holding neither role. A
-project that installs governance without the plugin therefore gets no surface
-telling a roleless session to send before it prompts, a cost the operator
-accepted over a rule loading into every session of every governed target.
+A relayed message carries no sender, so an operator cannot say whose turn produced it. A name prefix can resolve to the wrong session and still report success. A send to another repository's session, or from a sender with no roster row, lands where nobody asked for it. Nothing else tells a roleless session why a block goes before a prompt.
 
 ## Must
 
-- Fire for any session sending to another session, with or without a role and with or without a message-sending tool
-- Read the sender's own name off `canon sessions list --self --json` before composing anything, and degrade to naming itself from the environment when the installed CLI answers `--self` with an unknown option rather than a refusal carrying a reason
-- Resolve the addressee from a `sessionId` or a branch at the moment of sending, never by a name prefix
-- Check the resolved name against the agent listing, sending it bare under a single row and completing it with the `[ref]` under more than one
-- Send through a message-sending tool where one exists, and compose the copyable block where none does or where the listing carries no row to address
-- State why a block goes out before a prompt as the only surface carrying that reason, since no rule carries it and a caller restating the reason drifts from this body with nothing comparing them, while each caller still states that the message is owed
-- Carry the message body verbatim from whatever names it
-- Open the composed text with a header naming the sender, the addressee, and what the message is
-- State the header as a default a session may write around, rather than a fixed vocabulary
+- Any session sending to another reaches the skill, with or without a role or a send tool, and a send to a row in another repository is refused unless the caller names the operator's ask
+- The sender's name comes from `canon sessions list --self --json`, degrading to a name from the environment when the installed CLI lacks `--self`, and a sender with no roster row reads as unread
+- The addressee resolves from a `sessionId` or a branch at the moment of sending, never by name prefix, and is checked against the agent listing with its `[ref]` added under more than one row
+- The send goes through a message-sending tool where one exists, and a copyable block opening on a sender, addressee, and purpose header is composed where none does or the listing has no row
+- The body carries the message verbatim from its caller, and states why a block goes out before a prompt as the one surface holding that reason
 
 ## Must not
 
-- Draft a message body of its own. The text it composes belongs to the calling role's bullet or to the dispatch.
-- Decide who the message goes to. The caller names an id or a branch and this body turns it into an address.
-- Restate the last-rung inference `role-worker` and `role-planner` each carry, which differs between them
-
-## Guards
-
-- The roster cannot name the sender: report the refusal and its reason in place of a name
-- The resolution returns no row: report it rather than guessing, since the roster and the send channel enumerate different populations in both directions
-- The caller named no addressee at all: defer to the calling role's own last rung, and ask the operator where one is present
+- Draft a message body of its own
+- Decide who the message goes to, or guess an addressee when the resolution returns no row
+- Restate the last-rung inference the role bodies each carry
 
 ## Out of scope
 
-- Which messages are owed and when, which stays in the calling role's own bullet or in the dispatch
-- The last-rung inference, which stays in `role-worker` and `role-planner` because a worker holds a feature branch and a planner does not, so the two discriminate differently
-- Inbound reach as a distinct case. A relay in either direction is one session sending to another, which is what this body now covers.
+- Which messages are owed and when, which the calling role or the dispatch owns
+- The last-rung inference for a worker, which `role-worker` owns because a worker holds a feature branch
+- The last-rung inference for a planner, which `role-planner` owns because a planner holds none

package/claude/skills/session-relay/SKILL.md

@@ -34,6 +34,12 @@ The caller names the addressee as a `sessionId` or a branch, never as a name. A
 - From a `sessionId`: run `canon sessions list --json`, find the row carrying that id, and take the `name` on it
 - From a branch: take the row whose `branch` matches. Nothing renames a session when it takes a role, so an id is the stronger key and a branch the fallback.
 
+### Refuse another repository
+
+Refuse a send to a row whose `repository` differs from the sender's own, unless the caller names the operator's ask. Read the sender's repository from the Step 1 row and report the refusal with both paths.
+
+When Step 1 returned no row, the sender's repository is unread, so the comparison cannot run. Report it as unread and send only when the caller names the operator's ask.
+
 ### Check the name against the agent listing
 
 A name is not unique, and the roster carries no field separating two live sessions holding one. Check the name against the agent listing before sending.

package/claude/skills/session-resume/REQUIREMENT.md

@@ -7,41 +7,27 @@ description: Why resuming reads the handoff before the board, reads an index bef
 
 ## Gap
 
-Without this skill, a session picking up old work reconstructs state from the git log, which records what shipped and not what is queued, so finished work reads as pending and the actual next item goes unmentioned. The alternative failure is worse for a different reason. A session that reads every task file and every plan to be thorough spends the context the work needs before the work starts, and the summary arrives in a session with no room left to act on it.
+Without this skill, a session picking up old work rebuilds state from the git log, which records what shipped rather than what is queued. Reading every task file spends the context the work needs before it starts. A resume reading only the board walks past the handoff written to survive the compaction.
 
-A compaction keeps conclusions and drops the reasoning that produced them, and the previous session can write that reasoning to a handoff before it goes. A resume that reads the board and the plans alone walks past that file, so the one artifact written to survive the compaction reaches nobody and the next session re-derives what it holds.
-
-The task index is a folder catalog rather than a task filter, so it carries a row for the ordering file and one for every handoff on the board. A session reporting each row as a backlog item queues work nobody filed, and the count grows with every session that ever wrote a handoff.
-
-From a linked worktree the shared scratch folders resolve against the worktree rather than the main root, where they are empty. That reports no tracked work on a repository carrying a full backlog, and the report is indistinguishable from the true empty case.
-
-A resume is a read, and a session that treats it as a cleanup pass offers to archive finished entries or rewrite a plan it decided was stale. Both change tracked state on the strength of a summary the user has not confirmed yet.
+The task index catalogs the folder rather than filtering it, so its rows include the ordering file and every handoff. From a linked worktree the scratch folders resolve empty, which reads as no tracked work. A resume treated as cleanup offers to archive entries on a summary nobody confirmed.
 
 ## Must
 
-- Read the newest handoff before the board, and report what it carries attributed to its writer
-- Resolve the handoff, plans, and tasks folders at the main worktree root
-- Read the task index before any individual task file, and open only the task files the summary needs
-- Drop the board siblings from the index before reporting it as the backlog, since the catalog filters nothing and carries a row per handoff
-- Preserve the index's order in the report, since the order is the priority
-- Close with one recommendation naming the first item and whether a plan backs it
+- The newest handoff is read before the board and reported under its writer's name, its counts and sizes framed as true when written
+- The handoff, plans, and tasks folders resolve at the main worktree root
+- The index is read before any task file, its board siblings dropped, its order kept as the priority, and only the task files the summary needs opened
+- The report closes on one recommendation naming the first item and whether a plan backs it, or what a handoff leaves open beside an empty board
+- Every surface absent or empty reports no tracked work and stops
 
 ## Must not
 
 - Read the whole tasks folder to build a summary
-- Report the absence of a handoff, which is the common case and would train a reader to skip the line on the run where one exists
-- Restate a handoff's counts, sizes, or costs as current. Each was true when written.
-- Offer to remove, archive, or reorder an entry. Resume reports and does not mutate.
-
-## Guards
-
-- Every surface absent or empty reports no tracked work and stops, rather than inventing a next step from the repository
-- A handoff found beside an empty board recommends what the handoff leaves open, since the guard passes on the handoff alone and the recommendation has no backlog item to name
+- Report that no handoff exists, which is the common case and trains a reader to skip the line
+- Offer to remove, archive, or reorder an entry, since a resume reports and does not mutate
+- Invent a next step from the repository when the board is empty
 
 ## Out of scope
 
-- Writing a handoff, which happens at the close of a session rather than at its start. This skill names the standard that governs one and follows it no further.
-- The sections a role adds over the core handoff, which belong to that role's own surface
-- Archiving a shipped task out of the folder: `task-complete`
-- Marking an outcome, which `task-complete` does when the work ships, and archiving a plan, which the merge does
-- Implementing the item it recommends, which is the next request rather than part of this one
+- Writing a plain session's handoff, which `session-compact` owns
+- Writing the board-side map, which `session-map` owns
+- Marking an outcome or archiving a shipped task, which `task-complete` owns