@erclx/canon 5.45.0 → 5.46.0

package/claude/skills/git-stage/REQUIREMENT.md

@@ -7,33 +7,27 @@ description: What commit grouping is for, the gaps it closes, and how it differs
 
 ## Gap
 
-Without this skill, a staged diff spanning several concerns lands as one commit, so a later revert takes unrelated work with it. A renamed file staged as two separate paths records an add and a delete, losing the rename git would otherwise detect. Commits also land in the order the files happened to be listed rather than the order they depend on, so a bisect stops on a commit that cannot build.
+Without this skill, a staged diff spanning several concerns lands as one commit, so a later revert takes unrelated work with it. A renamed file staged as two paths records an add and a delete, and commits land in listing order rather than dependency order, so a bisect stops on a commit that cannot build.
 
-The routing failure sits on top of those. A description claiming every commit request pulls in the single-concern one this skill has no grouping to do on, and a staged set carrying a hunk-level selection reaches the unstage below and comes back widened to whole files, which is the one case the staged-set rule cannot hold.
+The routing fails on top of that. A description claiming every commit request pulls in single-concern sets with nothing to group, and a hunk-level selection reaching the unstage comes back widened to whole files.
 
 ## Must
 
-- Read the commit format reference and the prose standard before generating
-- Decline the single-concern and the hunk-level staged set in the description, naming the sibling that takes each. The widening is a property of the unstage, so it cannot be fixed here and has to be routed around.
-- Derive the groups from the staged diff, with lockfiles excluded from the derivation context
-- Account for every staged file in the preview, so a dropped file is visible before execution
-- Order the commits so a dependency lands before the file that imports it
-- Keep a rename pair in one group and restage both paths together, so git still detects the rename at commit time
-- Unstage everything first, then restage per group, since the incoming staged set is one undifferentiated blob
-- Count each subject against the length limit and shorten before executing
+- Each message follows the commit format reference, derived from the staged diff with lockfiles excluded, with each subject counted against the length limit before executing
+- Every staged file is accounted for in the preview, and no file the user did not stage is committed
+- Commits are ordered so a dependency lands before the file that imports it
+- A rename pair stays in one group, so git still detects the rename
+- The description declines single-concern and hunk-level staged sets and names `git-commit` for both
 
 ## Must not
 
-- Stage a file the user did not stage. The staged set is the input and widening it changes what ships.
+- Stage a file the user did not stage
 - Split a rename pair across groups
-- Emit anything after the result line. This runs inside a longer flow and prose here buries the next step.
-
-## Guards
-
-- Nothing staged: stop and name the command that stages
+- Run when nothing is staged
+- Emit anything after the result line
 
 ## Out of scope
 
-- Composing a single commit from the whole staged diff, which `git-commit` owns. That skill commits the staged set untouched, so a hunk-level selection belongs there and never here.
-- Splitting commits across branches, which `git-split` owns. The two partition different things: this one takes a staged diff and emits commits, that one takes commits and emits branches.
+- Composing one commit from the whole staged diff, which `git-commit` owns
+- Splitting commits across branches, which `git-split` owns
 - Pushing and opening the pull request, which `git-pr` owns

package/claude/skills/git-worktree/REQUIREMENT.md

@@ -7,32 +7,28 @@ description: What worktree listing and cleanup is for, the gaps it closes, and w
 
 ## Gap
 
-Without this skill, linked worktrees accumulate past the point where any of them is remembered. Merge state does not appear in the worktree list, so a cleanup either removes a worktree still holding unmerged work or, lacking a way to tell, removes nothing. Removing a worktree also leaves its local branch behind, so the branch list keeps growing even when cleanup runs.
+Without this skill, linked worktrees accumulate past the point where any of them is remembered. Merge state does not appear in the worktree list, so a cleanup either removes a worktree still holding unmerged work or removes nothing.
+
+A plain ancestry read misses the whole set, since `git branch --merged` decorates every branch checked out in a worktree. Removing a worktree also leaves its local branch behind, so the branch list keeps growing even when cleanup runs.
 
 ## Must
 
