@erclx/canon 5.44.0 → 5.46.0

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

@@ -7,58 +7,30 @@ description: What a building session is, the shared surfaces it may not write, a
 
 ## Gap
 
-Without this skill, a building session is told what to do and never what it is. One shipped body asserts a session role and it is the orchestrator, so worker behavior spreads across three skills that each own a step and none of them names the role or the channel it runs on. The handback works because a session reading plain text tends to follow it rather than because anything says it should, which held while a person launched every worker and stopped holding the first time one ran with nobody watching.
+Without this skill, a building session is told what to do and never what it is. It writes shared surfaces, hand-writing the board from a stale copy, filing a task with no row, or re-drafting a readied pull request. From a linked worktree it finds no plan folder and reports the task has no plan.
 
-The session then writes surfaces nothing told it were shared. One worker split a concern its own run could not reach, hand-wrote the priority board from a copy taken minutes earlier, and reverted a promotion with nothing reporting it, on a board that still validated afterwards because a reverted row is a well-formed board. A second added a row and labelled it with an identifier another row already held. The rule against both sits inside the controlling session's own body, which no worker loads.
-
-Standing in a linked worktree fails one step earlier and reports confidently while it does. The plan folder is gitignored, so `git worktree add` never creates it, and a worker reading it from the build tree reports that the task has no plan. That is true from where the session stands and wrong about the world, and a reader holding no second tree cannot tell those apart. Three workers hit it in one day and an absolute path unblocked all three.
-
-A blocked worker reaches nobody at all. Two dispatched sessions opened an interactive prompt inside a background session no operator was attached to, and the roster read both as alive throughout. An answer relayed afterwards arrives and does not land, since a queued message drains at the next tool round and a session waiting on input never reaches one, so the channel closes the gap only when it is used before the prompt opens. One of the two held uncommitted work across three files, which made stopping and relaunching a destructive recovery rather than a free one.
-
-Finishing is invisible from the other side. A worker that opens a pull request goes idle rather than exiting, so the one push signal available fired for a worker that was stopped and never fired for the one that finished, which then sat unnoticed for eighteen minutes. Polling covers that interval by spending a fixed cost against a worker with no pull request to report, measured as five consecutive runs reporting no movement across roughly fifteen minutes while one worker built.
-
-Nothing tells the session that refusing is allowed either. Four occasions across two days had a worker halt correctly with the cost falling on the dispatcher, and the correction that mattered most reached the right place because a worker argued back with evidence rather than complying. A role written only as report-upward suppresses exactly that.
-
-The draft mark fails from both ends. On 2026-08-31 four sessions re-drafted a pull request someone had readied, acting on a belief no surface in the tree stated. On 2026-09-07 a controlling session told a worker to lift the mark rather than lifting it itself, and the worker complied and reported against the surface rather than the outcome. From 2026-10-12 `canon pr lift` reads the gates itself, so the reviewers run it on a close and the controlling session runs it as the fallback. A worker leaves the verb to them and readies a pull request directly for nobody, since a direct ready skips every gate the verb reads.
+The channel fails on the worker's side. Blocks open prompts nobody is attached to, and a finished pull request goes idle unannounced or stalls silently on its reviews. Painted ones ship with no address for the UI reviewer. Late asks widen the reviewed scope, and a worker told only to report upward never argues back.
 
 ## Must
 
-- Assert what a building session is, what it may not do, and how long the role lasts, since the three step-owning skills each carry a procedure and none carries a role
-- State that session scratch resolves at the main worktree root, since a linked worktree holds none of those folders and their absence reads as a missing artifact rather than as a wrong vantage
-- State the shared board as read-only for a building session and name what it does instead when a row is owed, since a task file with no row is a dropped task and placing the row is the controlling session's call
-- Owe an announcement the moment the pull request opens, carrying the number, the branch, and the task, since that transition is the one interval only the worker can observe
-- Carry a row the build turned up in the pull request announcement, and send it alone only when the session ends before a pull request opens, since the worker files no task file of its own and the channel is the row's only route
-- Carry a fan-in member's branch and head commit in its done message in place of a pull request number, and end its role at the push, since a member opens no pull request and its integrator fixes what the merge surfaces
-- Send the controller the `canon pr review-state` record when a wait for the reviews times out, rather than waiting on, since a worker improvising that read stalled silently with both reviewers idle behind it
-- 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
-- Defer the addressee resolution to `session-relay` and keep only the operator ask and the last-rung inference, which discriminates here because a worker holds a feature branch and a controller does not, and which falls back to the roster and says so, since an operator's own launch names nobody
-- Keep refusing a dispatcher a first-class move carrying its evidence, since the halts measured so far were correct and the cost of each fell where it belonged
-- State that a held body may be older than the branch under it, since a plugin skill loads from the marketplace cache rather than from the working tree
-- Carry a talk clause for a launch whose operator is in the session, asking them at a judgment call and sending a close message when they end the conversation, since a cold worker's halt-toward-the-controller and merge-ends-the-role rules contradict a brief that asks it to talk
-- Freeze the plan's scope at dispatch, sorting a late ask into a defect to fix, a follow-up row to report, or an addition the operator's word admits with its re-review cost stated, since intake 155 measured about four UI review rounds on one pull request from late asks, each re-running both reviews
-- Own the local preview server for a painted diff, started as a tracked background command before the pull request opens, since a `no-server` read leaves the evidence comment and the UI reviewer without an address on the one path nobody watched being built (erclx/frameboard#1 and erclx/frameboard#4)
-- Point at `session-worktree`, `auto-ship`, and `review-address` for the steps each already owns
+- Session scratch resolves at the main worktree root, and a plan that fails to resolve is reported unreadable from there rather than absent
+- 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
 
 ## Must not
 
-- Restate a procedure any of the three step-owning skills carries, since thinness is what keeps one body correct for a dispatched worker reading it as its whole contract and for a hand-launched one reading it beside a person
-- Restate a boundary the orchestrator already states about itself
-- Report progress through the channel, which rebuilds on the sender's side the poll the announcement exists to retire
 - Write the priority board or the backlog, at any size
-- Create a task file for work the build turns up, through `task-board` or by hand, since the file lands with no row and the placement is not the worker's to make
-- Be a skill nothing invokes but its author typing the name. `auto-ship` Step 0 invokes it on every build, dispatched or hand-launched, so a stretch where only a typed invocation reaches it is the signal that the role never took.
-
-## Guards
-
-- Plan path does not resolve from inside the worktree: report it unreadable from here and name the main-root path, rather than reporting the task as having no plan
-- Plan carries a suggestion written as needing the operator's call: halt and message, rather than answering it
-- Launch named no controlling session: resolve from the roster, address the match, and say the addressee was inferred
-- No live session holds the other end: report what would have been sent and stop, rather than retrying or waiting
+- Create a task file for work the build turns up
+- Ready the pull request directly, or re-draft one someone readied
+- Report progress through the channel
+- Restate a procedure `session-worktree`, `auto-ship`, or `review-address` carries
 
 ## Out of scope
 
 - Entering the worktree, which `session-worktree` owns
 - The chain from implement through pull request, which `auto-ship` owns
-- How the build moves through the plan, slice by slice with a commit each, which `build-in-slices` owns
+- Moving through the plan slice by slice, which `build-in-slices` owns
 - Answering a posted review, which `review-address` owns
-- The controlling session's half of the channel, the review poll, and the watch beside it, which `role-orchestrator` and its runbooks hold
+- The controlling session's half of the channel and the review poll, which `role-orchestrator` owns

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