-- Resolve merge state per branch from the pull request first, and fall back to local ancestry when no pull request exists
-- Match the ancestry fallback against the branch name alone. `git branch --merged` decorates the current branch and every branch checked out in a linked worktree, which is the whole set this skill enumerates.
-- Remove the worktree and its local branch together, since either one left alone is the state the skill exists to prevent
-- Exclude five kinds of row from the remove set: the main root, the current session's worktree, any dirty tree, any worktree registered from outside the path prefix `session-worktree` creates under, and any worktree a live session is occupying
-- Give every skipped row a one-word reason, so the skip is a decision the user can overturn rather than a silence
-- Pick exactly one mode. Listing and removing are different requests and inferring both from one invocation removes worktrees the user meant to read about.
+- Merge state comes from the pull request first and from local ancestry matched on the branch name alone when no pull request exists
+- A worktree and its local branch are removed together
+- The main root, the current session's worktree, a dirty tree, a worktree outside the prefix `session-worktree` creates under, and one a live session occupies are never removed
+- Every skipped row carries a one-word reason, and an empty remove set says why each row was held
+- Each run is exactly one of listing or removing
 
 ## Must not
 
-- Enter or create a worktree. The description states the boundary so the model routes entry elsewhere rather than discovering it here.
-- Remove a worktree with uncommitted work, whatever its merge state
-- Remove a worktree a live session is occupying, whatever its merge state
-- Remove the worktree the session is currently running in
+- Enter or create a worktree
+- Remove a dirty or occupied worktree, whatever its merge state
+- Remove the worktree the session runs in
+- Run outside a git repository
 - Emit anything after the result line
 
-## Guards
-
-- Not a git repository: stop
-- Remove set is empty: stop and say why every row was held back
-
 ## Out of scope
 
-- Entering a worktree, which `session-worktree` owns. That skill derives the name and aligns the branch, and this one never creates.
-- Deciding which features can run in parallel, which is a planning call rather than a git operation
-- The pull request lifecycle, which `git-pr` and `git-followup` own. This skill reads pull request state and never writes it.
+- Entering a worktree, which `session-worktree` owns
+- Writing pull request state, which `git-pr` and `git-followup` own
+- Deciding which features can run in parallel, which the planning skills own

package/claude/skills/make-deck/REQUIREMENT.md

@@ -7,38 +7,30 @@ description: Why the skill draws a deck as HTML in the project's tokens inside i
 
 ## Gap
 
-Without this skill, a deck request turns into hand-built output. The session writes a deck into whatever path occurs to it, so a second deck overwrites the first and nothing lists either. It writes pptxgenjs code or hex colors per deck, so the deck takes neither the project's design nor any other deck's, and it invents attributes the converter does not read, so a section, a chart, or an entrance silently goes missing. Every slide comes out as a title over bullets, which is the shape that needs no decision and reads as a document rather than a deck.
+Without this skill, a session writes a deck into whatever path occurs to it, so a second deck overwrites the first and nothing lists either. It writes pptxgenjs code or hex colors, so the deck ignores the project's design. Every slide comes out as a title over bullets, which reads as a document rather than a deck.
 
-A first render shipped unread hands the audience the overlap, the overflow, and every element the converter fell back to a picture for, since markup that looks correct says nothing about the file it produces.
+It invents attributes the converter does not read, so a section, a chart, or an entrance silently goes missing. A first render shipped unread hands the audience the overlap, the overflow, and every element the converter fell back to a picture for.
 
 ## Must
 
-- Read the existing decks and the slide format from the CLI before drawing, and pick a deck name no listed deck carries unless the request names one
-- Write each deck into its own folder under the slides record folder, one HTML file per slide in filename order
-- Draw with the project's custom properties so the deck takes the project's design
-- Vary the composition across the deck rather than repeating one shape
-- Size content to fit the slide frame, keeping titles short and lines tight
-- Shell out to the render command for the deck itself
-- Read every fallback and refusal the render reports, run one QA pass over the rendered images, and fix what both report
+- The existing decks and the slide format are read from the CLI before drawing, and a new deck takes a name no listed deck carries unless the request names one
+- Each deck lands in its own folder under the slides record folder, one HTML file per slide in filename order, drawn with the project's custom properties
+- The composition varies across the deck, and content fits the slide frame with short titles and tight lines
+- The render command produces the deck itself
+- Every fallback and refusal the render reports is read, one QA pass runs over the rendered images, and what both report is fixed once
 
 ## Must not
 
-- Hardcode a deck name, an attribute, or a chart type, which goes stale the moment the CLI changes
-- Reimplement the conversion, the master, or the packaging, which the CLI owns
+- Hardcode a deck name, an attribute, or a chart type, or reimplement the conversion, the master, or the packaging the CLI owns
 - Write a deck into the shared layouts folder, which is never listed as a deck
-- Invent token values when the project has no token stylesheet
+- Invent token values when the project has no token stylesheet, rather than saying the deck renders unstyled
 - Write centered body text or content that overflows a slide
-- Loop on aesthetics past a single fix pass
-
-## Guards
-
-- No token stylesheet: draw the deck anyway and say it renders unstyled.
-- Image conversion tools missing: skip the image pass and say so. Do not fail the render over a verification step.
+- Loop on aesthetics past a single fix pass, or fail the render when the image tools for the QA pass are missing
 
 ## Out of scope
 
 - Converting HTML to PowerPoint, which the CLI owns end to end
-- The project's palette and faces, which live in its token stylesheet rather than in the slides
-- Writing the content the deck is about, which the caller brings
-- Drafting a deck as a canvas page, which waits on a measurement of that authoring surface
+- The project's palette and faces, which its token stylesheet owns
+- Writing the content the deck is about, which the caller owns
+- Drafting a deck as a canvas page, which no skill owns until that authoring surface is measured
 - Recording a demo, which `script-screencast` owns

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

@@ -7,9 +7,9 @@ description: Why the markdown format rules travel in a skill, and where the boun
 
 ## Gap
 
-Without this skill, the markdown format rules sat in a standard that a session opened only when a rule told it to. The banned characters and the structure rules are facts a scan settles, yet a session wrote the whole document from memory and learned the result only from the audit's exit.
+Without this skill, the markdown format rules sit in a standard that a session opens only when a rule tells it to. The banned characters and the structure rules are facts a scan settles, yet a session writes the whole document from memory and learns the result only from the audit's exit.
 
-The rules also had three carriers, a standard, a generated rule pointing at it, and a second hand-written rule routing voice. Each stated one routing and each drifted from the others.
+The rules also have three carriers, a standard, a generated rule pointing at it, and a hand-written rule routing voice. Each states one routing and each drifts from the others.
 
 ## Must
 
@@ -20,4 +20,10 @@ The rules also had three carriers, a standard, a generated rule pointing at it,
 ## Must not
 
 - Restate the banned characters in the body
-- Carry voice, rhythm, or word guidance, which `write-human` owns
+- Carry voice, rhythm, or word guidance
+
+## Out of scope
+
+- Voice, rhythm, and word choice, which `write-human` owns
+- A Mermaid fence or a figure, which `draw-figure` owns
+- The banned-character scan itself, which `canon markdown audit` owns

package/claude/skills/plan-feature/REQUIREMENT.md

@@ -7,37 +7,28 @@ description: What feature planning is for, the gaps it closes, and why it stops
 
 ## Gap
 
-Without this skill, implementation starts before anyone knows what it touches. A session reads no project context and rediscovers a settled constraint halfway through, the file list emerges as the work goes rather than before it, and the ambiguities that needed a decision get resolved silently in whichever direction the first edit happened to go. A constraint naming a surface to leave alone forbids two different acts at once, so the executing session picks one and the branch either grows an excluded concern or ships a reference to a file the change deleted.
+Implementation starts before anyone knows what it touches. A session rediscovers a settled constraint halfway through, and an ambiguity gets resolved silently in whichever direction the first edit went. A feature stacked into pull requests over the same files pays the review cost once per slice.
+
+A constraint naming a surface to leave alone forbids two acts at once, conforming it and retargeting a pointer into it. A vague ask reaches the plan with no checkable criterion, and a decision rests on a practice recalled from memory.
 
 ## Must
 
-- Read the project's own Claude setup before scanning source, so the plan inherits decisions already made instead of reopening them
-- Reframe a vague ask as observable, checkable success criteria before listing any file, and carry each criterion into the plan's verification, so a plan never ships a check with nothing measurable to prove
-- Slice batches by a user-visible path rather than by layer, and sequence the riskiest batch first while a sweep stays last, so the batch most likely to change the plan lands while later ones can still move, and fold a stacked batch that shares most of its files into its parent unless the plan writes down why the two are judged apart, since a canvas inspector built as five stacked pull requests over 26 files paid the full review, rebase, and merge cost five times
-- Predict the operator's answers to the next three questions about the ask's success criteria, proceed on the ones it can predict, and ask when it can predict none, since a plan built on a guessed goal proves the wrong thing
-- Fetch the outside source a decision rests on, quote the passage relied on in the plan's `**Sources:**` section, and mark a source it could not fetch as unverified, since a planner that paraphrases a practice from model memory ships an unaudited claim. A measured planner run fetched its sources only after a follow-up message asked, and the `search-craft` measured run shows a plain research request never loaded that skill unprompted
-- Name every file the work touches with the reason it is touched
-- Place each new path against the layout guidance with a one-clause reason, loading that guidance only when the plan creates a file or folder, since the planner decides placement and the worker copies whatever path it is given
-- Name how each outcome is proven and which input or state would break the change, so the executing session has a check to run and the reviewer has a place to look
-- Surface each unresolved ambiguity as a numbered question carrying a suggested answer and an empty answer slot, so the plan is decision-ready in one pass
-- State which act a constraint forbids when it names a surface to leave alone, since conforming that surface and retargeting a pointer into it are different acts and only one is out of scope
-- Scale the output to the work. A two-file change with nothing to decide should not produce a plan file.
-- Stop at the plan and wait to be told to continue
+- Read the project's Claude setup before scanning source, and name every file the work touches with the reason it is touched
+- Reframe a vague ask as observable success criteria, carry each into the plan's verification, and ask when none can be predicted
+- Slice by user-visible path with the riskiest batch first, and fold a stacked batch sharing most of its files into its parent unless the plan says why they differ
+- Quote the fetched passage behind each outside source, mark an unfetched one unverified, and place each new path against the layout guidance with a one-clause reason
+- Surface each ambiguity as a numbered question with a suggested answer and an empty slot, and stop at the plan
 
 ## Must not
 
 - Implement, or edit any file the plan describes
-- Read directories speculatively. Context spent on files the feature does not touch is context the plan does not get.
-- Bundle independent concerns into one plan, since a plan covering two things gets executed as neither
-- Restate the plan in chat during follow-up rounds. The file is the source of truth and a chat copy of it goes stale immediately.
-
-## Guards
-
-- No feature description: stop and ask for one
-- No predictable success criterion: ask before planning rather than guessing the goal
+- Read directories speculatively, since context spent on files the feature does not touch is context the plan does not get
+- Bundle independent concerns into one plan
+- Restate the plan in chat during follow-up rounds, since the file is the source of truth
 
 ## Out of scope
 
-- Executing the plan, which is the ship pipeline
-- Task-board state, which `task-board` owns. A plan links to its task and does not create one.
-- Reconciling the context entries after the work lands, which `context-fold` owns, and marking the board, which `task-complete` owns
+- Executing the plan, which `auto-ship` owns
+- Creating a task for the plan, which `task-board` owns
+- Reconciling the context entries after the work lands, which `context-fold` owns
+- Marking the board, which `task-complete` owns

package/claude/skills/plan-groundwork/REQUIREMENT.md

@@ -7,43 +7,27 @@ description: Why a question that has not been measured gets a disposable folder
 
 ## Gap
 
-Without this skill, a question nobody has measured is answered with a plan. The session commits to an approach before the current state is known, and the reasoning that produced it lives in a conversation that compacts away. A research pass that does run spreads its findings across chat, so the next session re-measures what this one already counted, or worse carries a figure from recall and states it as current.
+A question nobody has measured is answered with a plan. The session commits before the current state is known, and its reasoning compacts away with the conversation, so the next session re-measures what this one counted or states a figure from recall as current.
 
-Two failure modes cost more than the rest. A track that fans out to subagents returns findings without the reasoning that makes the folder worth keeping, which turns a conversation into a search result. And an experiment fixture written under the project root loads that project's own instruction files through the ancestor chain, so the arm measures the repository instead of the question, and the result reads as evidence either way.
-
-A track that closes with several separable findings writes only one task, and the rest have no stated route out of the folder. Without one, a finding sits until the operator asks whether filing it elsewhere is the next step, which is how a track that measured everything correctly still lost work between sessions.
+A track fanning out to subagents returns findings without their reasoning. Under the project root, a fixture loads its instruction files, so the arm measures the repository instead of the question. When a closing track holds several findings, one task is written and the rest have no route out.
 
 ## Must
 
-- Detect open, resume, and close from the folder itself, matching the topic against tracks already there before deriving a slug
-- Name a newly opened folder with a two-digit ordinal ahead of the slug, taken from the highest one already present across groundwork and intake
-- Apply the qualifying test in open mode alone, so a track already measured is not refused by the test that admitted it
-- Measure the current state now rather than carrying a figure from a previous session
-- Carry a lean and the finding that would overturn it on every open question, or admit that a measurement is missing
-- Confine writes to the track folder, with the close-time task file, the experiment fixture, and the intake routing below as the only exceptions
-- Route a closing-track finding the required task does not cover through `plan-intake`, rather than leaving it to be asked about. The route runs in the same session, so it is a write outside the folder rather than a handoff to a later one.
-- Place the closing task's row through `task-board` Step 4 rather than writing `priority.md` or `backlog.md` directly
-- Link every claim about a source outside the project, and list an unread source as a lead rather than citing it
-- Put a fixture a headless run is pointed at outside the repository
-- Write the next-session file self-contained, since backing the folder through `canon records push` and `canon records pull` holds only where a records remote is configured, protects only against the machine being lost even there, and never against a compaction dropping this session's reasoning before it has pushed
+- Detect open, resume, and close from the folder itself, matching the topic against existing tracks first, and number a new folder past the highest ordinal across groundwork and intake
+- Measure the current state now, carry a lean and the finding that would overturn it on every open question, link every outside claim, and end a pass with every question leaned on a plain retell
+- Confine writes to the track folder, plus the close-time task file, the experiment fixture, and the intake routing
+- Route a closing finding the task does not cover through `plan-intake` in the same session, and place the closing task's row through `task-board`
+- Put a fixture a headless run is pointed at outside the repository, and write the next-session file self-contained
 
 ## Must not
 
 - Write a feature plan, a source change, a standard, a rule, or a reference doc
-- Dispatch subagents. A search too large to run inline is a finding that the question is too broad.
-- Close while an open question quietly fails an outcome, rather than resolving it or recording it as knowingly accepted
-- Spawn more than three billed headless runs without asking
-- Match a topic against the shared scratch directory, which holds folders that were never tracks
-- Pause for approval between steps, which the write scope is what makes safe
-
-## Guards
-
-- No topic given: stop rather than inferring one
-- Fewer than two of the three qualifying conditions hold in open mode: stop and route to the planning skill, because the decision is already made
-- Resume and close are exempt from that test by definition
+- Dispatch subagents, since a search too large to run inline is a finding that the question is too broad
+- Close while an open question quietly fails an outcome, or spawn more than three billed headless runs without asking
+- Pause for approval between steps, or open a track with no topic or fewer than two of the three qualifying conditions
 
 ## Out of scope
 
 - Writing the plan the track concludes toward, which `plan-feature` owns
-- Implementing anything the track recommends
-- Persisting the folder. It is gitignored and disposable, which is what makes it the right container for an unanswered question.
+- Filing a breadth dump, which `plan-intake` owns
+- Placing a task row, which `task-board` owns

package/claude/skills/plan-groundwork/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: plan-groundwork
-description: Opens and runs a numbered groundwork folder under `.canon/groundwork/<nn>-<slug>/` for a topic that has to be measured before it can be planned. Detects open, resume, and close from the folder itself. Use when asked to "research X", "dig into X", "work out what we should do about X", "measure this before we commit", or "open a groundwork folder". Do NOT use to write a feature plan or to implement. That is `plan-feature`.
+description: Opens and runs a numbered groundwork folder under `.canon/groundwork/<nn>-<slug>/` for a topic that has to be measured before it can be planned. Detects open, resume, and close from the folder itself. Use when asked to "research X", "dig into X", "work out what we should do about X", "measure this before we commit", "open a groundwork folder", or "retell the groundwork". Do NOT use to write a feature plan or to implement. That is `plan-feature`.
 metadata:
   family: decide
 ---
@@ -88,6 +88,7 @@ A matched folder routes on its own `<nn>-<slug>/`. Detect the mode from the fold
 
 - Present without `06-decision.md`: resume
 - Present and the user judges it ready: close
+- Present and the user asks for a retell: read the track and end on the retell, measuring and writing nothing
 
 ## Step 2: orient
 
@@ -135,4 +136,6 @@ Aside from an experiment fixture, Steps 4 and 5 are the only ways close mode rea
 
 ## Output
 
-Emit the full relative path from the project root for every file written or updated, since a bare filename names a file the reader cannot open. Read `${CLAUDE_SKILL_DIR}/references/output.md` on reaching this step for the open and resume template and the close template. A run that stops on a guard skips it.
+Emit the full relative path from the project root for every file written or updated, since a bare filename names a file the reader cannot open. Read `${CLAUDE_SKILL_DIR}/references/output.md` on reaching this step for the open and resume template, the retell, and the close template. A run that stops on a guard skips it.
+
+End on the retell in place of the open and resume template once every open question carries a lean. A question marked `none, needs measuring` keeps the open and resume template, unless the operator asks for a retell, which answers whatever the state. The retell lists written files under `**Written:**`, and close keeps its one-line report.

package/claude/skills/plan-groundwork/references/output.md

@@ -1,6 +1,6 @@
 ---
 title: Groundwork output reference
-description: The chat output a groundwork run closes on, one template for open and resume and one for close
+description: The chat output a groundwork run closes on, one template for open and resume, a retell for a fully leaned pass, and one for close
 ---
 
 # Groundwork output reference
@@ -26,6 +26,52 @@ Use `📂 Resumed` in place of `📂 Opened` on a resume pass.
    - Overturned by: <the finding that would change it>
 ```
 
+## Retell
+
+Replaces the open and resume template once every open question carries a lean. It also answers an operator who asks for one, whatever the questions' state. Chat only, and the retell itself writes no file.
+
+Use H2 only, one-line bold-label bullets, and numbers only where they settle something. Stay near 300 words.
+
+- Keep the leans that decide the operator's call, five at most, and fold the rest into one line naming how many more there are and where they sit
+- Label each reversal `Overturned by`, as `groundwork.md` does
+- Drop the held and not held split when the operator gave no hunch to test
+- Put a question marked `none, needs measuring` under `## More measuring` as a yes, since an asked-for retell has no lean to give it
+- List a file the pass wrote or updated under `**Written:**` after the verdict, and omit the block when none was
+
+```plaintext
+**<the verdict in one line>**
+
+**Written:**
+
+- `.canon/groundwork/<nn>-<slug>/<file>.md`
+
+## Problem
+
+<one or two sentences>
+
+## What is true now
+
+- **Held:** <the part of the operator's hunch the evidence supports>
+- **Not held:** <the part it does not>
+
+## Leans
+
+1. <lean>
+   - **Overturned by:** <the finding that would change it>
+
+## More measuring
+
+**<Yes or No>:** <its cost, and what it would decide>
+
+## Dropped
+
+- <what was set aside>
+
+## Your call
+
+<the single decision the operator owes>
+```
+
 ## Close
 
 Omit the uncited-claims block when the count is zero.

package/claude/skills/plan-intake/REQUIREMENT.md

@@ -7,43 +7,28 @@ description: Why a brain dump gets a filed inventory rather than ten plans, and
 
 ## Gap
 
-Without this skill, a brain dump reaches a session that has nowhere to put it. `plan-feature` answers with one plan per independent concern, so forty findings produce ten plan files before anything has been measured. `plan-groundwork` refuses a breadth pass outright, since its qualifying test asks whether the current state is unknown and most items are knowable by grep. What gets filed instead is a list of opinions, because nothing forces a count against the tree and a complaint reads the same whether it covers three sites or three hundred.
+A brain dump reaches a session with nowhere to put it. One plan per concern turns forty findings into ten plans before anything is measured, and what gets filed instead is a list of opinions, because nothing forces a count against the tree.
 
-Two failure modes cost more than the rest. An operator's silence on an item reads as consent when the folder borrows the plan file's blank-means-accept contract, which ships changes nobody approved across a folder read over weeks. And a report naming only a path cannot distinguish three new items from one reworded sentence in a file that holds a dozen items, so every reader diffs it against memory to find out what moved.
-
-Four more are cheaper to name than to rediscover. A question filed without a pick comes back unresolved, measured across one folder's 19 open items, where every one carrying a suggestion resolved on a bare `ok` and the five carrying none did not.
-
-A session with no numbering convention re-decides the folder shape per dump, so no two intakes are readable the same way and the second one has to be learned from scratch. A question answerable both in the index and on its item resolves to whichever a reader opens first, with no rule saying which wins. And a pass with no write scope starts fixing what it files, which turns a triage into a branch nobody asked for and nobody reviewed.
+An empty operator slot reads as consent under a blank-means-accept contract, which ships changes nobody approved. A report naming only a path hides what moved. A question filed without a pick comes back unresolved, and a pass with no write scope starts fixing what it files.
 
 ## Must
 
-- Route each item on whether the repository can answer it today, sending what needs an experiment or an outside source to the groundwork skill and what is already decided to the planning skill
-- Measure every problem line against the tree during this pass, carrying a number or a file path rather than a figure from recall
-- Close every item with a verdict, and pair every open question with a suggested pick
-- Treat an empty operator slot as unread rather than as agreement
-- Reserve the index number and carry the domain in every other filename, leaving the rest of the numbering as read order
-- Name a newly opened folder with a two-digit ordinal ahead of the slug, taken from the highest one already present across intake and groundwork
-- Keep answers on items alone, with the index pointing at them
-- Name the heading and the act beside every path the pass wrote
-- Confine writes to the intake folder
+- Route each item on whether the repository can answer it today, sending experiments to `plan-groundwork` and decided work to `plan-feature`
+- Measure every problem line against the tree, close every item with a verdict, and pair every open question with a suggested pick
+- Treat an empty operator slot as unread, and keep answers on items with the index pointing at them
+- Reserve the index number, carry the domain in every other filename, and number a new folder past the highest ordinal across intake and groundwork
+- Confine writes to the intake folder and name the heading and the act beside every path written
 
 ## Must not
 
 - Write a plan, a task file, a standard, a rule, or a source change
-- Fill an operator's answer slot, or infer a disposition from an empty one
-- Replace a verdict with an overlap line, which drops the call on exactly the items where a live board task might be the thing that is wrong
-- Reserve mid-range numbers, which would force every future intake into one dump's shape
-- Date every file, since the first edit to one leaves the rest stale
-- Open a folder for a single question, which is either a groundwork track or a plan
-
-## Guards
-
-- No dump given: stop rather than inferring one
-- One question rather than a set of findings: stop and route to the groundwork or planning skill
+- Fill an operator's slot, or replace a verdict with an overlap line
+- Reserve mid-range numbers or date every file
+- Open a folder for a single question or for no dump
 
 ## Out of scope
 
 - Measuring one question in depth, which `plan-groundwork` owns
 - Planning a promoted item, which `plan-feature` owns
 - Promoting an item onto the board, which `task-board` owns
-- Enforcing any of this. The folder is gitignored, so no check reaches its contents and every rule holds only while a session reads it.
+- Enforcing any of this, which no check does since the folder is gitignored

package/claude/skills/plan-intake/references/intake.md

@@ -113,9 +113,9 @@ Where an item touches a task already on the board, say so in the index rather th
 - **You:**
 ```
 
-- `Problem:`, `Fix:`, `Worth it:`, and the empty `You:` slot ship on every item. The other two are conditional.
+- `Problem:`, `Fix:`, `Worth it:`, and the empty `You:` slot ship on every item, each on one line since the reader takes nothing after it. The other two are conditional.
 - Number items per cluster file, giving a finding split later a letter suffix such as `3a` beside `3`, since renumbering moves every cited label
-- `Suggested:` is required whenever `Open:` is present, since `ok` against two defensible options carries no information
+- `Open:` reads on its own, with no bare "it" or "this" for the Fix, and `Suggested:` is required beside it, since `ok` against two options carries no information
 - Where the answer is the operator's preference rather than a technical call, say so in that form rather than inventing a default
 - `Overlaps:` never replaces `Worth it:`, since an item a live board task might have wrong is the one whose verdict matters most
 

package/claude/skills/plan-intake-answer/REQUIREMENT.md

@@ -7,42 +7,27 @@ description: Scope boundary for answering a filed intake from chat, and the writ
 
 ## Gap
 
-Without this skill, an operator answers a filed intake by opening each cluster file and typing under each item, so a dump spanning six clusters is six files navigated in turn and the cost scales with how well the pass split the domains. The folders that go unanswered are the large ones, which are the ones a breadth pass exists to produce.
+An operator answers a filed intake by opening each cluster file and typing under each item, so the largest folders go unanswered. A session asked to help reads an empty slot as agreement, answers in chat and never the file, or overwrites a slot already filled.
 
-A session asked to help with that fails in shapes the intake standard already names. It reads an empty slot as agreement and reports items decided that nobody reached. It writes an answer into the conversation and never into the file, so the record still reads as unread and the next session re-asks. It types the answer into `00-overview.md`, where retrieval walks item headings and finds nothing. It overwrites a slot the operator already filled, discarding a decision already made.
-
-The write itself fails a fourth way that no prose rule prevents. Every worker runs in a linked worktree where the file-editing tools refuse a main-root path, and a stream editor expands an unescaped ampersand in the replacement to the whole match and exits zero when it matches nothing. A body instructing either route reports success and loses the answer.
-
-The batching fails a fifth way. A folder holding thirty unread items put as thirty questions is unanswerable, and put as one flat batch it hides which cluster the operator is in and leaves a file half answered when attention runs out.
+The write fails where no prose rule catches it. A worker's file-editing tools refuse a main-root path from a linked worktree, and a stream editor exits zero on no match, so the answer is lost behind a success report. Thirty items in one flat batch leave a file half answered.
 
 ## Must
 
-- Offer every item carrying an empty answer slot, not only the ones carrying an open question, since the standard's one-token accept exists for a verdict with no question attached
-- Batch by cluster in the folder's own numbering, so the operator has a stopping point that leaves whole clusters unread rather than a file half answered
-- Cap a batch at four items, which is what a structured question tool takes
-- Rank the item's own suggestion or verdict first and give every option what it costs, since the pass already made a recommendation and burying it asks the operator to re-derive it
-- Land every selection through a verb that resolves the root in-process and rewrites the whole line, which is the only route that works from a linked worktree
-- Write one cluster per call, since concurrent calls against one file race on the read and keep only the last answer
-- Carry the cluster and the label together, because items are labeled per file and a label alone names an item in every cluster at once
-- Pass a label exactly as its heading spells it, letter suffix included, since a pass that splits a finding after the fact labels the halves rather than renumbering the file
-- Report what stays unread by count after each cluster
+- Offer every item with an empty slot, batched by cluster in the folder's numbering and capped at four items, so a stop leaves whole clusters unread
+- Open each question with a lead-in an operator who has not opened the file can follow, then rank the item's own suggestion first and give every option its cost
+- Land each selection through a verb that resolves the root in-process and rewrites the whole line, one cluster per call
+- Pass the cluster and the label exactly as the heading spells them, letter suffix included
+- Report what stays unread by count after each cluster, and stop when there is no folder or no unread item
 
 ## Must not
 
-- Fill a slot the operator did not answer, including the remainder of a batch they abandoned
-- Infer an answer from the conversation having happened, which is the inversion the intake standard states against the plan standard
-- Overwrite a slot already carrying an answer, which is a decision already made
-- Write anywhere in the folder but an item's answer slot, and never into the index, which carries none
-
-## Guards
-
-- No intake folder at all, stop and name the skill that files one
-- The named folder carrying no unread item, stop rather than re-asking answered items
+- Fill a slot the operator did not answer, or infer an answer from the conversation having happened
+- Overwrite a slot already carrying an answer
+- Write anywhere but an item's answer slot, the index included
 
 ## Out of scope
 
-- Filing a dump and writing the items, which is `plan-intake` and owns every other write into the folder
-- Promoting an answered item onto the board, which is `task-board` and runs after the answers land
-- The item format, the answer contract, and retrieval, which the `plan-intake` skill's `references/intake.md` owns and this skill cites
-- The comparable answer slots in groundwork and feature plans, which carry their own contracts and are a separate measurement
-- Deciding when to fire. The description states `Do NOT auto-trigger`, so answering is the operator's call rather than a description match.
+- Filing a dump and writing the items, which `plan-intake` owns
+- Promoting an answered item onto the board, which `task-board` owns
+- The item format, the answer contract, and retrieval, which `plan-intake` owns in its `references/intake.md`
+- Deciding when to fire, which the operator owns since the skill never auto-triggers

package/claude/skills/plan-intake-answer/SKILL.md

@@ -31,7 +31,7 @@ Never guess from the topic of the conversation. A session resuming against the w
 
 ## Step 2: collect one cluster
 
-Run `canon intake list <slug> --unread --json`. It returns the unread items grouped by the cluster file holding them, each carrying its label, title, open question, and suggestion.
+Run `canon intake list <slug> --unread --json`. It returns the unread items grouped by the cluster file holding them, each carrying its label, title, `problem`, `fix`, open question, and suggestion. The `problem` and `fix` fields are absent on an item that lacks the line, so write the lead-in from whichever are present.
 
 Work one cluster at a time, in the order the folder numbers them. A dump of six clusters holding five items each is thirty questions, and a surface putting all of them at once is unusable. The cluster boundary is also where an operator who runs out of attention stops cleanly, leaving whole clusters unread rather than one file half answered.
 
@@ -47,6 +47,12 @@ Offer every item with an empty slot, not only the ones carrying an open question
 | `Open:`      | That question, with its `Suggested:` line ranked first and marked as suggestion |
 | No `Open:`   | Its verdict, with `ok` ranked first and alternatives from what it could be      |
 
+Open every question with a lead-in of one to three plain sentences, written fresh from `problem`, `fix`, and `open` for an operator who has not opened the file. It says what is wrong today, what the fix is, and what the call is, condensing a long `problem` rather than pasting it.
+
+- An item with no `fix` still states the problem and the call, and one with no `Open:` says what the verdict accepts
+- As filed, "which hooks take it" means nothing lifted out of the Fix line it was written under
+- With a lead-in: "Claude Code 2.1.295 lets a hook fail closed. A crashed `scratch-guard.sh` lets writes through, and the fix sets `onFailure: "block"`. Should `unattended-agent-guard.sh` get it too?"
+
 Give every option what it means and what it costs. An option with no stated cost is not an option, since the operator picks it without knowing what the other one buys.
 
 Send the whole batch in one turn. When the session runs on a surface carrying a structured question tool, such as `AskUserQuestion` in Claude Code, send it through one call with one entry per item. Otherwise write it as a numbered list in one message with the suggestion marked.