@erclx/aitk 0.94.0 → 0.96.0

package/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "aitk",
   "description": "Automated governance, versioning, and discovery tools for Claude Code.",
-  "version": "0.94.0",
+  "version": "0.96.0",
   "author": {
     "name": "Eric Le",
     "url": "https://github.com/erclx"

package/claude/skills/claude-orchestrate/SKILL.md

@@ -38,7 +38,7 @@ The roadmap is optional and this skill does not require it. It carries why a seq
 
 A compaction is a moment this skill cannot detect, so the human asks for each side of it and this skill reads the matching runbook when they do.
 
-On a request to write the handoff or save the session, read `${CLAUDE_SKILL_DIR}/references/orchestrator-handoff.md` and follow it. It captures what the session learned, then writes `.claude/tasks/session.md` with the state of play, the decisions taken under delegated authority, the mistakes worth not repeating, and the standing cautions. That capture is the only one this session runs, since the refill sweep reports it as owed rather than paying it. Write nothing to the handoff that the board, a task file, or a groundwork folder already carries.
+On a request to write the handoff or save the session, read `${CLAUDE_SKILL_DIR}/references/orchestrator-handoff.md` and follow it. It captures what the session learned, then writes a session map per `.claude/standards/session.md`, or `${CLAUDE_SKILL_DIR}/../../standards/session.md` when the project does not have it, carrying the state of play, the mistakes worth not repeating, and the standing cautions, with the decisions taken under delegated authority added as this role's extension. That capture is the only one this session runs, since the refill sweep reports it as owed rather than paying it. Write nothing to the handoff that the board, a task file, or a groundwork folder already carries.
 
 On a request to resume after a compaction, read `${CLAUDE_SKILL_DIR}/references/orchestrator-resume.md`, which reads that file back with the board and the groundwork behind the live work.
 

package/claude/skills/claude-orchestrate/references/orchestrator-handoff.md

@@ -1,58 +1,30 @@
 ---
 title: Orchestrator handoff runbook
-description: Memory capture at the close of a session, what to write to .claude/tasks/session.md before a compaction, what to leave to the board, and the resume invocation the file carries out
+description: The two sections an orchestrating session adds over the shared session map, how capture runs from a session that never commits, and the resume invocation the file carries out
 ---
 
-Capture what the session learned, then write the pre-compact handoff as orchestrator. Do both before a compaction, because a compaction keeps conclusions and drops the reasoning that produced them, and no other file in the repository carries that reasoning.
+Write the pre-compaction handoff as orchestrator. Follow `.claude/standards/session.md`, or `${CLAUDE_SKILL_DIR}/../../standards/session.md` when the project does not have it, for the filename, the three core sections, the write procedure, and the citation rule. Everything below is the extension this role adds over that core, and none of it belongs to a session holding no delegated authority.
 
-1. Invoke `aitk:claude-memory-capture` and tell it this session does not commit. Capture reads the session and this handoff summarizes it, so capturing first lets the handoff cite what was written instead of restating the same lesson in prose.
-2. Run `aitk claude skills drift <commit this session started from>` and re-read any body it names before writing anything below. Nothing on the machine records that commit, so recover it from how long the session has been running with `git log -1 --format=%H --before='<duration> ago'`, rounding the duration up rather than down. A ref older than the oldest load over-reports and confirming a name costs one read of the body, so the generous end is the safe one and a guess at the exact commit is not worth making. A skill body enters a session once and re-invoking the skill replays the held copy rather than the file, so the drift is worst at exactly this moment and a name here is a body this session has been following out of date. Record what it named under `## Standing cautions`. The verb answers where the working directory carries `claude/skills/` with history behind it, which is the toolkit repository itself, and refuses by naming the absent tree anywhere else. A project consuming the plugin from a marketplace cache is that second case, so read the refusal as the boundary rather than as a fault.
-3. Resolve the main worktree root with `git worktree list --porcelain | grep -m 1 '^worktree ' | cut -d' ' -f2-`, falling back to `pwd`. Write `.claude/tasks/session.md` under it.
-4. Write only what a compaction destroys and no other file already carries. The board holds the ordering and what each task waits on, a task file holds its own findings, and a groundwork folder holds its track.
-5. Use this shape, resolving `${CLAUDE_SKILL_DIR}/references/orchestrator-resume.md` and `${CLAUDE_SKILL_DIR}/references/orchestrator-poll.md` to absolute paths as you write it and pasting each in place of `<RESUME_RUNBOOK>` and `<POLL_RUNBOOK>`:
+1. Run the capture step the core opens with, and tell `aitk:claude-memory-capture` that this session does not commit.
+2. Add `## Decisions taken under delegated authority` directly after `## State`, holding each decision and why it went that way, so nobody re-proposes it. It sits there rather than after the core because a decision is read against the state it was taken in.
+3. Close the file with the block below, resolving `${CLAUDE_SKILL_DIR}/references/orchestrator-resume.md` and `${CLAUDE_SKILL_DIR}/references/orchestrator-poll.md` to absolute paths as you write it and pasting each in place of `<RESUME_RUNBOOK>` and `<POLL_RUNBOOK>`:
 
 ```markdown
----
-title: Session map
-description: <what the board cannot show, and the date it was written>
----
-
-# Session map
-
-<one line marking the file throwaway and naming the board as the real source>
-
-## State
-
-<what is clean, what is running, what is open, and any untracked file that needs committing>
-
-## Decisions taken under delegated authority
-
-<each decision and why it went that way, so nobody re-proposes it>
-
-## Mistakes worth not repeating
-
-<what went wrong and the rule it yields>
-
-## Standing cautions
-
-<commands that lie, tools that measure the wrong tree, and anything unbacked>
-
 Resume by loading the orchestrator skill and asking it to resume after a compaction. This repository spells that `/aitk:claude-orchestrate` followed by the request. Following <RESUME_RUNBOOK> reaches the same place with no skill loaded at all.
 
-That resume reads the board and stops. It restarts nothing, so the review poll is a second thing owed here, and <POLL_RUNBOOK> holds the prompt and the condition. Do not reach for `session-resume`, which reads tracked work and knows nothing about this board or the workers on it.
+That resume reads the board and stops. It restarts nothing, so the review poll is a second thing owed here, and <POLL_RUNBOOK> holds the prompt and the condition. Do not reach for `session-resume`, which reads tracked work and reports the newest map without restarting this loop.
 ```
 
-6. Cite a commit, a task, or a file and line for every claim, so the next session can tell a read from a recall.
-7. Overwrite the previous handoff rather than appending to it. A stale entry read as current is worse than no handoff.
-
-The substitution belongs in step 5 because step 7 ends the write. A reader who treats the list as finished there ships the literal placeholders, and the variable expands while this runbook renders rather than in the turn that reads the handoff back, so a path left unresolved reaches a session holding no skill as a string matching nothing. `orchestrator-poll.md` resolves its script at the same point and for the same reason.
+The delegated-authority section is the orchestrator's alone because a worker holds no delegation to have exercised, and a section a session cannot fill teaches its reader to skip the file. The closing block is the orchestrator's for the same reason from the other direction: it restarts a review poll no other role runs.
 
-Add a section only for content that fits none of the four and would otherwise be lost. Do not restate the board, and do not summarize the work that shipped, because git already carries it. The closing block is the one exception, and the paragraph below states why.
+The substitution belongs in step 3 because that step ends the write. A reader who treats the list as finished elsewhere ships the literal placeholders, and the variable expands while this runbook renders rather than in the turn that reads the handoff back, so a path left unresolved reaches a session holding no skill as a string matching nothing. `orchestrator-poll.md` resolves its script at the same point and for the same reason.
 
-That block sits in this runbook and again in the file this runbook writes, which is the fix rather than a copy for a later pass to collapse. A session has to already be holding this runbook to read it, and a compaction that took the skill body took the routing to it too, so the session that most needs the resume is the one that can no longer find it. `session.md` survives that, so it carries the invocation itself. Each of the two reaches a reader the other cannot.
+That block sits in this runbook and again in the file this runbook writes, which is the fix rather than a copy for a later pass to collapse. A session has to already be holding this runbook to read it, and a compaction that took the skill body took the routing to it too, so the session that most needs the resume is the one that can no longer find it. The map survives that, so it carries the invocation itself. Each of the two reaches a reader the other cannot.
 
 The requirement is a resume request to the orchestrator skill with that skill loaded first. The command the block carries is this repository's spelling rather than the only one, since the skill ships to every target holding the plugin and each runs whatever client it runs. The poll restart is named beside it because the resume performs none.
 
 Step 1 exists because both other callers of capture are ship-chain skills and this session never ships. Without a call here, the session that receives every operator correction is the one session that records none. A compaction arriving with no warning takes the capture with it, and firing it once per batch of merges leaves the same window open across a long planning stretch, since a sweep runs only on a merge. The refill sweep reports the debt between handoffs so the operator knows one is owed.
 
 Capture is told this session does not commit, so it skips routing and writes memory files alone. A routed fact lands in a context entry, which is a tracked file, and the orchestrator's boundaries forbid writing one from this session. That split is correct rather than a limitation, since a domain fact belongs to the task that owns the surface and goes in that task's Findings, while what this session produces is feedback about how to work, which is the class the memory folder keeps.
+
+The core's drift step answers where the working directory carries `claude/skills/` with history behind it, which is the toolkit repository itself, and refuses by naming the absent tree anywhere else. A project consuming the plugin from a marketplace cache is that second case, so read the refusal as the boundary rather than as a fault.

package/claude/skills/claude-orchestrate/references/orchestrator-resume.md

@@ -6,7 +6,7 @@ description: What to read back after a compaction, and how to treat a groundwork
 Resume as orchestrator after a compaction. Read the board and the groundwork behind the live work before answering anything, because a compaction summary keeps conclusions and drops the reasoning that produced them.
 
 1. Resolve the main worktree root with `git worktree list --porcelain | grep -m 1 '^worktree ' | cut -d' ' -f2-`, falling back to `pwd`. Every path below resolves against it.
-2. Read `.claude/tasks/priority.md` for the ordering and what each task waits on. Read `.claude/tasks/session.md` when it exists, and treat it as this session's scratch rather than a source.
+2. Read `.claude/tasks/priority.md` for the ordering and what each task waits on. Read the newest `.claude/tasks/session-*.md` when one exists, per `.claude/standards/session.md`, and treat it as the previous session's scratch rather than a source.
 3. Read the task file for every entry under `## Run now`, plus any entry a live pull request names.
 4. Read the groundwork folder each of those tasks cites. Read `README.md` for the file map, then `06-decision.md` when the track is closed, or `07-next-session.md` and the numbered topic files when it is open. A task's Findings section is a lossy summary of its track, so planning against the summary re-derives what the folder already settled.
 5. Run `gh pr list --state open` and `git log --oneline -5` to see what shipped since the folder was written.

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

@@ -1,6 +1,6 @@
 ---
 name: session-resume
-description: Why resuming reads an index before task files, resolves scratch at the main root, and never mutates what it reports
+description: Why resuming reads the handoff before the board, reads an index before task files, resolves scratch at the main root, and never mutates what it reports
 ---
 
 # Session resume requirement
@@ -9,14 +9,20 @@ description: Why resuming reads an index before task files, resolves scratch at
 
 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.
 
+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, the plans, and the memory index 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 refresh a memory it decided was stale. Both change tracked state on the strength of a summary the user has not confirmed yet.
 
 ## Must
 
-- Resolve the plans, memory, and tasks folders at the main worktree root
+- Read the newest handoff before the board, and report what it carries attributed to its writer
+- Resolve the handoff, plans, memory, 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
 - Surface only the memory entries that inform the top item
 - Close with one recommendation naming the first item and whether a plan backs it
@@ -24,15 +30,20 @@ A resume is a read, and a session that treats it as a cleanup pass offers to arc
 ## 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.
 - Update memory, which changes when a recorded fact becomes wrong rather than on a resume
 
 ## Guards
 
-- All three surfaces absent or empty reports no tracked work and stops, rather than inventing a next step from the repository
+- All four surfaces 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
 
 ## 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: `claude-tasks`
 - Archiving a plan and marking an outcome, which `claude-docs` does when the work ships
 - Implementing the item it recommends, which is the next request rather than part of this one

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

@@ -1,6 +1,6 @@
 ---
 name: session-resume
-description: Resumes a previous session by reading tracked work and relevant context. Use when starting a new session, or when asked to "pick up where we left off", "what was I working on", or "resume".
+description: Resumes a previous session by reading the handoff it left behind, tracked work, and relevant context. Use when starting a new session, or when asked to "pick up where we left off", "what was I working on", or "resume".
 ---
 
 # Session resume
@@ -11,19 +11,24 @@ Resolve `.claude/plans/`, `.claude/memory/`, and `.claude/tasks/` at the main wo
 
 Read these in parallel, skipping any that do not exist:
 
-- `.claude/tasks/index.md`: the backlog, one line per task. Read this before any individual task file.
+- the newest `.claude/tasks/session-*.md`: the handoff a previous session wrote before a compaction, per `.claude/standards/session.md`, or `${CLAUDE_SKILL_DIR}/../../standards/session.md` when the project does not have it. It leads the report rather than the reads.
+- `.claude/tasks/index.md`: the folder catalog. Read this before any individual task file, and take the backlog from it by dropping the `index`, `priority`, and `session-` rows, which are siblings rather than tasks.
 - `.claude/plans/*.md`: execution detail for in-progress tasks
 - `.claude/memory/index.md` and any memory files relevant to the top backlog item
 
 Then read only the task files the summary needs, typically the top one. Do not read the whole folder.
 
-If all three surfaces are absent or empty, stop: `✅ No tracked work found. Start a new task.`
+Most projects carry no handoff. Say nothing about its absence, since a line reporting it every run trains a reader to skip the line on the run where a handoff exists.
+
+If all four surfaces are absent or empty, stop: `✅ No tracked work found. Start a new task.`
 
 ## Step 2: summarize
 
-Output three sections:
+Output these sections, omitting the first when no handoff was found:
+
+**Carried over:** the reasoning the handoff holds, as its writer stated it. Attribute it to the map rather than restating it as fact, and re-measure any count, size, or cost before acting on one.
 
-**Up next:** one line per entry in `.claude/tasks/index.md`, preserving order.
+**Up next:** one line per task row in `.claude/tasks/index.md`, preserving order. A board carrying handoffs has a row per session that wrote one, so a report listing every row queues work nobody filed.
 
 **Active plans:** one line per file in `.claude/plans/`, linking each to its task file in `.claude/tasks/`. Say "None" if empty.
 
@@ -33,6 +38,14 @@ Output three sections:
 
 End with one line: `Start with: <first Up next item>` and note whether it has a linked plan.
 
+When the board is empty and a handoff was found, name what the handoff leaves open instead: `Start with: <the open thread the handoff names>`. A recommendation slot filled with nothing reads as a failed run, and a handoff on an empty board is the shape a session leaves when it was reasoning rather than shipping.
+
 Do not offer to remove entries. A completed task is archived out of `.claude/tasks/` when work ships. The git log is the authoritative record of shipped work. Plan files are archived per the plan lifecycle rule in `CLAUDE.md`.
 
 Memory is updated only when a recorded fact becomes wrong, never on resume. A domain fact reaches a session through `.claude/context/`, which `claude-memory-capture` routes to and the three-tier model loads on demand, so the memory folder read here is the residue no context entry owns.
+
+## Writing the next one
+
+This skill reads a handoff and never writes one. Reading and writing are two jobs, and the write happens at the close of a session rather than at its start.
+
+Name the standard when the session asks how to leave a handoff behind, and let the session follow it directly. Any session may write one, whatever role it holds, so nothing here routes the request to another skill. A role carrying sections of its own adds them over the core per that role's own runbook.

package/docs/agents/commands.md

@@ -32,7 +32,7 @@ Full help: `aitk <command> --help`. Behavior notes for the install and sync verb
 | `aitk tasks validate`      | Report board rows whose plan, task file, group, or file set does not hold (`--json`)                                                      |
 | `aitk intake list`         | Report intake folder counts, or one folder's items, keeping what is unread with `--unread` (`--json`)                                     |
 | `aitk intake answer`       | Write selections into one cluster's answer slots, repeating `--set <item>=<answer>` (`--json`)                                            |
-| `aitk records validate`    | Report a session record against the standard governing it, per kind (`--json`)                                                            |
+| `aitk records validate`    | Report a session record or a standard against the standard governing it, per kind (`--json`)                                              |
 | `aitk records push`        | Commit the eight backed record folders and push them to a private records remote (`--json`)                                               |
 | `aitk records pull`        | Fetch the records remote and write it back, refusing rather than discarding unpushed records (`--json`)                                   |
 | `aitk sessions list`       | Resolve live sessions to the worktree and branch each holds, filtered by `--branch` (`--json`)                                            |

package/docs/agents/index.md

@@ -20,7 +20,7 @@ CLI catalog and invocation rules for agents, split by command domain. Start with
 - [Markdown audit](markdown-audit.md): Running the audit over any markdown path, where its bans and checkpoints are read from, what each check reports, and why the ban half gates while the structural half reports
 - [Output shape](output-shape.md): Two framed shapes every command renders into, how JSON and --names modes keep stdout clean, and the exit discipline that lets piped output drain
 - [Overview](overview.md): What this folder covers, the invocation rules every command inherits, and where domain behavior is documented instead
-- [Records](records.md): Validating the gitignored session records under .claude/, the per-kind checks, the refusal reasons, backing the folders to a private remote, and why the root defaults to the main worktree
+- [Records](records.md): Validating the session records under .claude/ and the standards corpus, the per-kind checks, the refusal reasons, backing the folders to a private remote, and which root each kind defaults to
 - [Sandbox](sandbox.md): Scenario routing, the expectation scoring surface, and the coverage census over scenarios and skills
 - [Scripting](scripting.md): The runtime catalogs that replace hardcoded names, what each carries, and a headless invocation per domain
 - [Sessions](sessions.md): Resolving live peer sessions to the worktree and branch each holds, the liveness confidence field, the unresolved reasons, and what the read depends on

package/docs/agents/records.md

@@ -1,28 +1,31 @@
 ---
 title: Records
-description: Validating the gitignored session records under .claude/, the per-kind checks, the refusal reasons, backing the folders to a private remote, and why the root defaults to the main worktree
+description: Validating the session records under .claude/ and the standards corpus, the per-kind checks, the refusal reasons, backing the folders to a private remote, and which root each kind defaults to
 ---
 
 # Records
 
 ## Validate
 
-`aitk records validate <kind>` reports where a session record and the standard governing it disagree. The four kinds are `plans`, `groundwork`, `intake`, and `memory`, each a gitignored folder under `.claude/`.
+`aitk records validate <kind>` reports where a file and the standard governing it disagree. Four kinds are gitignored folders under `.claude/`: `plans`, `groundwork`, `intake`, and `memory`. The fifth is `standards`, the authoring corpus, which is tracked and installed rather than scratch.
 
 ```bash
 aitk records validate plans
 aitk records validate memory
+aitk records validate standards
 aitk records validate intake --json
 ```
 
-| Option          | Behavior                                      |
-| --------------- | --------------------------------------------- |
-| `--json`        | Add a machine-readable record on stdout       |
-| `--root <path>` | Project root, defaulting to the main worktree |
+| Option          | Behavior                                                            |
+| --------------- | ------------------------------------------------------------------- |
+| `--json`        | Add a machine-readable record on stdout                             |
+| `--root <path>` | Project root, defaulting to the main worktree except on `standards` |
 
-It reads and never writes. Each folder is per-machine scratch with no history behind it, so a repair that guessed wrong could not be undone, and the report names the record for a session to fix.
+It reads and never writes, and the reason splits by kind. A session record is per-machine scratch with no history behind it, so a repair that guessed wrong could not be undone. A standard installs into every target and is cited by bare filename, so a rename the verb performed would reach further than the file it moved, which is why a finding naming one says so.
 
-Nothing fires it automatically. The folders are gitignored, so the standards-audit hook exits early on them and any check reading changed files from git never lists one. The verb runs at the moment a session claims the record is finished, which is the same placement `aitk tasks validate` takes over the board.
+`standards` reads the authoring root at `standards/` where it exists and the installed copy at `.claude/standards/` otherwise. The authoring root wins because the installed tree is generated from it in the toolkit, where a fix written to the copy is discarded by the next regen. A project that consumed the corpus holds only the second, so one precedence serves both. The walk stays flat, matching install and the catalog, so `standards/bundled/` is out of range: its members are named for the skill that reads them rather than for a path they govern.
+
+Nothing fires it automatically. The four record folders are gitignored, so the standards-audit hook exits early on them and any check reading changed files from git never lists one. The corpus is tracked and still unreached, since the markdown audit reads content across the files git lists and rules on no filename. The verb runs at the moment a session claims the record is finished, which is the same placement `aitk tasks validate` takes over the board.
 
 ### What each kind checks
 
@@ -32,6 +35,7 @@ Nothing fires it automatically. The folders are gitignored, so the standards-aud
 | `groundwork` | A track with no `README.md` or no `01-current-state.md`, a file missing `title` or `description`, a `README.md` with no `date` as `YYYY-MM-DD`, an unnumbered file, and a track holding a decision without its handoff or the reverse |
 | `intake`     | A dump with no `00-overview.md`, the same frontmatter and numbering checks, an item missing any of `Problem`, `Fix`, `Worth it`, or `You`, and an item carrying `Open` with no `Suggested`                                            |
 | `memory`     | A filename whose prefix names none of the four types, an entry missing `title`, `description`, or `category`, a `category` disagreeing with that prefix, a title repeating the filename, and a rule-bearing body missing a part       |
+| `standards`  | A standard missing `title` or `description`, an absent `## Scope` section, a scope section carrying no `Does not govern:` list, a statement anchoring nothing, and a filename naming no part of the path the statement governs        |
 
 The half-closed track is the groundwork check a reader cannot run by eye. A folder holding `06` without `07` reads as closed to anyone scanning filenames while the file a returning session actually opens is absent.
 
@@ -39,15 +43,23 @@ The item check skips `00-overview.md` and `99-next-session.md`, since neither ho
 
 A memory `category` is compared against the sentence-case form of the filename prefix rather than checked field by field, so one finding covers a prefix outside the four types, a field disagreeing with the prefix, and a casing drift that would open a second group in the catalog. The body check runs on `feedback` and `project` entries alone, because a `user` or `reference` entry is a single sentence by design and has no rule to apply.
 
+The standards filename check derives a word from the governed path rather than counting words in the name. Every member of the corpus is named for the artifact its scope statement governs, and one word is what that produces rather than the rule itself, so a check keyed on word count would pass a conforming single word naming the wrong artifact. Each path segment offers its own word, a dotted container segment offers none, a hyphenated segment offers its parts, and the singular and the plural both match.
+
+The scope statement is read exactly as `scripts/standards/list.sh` reads it for the catalog's `appliesTo` field: backticked spans in the first sentence alone, with an attribute standard resolving where that sentence backticks nothing and the statement says it governs an attribute. One sentence read two ways would let a standard pass the check while publishing a different jurisdiction to every consumer of the catalog. An attribute standard is exempt from the filename derivation because it governs no path to derive from, and a statement that anchors nothing and claims no attribute is reported as `scope-unanchored` rather than passed, since silence there would let the backticks be removed to disable the check.
+
+An absent `## Scope` section suppresses the filename finding. The name derives from the statement, so a missing section leaves nothing to derive against, and reporting both would name one defect twice and point the fix at the wrong file. The walk skips `index.md`, which is generated from its siblings rather than authored.
+
 A plan section opens as a bold label or as an H2 and the check counts both, naming the standard's spelling when it reports one missing. The corpus splits roughly four to one between the two forms, so failing the variant would report nearly every plan on a rule that costs a reader nothing.
 
 A section runs to the next marker-shaped line whatever it names, so a plan carrying a label of its own closes the section above it rather than collecting into it. Fenced blocks are dropped before any of this, since a plan showing the shape it writes puts real-looking bullets and headings inside a fence.
 
 ### Exit codes and refusals
 
-Exit codes: `0` every check passed, `1` refused, `2` at least one record carries a finding. A `reason` field carries which gate fired: `no-folder` when the kind's directory does not exist, and `unknown-kind` when the argument names no published kind.
+Exit codes: `0` every check passed, `1` refused, `2` at least one record carries a finding. A `reason` field carries which gate fired: `no-folder` when none of the kind's directories exist, and `unknown-kind` when the argument names no published kind. A `no-folder` message names every candidate, so the `standards` refusal names both roots.
+
+The four record folders are shared scratch at the main worktree root, so `--root` defaults to the first entry of `git worktree list` rather than the working directory. A linked worktree validates the same records every other session reads.
 
-The folders are shared scratch at the main worktree root, so `--root` defaults to the first entry of `git worktree list` rather than the working directory. A linked worktree validates the same records every other session reads.
+`standards` takes the other default, the root of the checkout the caller stands in. The corpus is tracked, so a linked worktree holds its own edited copy, and resolving the main root there would report on a tree the session never touched while saying nothing about which one it read. A session that adds or renames a standard inside a worktree is the case, and it is the one the check exists for.
 
 Skills branch on the findings rather than on the exit code:
 
@@ -55,7 +67,7 @@ Skills branch on the findings rather than on the exit code:
 aitk records validate plans --json | jq -r '.findings[] | "\(.kind): \(.subject)"'
 ```
 
-For the shapes each check enforces, see `.claude/standards/plan.md`, `.claude/standards/groundwork.md`, `.claude/standards/intake.md`, and `.claude/standards/memory.md`.
+For the shapes each check enforces, see `.claude/standards/plan.md`, `.claude/standards/groundwork.md`, `.claude/standards/intake.md`, `.claude/standards/memory.md`, and `.claude/standards/standard.md`.
 
 ## Push and pull
 

package/docs/agents/tasks.md

@@ -103,7 +103,7 @@ The collision check is the one a person cannot run by eye. Paths come from the b
 
 Exit codes: `0` every check passed, `1` refused, `2` at least one finding. The `reason` field carries which gate refused: `no-board`, `no-ordering`, or `no-groups`. A board grouping under headings of its own trips `no-groups` rather than being read against columns it never declared.
 
-Columns are read from each table's own header rather than by position, so a project whose board differs from this one is reported for what it lacks. The `index`, `priority`, and `session` siblings are skipped, since none of the three is a task.
+Columns are read from each table's own header rather than by position, so a project whose board differs from this one is reported for what it lacks. The `index` and `priority` siblings are skipped, along with every pre-compaction handoff, which takes one file per session under a `session-` prefix. None of them is a task, and a handoff counted as one would be reported as a task carrying no row on every session that wrote one.
 
 Skills branch on the findings rather than on the exit code:
 

package/docs/ai-workflow.md

@@ -164,27 +164,120 @@ Before the first feature session on a UI-heavy project, pick a design tier. The
 
 ## Skills
 
-| Skill                        | When to use                                                                                                          |
-| ---------------------------- | -------------------------------------------------------------------------------------------------------------------- |
-| `aitk:claude-intake`         | File a brain dump into an inventory under `.claude/intake/`, one item per finding with a verdict                     |
-| `aitk:claude-groundwork`     | Before a plan is warranted, measure an unknown in a track folder under `.claude/groundwork/`                         |
-| `aitk:claude-feature`        | Before implementation, scan for conflicts and ambiguities                                                            |
-| `aitk:decision-escalate`     | Batch every open decision that turns on your preference into one set of questions, each with a recommended default   |
-| `aitk:claude-roadmap`        | Sequence MVP scope into ordered versions in `.claude/ROADMAP.md`                                                     |
-| `aitk:claude-orchestrate`    | Assert the orchestrator role, refill the ready queue, and dispatch the feature, review, and worktree skills          |
-| `aitk:claude-diagram`        | Draft per-kind mermaid entries under `.claude/diagrams/` from architecture and code, then verify each rendered image |
-| `aitk:claude-design-extract` | Draft `.claude/DESIGN.md`, sourcing tokens from existing UI code or proposing them from requirements on day one      |
-| `aitk:claude-review`         | In a fresh session, review all changes since main                                                                    |
-| `aitk:claude-pr-review`      | Review an open PR from an independent session, then re-review the commits added since until nothing is open          |
-| `aitk:claude-address-review` | Address PR findings and CI status, refresh stale docs, rebase a branch that stopped merging, then push a follow-up   |
-| `aitk:claude-tasks`          | Add a task to `.claude/tasks/` or archive a shipped one out of the folder                                            |
-| `aitk:claude-docs`           | When decisions diverged from plan, update `.claude/` docs                                                            |
-| `aitk:claude-ui-test`        | After UI changes, generate and run e2e tests + visual checklist                                                      |
-| `aitk:claude-ux-audit`       | Audit existing UI surfaces for missing states, edge cases, inconsistencies                                           |
-| `aitk:claude-ux-measure`     | Measure paint, processor, and layout cost against a running interface, on the harness the project already carries    |
-| `aitk:claude-autoship`       | After plan approval, chain implement → verify → review → draft PR                                                    |
-| `aitk:systematic-debugging`  | When a test fails or bug surfaces, enforce root-cause investigation before fixes                                     |
-| `aitk:git-ship`              | Post-feature: sync docs, commit, rename branch, open PR                                                              |
+Groups run in the order a project meets them, so a reader at a known point scans to that group and reads across. The set reconciles the scenarios above with the lifecycle [target projects](target-projects.md) describes, rather than inventing a third vocabulary beside those two, so a group name matches neither source exactly and every moment either one names has a group. Each row says when to reach for the skill. What it does is the skill's own description.
+
+This section is the corpus the coverage claim is measured against: every name `aitk claude skills list --names` reports takes exactly one row here. A skill serving two moments sits at the earlier one, and mentions elsewhere in this file are prose rather than routing.
+
+### Set up a project
+
+| Skill                        | When to use                                                                             |
+| ---------------------------- | --------------------------------------------------------------------------------------- |
+| `aitk:setup-init`            | On a fresh scaffold, to detect the stack and run the whole install chain in one pass    |
+| `aitk:toolkit-operator`      | On a project that already exists, to read what it carries before an install is picked   |
+| `aitk:setup-gov`             | When the governance rules are wanted without the tooling chain                          |
+| `aitk:setup-indexes`         | When a markdown-heavy folder needs an `index.md` a session can browse                   |
+| `aitk:setup-plugins`         | On a new machine, to install the community and official plugins user-scoped             |
+| `aitk:setup-verify`          | After the agent generates configs, to run the installed scripts and report pass or fail |
+| `aitk:claude-design-extract` | Before the first UI feature, to draft `.claude/DESIGN.md`                               |
+| `aitk:claude-diagram`        | Once the architecture is written, to draft per-kind entries under `.claude/diagrams/`   |
+
+### Decide what to build
+
+| Skill                       | When to use                                                                     |
+| --------------------------- | ------------------------------------------------------------------------------- |
+| `aitk:claude-intake`        | When the input is a pile of findings rather than one feature                    |
+| `aitk:claude-intake-answer` | When an intake folder holds unread slots waiting on your decision               |
+| `aitk:claude-groundwork`    | When the state is unmeasured and more than one approach is live                 |
+| `aitk:decision-escalate`    | When open decisions turn on your preference and want batching into one set      |
+| `aitk:claude-roadmap`       | When MVP scope needs sequencing into ordered versions                           |
+| `aitk:claude-tasks`         | When a decided item needs a file on the board, or a shipped one needs archiving |
+| `aitk:claude-feature`       | When the approach is settled and the next step is a plan                        |
+
+### Build the feature
+
+| Skill                       | When to use                                                         |
+| --------------------------- | ------------------------------------------------------------------- |
+| `aitk:claude-worktree`      | At the plan-to-execute boundary, to get an isolated tree and branch |
+| `aitk:claude-autoship`      | After plan approval, to chain implement, verify, review, draft PR   |
+| `aitk:project-commands`     | When the project's own command needs running                        |
+| `aitk:systematic-debugging` | When a test fails or a bug surfaces, to force root cause first      |
+| `aitk:claude-ui-test`       | After a UI change, to generate e2e tests and a visual checklist     |
+
+### Check the work before it leaves the branch
+
+| Skill                         | When to use                                                           |
+| ----------------------------- | --------------------------------------------------------------------- |
+| `aitk:claude-review`          | On the local branch diff, before anything is pushed                   |
+| `aitk:claude-standards-audit` | When changed markdown has to answer to the authoring standards        |
+| `aitk:claude-ux-audit`        | To read UI source for missing states, edge cases, and inconsistencies |
+| `aitk:claude-ux-measure`      | To start the interface and measure paint, processor, and layout cost  |
+
+### Ship it
+
+| Skill                        | When to use                                                                        |
+| ---------------------------- | ---------------------------------------------------------------------------------- |
+| `aitk:git-ship`              | To run the whole post-feature chain from docs sync through open PR                 |
+| `aitk:claude-memory-capture` | First in that chain, to route what the session learned to the surface owning it    |
+| `aitk:claude-docs`           | When decisions diverged from the plan, or a shipped task needs its outcomes marked |
+| `aitk:docs-sync`             | When a change since main left `README.md` or `docs/` stale                         |
+| `aitk:git-stage`             | When the staged set spans several concerns and wants one commit each               |
+| `aitk:git-commit`            | When the staged set is one concern, or was staged hunk by hand                     |
+| `aitk:git-branch`            | When a branch name needs generating or renaming to conventional form               |
+| `aitk:git-pr`                | When a pull request needs a title and body written from the diff                   |
+| `aitk:claude-memory-review`  | After capture writes an entry, to propose where each one belongs                   |
+
+### After the pull request opens
+
+| Skill                        | When to use                                                          |
+| ---------------------------- | -------------------------------------------------------------------- |
+| `aitk:claude-pr-review`      | From an independent session, to post findings on the PR itself       |
+| `aitk:claude-address-review` | On the worker's side, to fix posted findings and push a follow-up    |
+| `aitk:git-followup`          | For a small self-review edit on a branch whose PR is already open    |
+| `aitk:git-split`             | When a branch turns out to carry unrelated commits                   |
+| `aitk:git-issue`             | When something surfaced that belongs on the tracker rather than here |
+| `aitk:git-worktree`          | After a PR merges, to list worktrees and reclaim the slot            |
+
+### Run several tracks at once
+
+| Skill                     | When to use                                                                    |
+| ------------------------- | ------------------------------------------------------------------------------ |
+| `aitk:claude-orchestrate` | To assert the control session that owns the queue and reviews each worker's PR |
+| `aitk:session-resume`     | At the start of a session, to pick up what a previous one left                 |
+
+### Keep the project current with the toolkit
+
+| Skill                       | When to use                                                                        |
+| --------------------------- | ---------------------------------------------------------------------------------- |
+| `aitk:claude-seed-sync`     | After a toolkit update, to reconcile installed seeds without losing customizations |
+| `aitk:migration-claude-md`  | When `CLAUDE.md` grew past what always-load context should carry                   |
+| `aitk:migration-context`    | When `docs/` holds agent-flavored files belonging in `.claude/context/`            |
+| `aitk:migration-standards`  | When standards sit at the root while rules point into `.claude/`                   |
+| `aitk:migration-superseded` | When a drift report names a `.claude/` file a folder has replaced                  |
+| `aitk:toolkit-feedback`     | When something in the toolkit is broken, missing, or off                           |
+| `aitk:toolkit-triage`       | In the toolkit repo, to work through the open feedback issues                      |
+
+### Generate an artifact on demand
+
+| Skill                      | When to use                                                           |
+| -------------------------- | --------------------------------------------------------------------- |
+| `aitk:create-rule`         | For a project-specific governance rule the toolkit does not ship      |
+| `aitk:create-skill`        | For a new `SKILL.md`                                                  |
+| `aitk:create-snippet`      | For a reusable prompt                                                 |
+| `aitk:create-standard`     | For a new authoring convention                                        |
+| `aitk:bash-script`         | For an interactive, human-facing shell tool                           |
+| `aitk:cli-script`          | For a non-interactive automation, CI, or pipeline script              |
+| `aitk:ci-workflow`         | For a GitHub Actions workflow file                                    |
+| `aitk:claude-slides-draft` | For a deck, drafted as `.claude/SLIDES.md` and rendered to PowerPoint |
+| `aitk:claude-screencast`   | For a recording script with beats and defaults already seeded         |
+
+### Answer a question at any point
+
+| Skill                      | When to use                                                                    |
+| -------------------------- | ------------------------------------------------------------------------------ |
+| `aitk:toolkit-cli`         | Before a sync or install, to learn what it overwrites, merges, or leaves alone |
+| `aitk:youtube-transcripts` | When a video transcript is wanted in the repo as context                       |
+
+Both rows answer a question rather than mark a point in a project's life, so a phase above would send a reader to the wrong group.
 
 ## Feedback routing
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@erclx/aitk",
   "type": "module",
-  "version": "0.94.0",
+  "version": "0.96.0",
   "description": "Infrastructure and quality tooling for developer workflows",
   "license": "MIT",
   "bin": {

package/src/commands/records.ts

@@ -9,7 +9,9 @@ import {
 import {
   type Finding,
   isRecordKind,
+  isSharedScratch,
   RECORD_KINDS,
+  type RecordKind,
   type ValidateOutcome,
   validateRecords,
 } from '@/records/validate'
@@ -22,7 +24,7 @@ import {
   outro,
   pipeOutput,
 } from '@/ui'
-import { mainWorktreeRoot } from '@/worktree'
+import { currentWorktreeRoot, mainWorktreeRoot } from '@/worktree'
 
 /** Returned when a record carries a finding, which is the gating result. */
 const EXIT_FINDINGS = 2
@@ -38,17 +40,20 @@ export function register(program: Command): void {
   const records = program
     .command('records')
     .description(
-      'Check and back up the gitignored session records under .claude/',
+      'Check a governed corpus against its standard, and back up the session records under .claude/',
     )
     .helpOption('-h, --help', 'Show this help message')
 
   records
     .command('validate')
-    .description('Report where a record and the standard governing it disagree')
+    .description('Report where a file and the standard governing it disagree')
     .argument('<kind>', `Record folder: ${RECORD_KINDS.join(', ')}`)
     .helpOption('-h, --help', 'Show this help message')
     .option('--json', 'Add a machine-readable record on stdout')
-    .option('--root <path>', 'Project root, defaulting to the main worktree')
+    .option(
+      '--root <path>',
+      'Project root, defaulting to the main worktree except on standards',
+    )
     .addHelpText(
       'after',
       [
@@ -58,18 +63,22 @@ export function register(program: Command): void {
         '  groundwork  README and current-state files, numbering, dating, and a half-closed track',
         '  intake      overview file, numbering, dating, and the four bullets every item carries',
         '  memory      filename and type prefix, frontmatter, and the body shape each type carries',
+        '  standards   frontmatter, the scope section and its handoff list, and a filename',
+        '              derived from the governed path',
         '',
         'Exit codes:',
         '  0  every check passed',
         '  1  refused, with the reason on stderr or in the JSON record',
         '  2  at least one record carries a finding',
         '',
-        'It reports and never writes. Each folder is per-machine scratch with no',
-        'history behind it, so a session fixes the record the report names.',
+        'It reports and never writes, so a session fixes what the report names. A',
+        'session record has no history to undo a wrong repair from, and a standard',
+        'is installed and cited everywhere, so a rename is larger than a file move.',
         '',
         'Examples:',
         '  aitk records validate plans',
         '  aitk records validate memory',
+        '  aitk records validate standards',
         '  aitk records validate intake --json',
         '',
       ].join('\n'),
@@ -218,6 +227,15 @@ function reportRefusal(
   return 1
 }
 
+/**
+ * A shared-scratch kind reads the main worktree root, so a linked worktree
+ * validates the records every other session reads. A tracked corpus reads the
+ * checkout the caller stands in, which is the copy that session has edited.
+ */
+function defaultRoot(kind: RecordKind): Promise<string> {
+  return isSharedScratch(kind) ? mainWorktreeRoot() : currentWorktreeRoot()
+}
+
 async function runValidate(
   kind: string,
   opts: ValidateCommandOptions,
@@ -236,7 +254,7 @@ async function runValidate(
     )
   }
 
-  const root = opts.root ?? (await mainWorktreeRoot())
+  const root = opts.root ?? (await defaultRoot(kind))
 
   return report(await validateRecords(root, kind), emitJson, root)
 }

package/src/records/backup.ts

@@ -10,8 +10,9 @@ import { gitEnv } from '@/git-env'
  * enclosing repository already. The list is spelled out rather than read off
  * that group so adding an ignore entry cannot silently enlarge the payload.
  *
- * `RECORD_KINDS` in `validate.ts` names four of these. The two lists differ on
- * purpose: one is what a standard governs, this is what a disk loss would take.
+ * `RECORD_KINDS` in `validate.ts` overlaps this on four names and carries one
+ * more that no backup reaches. The two lists differ on purpose: one is what a
+ * standard governs, this is what a disk loss would take.
  */
 export const BACKED_FOLDERS = [
   'groundwork',

package/src/records/validate.ts

@@ -4,15 +4,31 @@ import { join } from 'node:path'
 import { parseFrontmatter, readField } from '@/indexes/frontmatter'
 import { linesOutsideFences } from '@/markdown/scan'
 
-export const RECORD_KINDS = ['plans', 'groundwork', 'intake', 'memory'] as const
+export const RECORD_KINDS = [
+  'plans',
+  'groundwork',
+  'intake',
+  'memory',
+  'standards',
+] as const
 
 export type RecordKind = (typeof RECORD_KINDS)[number]
 
-const FOLDER_BY_KIND: Readonly<Record<RecordKind, string>> = {
-  plans: join('.claude', 'plans'),
-  groundwork: join('.claude', 'groundwork'),
-  intake: join('.claude', 'intake'),
-  memory: join('.claude', 'memory'),
+/**
+ * The folders each kind reads, in precedence order.
+ *
+ * Standards carry two because the corpus authors at the project root and
+ * installs under `.claude/`. The authoring root wins where both exist, since the
+ * installed tree is a generated copy here and a finding fixed there is
+ * overwritten by the next regen. A project that consumed the corpus holds only
+ * the second, so one order serves both.
+ */
+const FOLDERS_BY_KIND: Readonly<Record<RecordKind, readonly string[]>> = {
+  plans: [join('.claude', 'plans')],
+  groundwork: [join('.claude', 'groundwork')],
+  intake: [join('.claude', 'intake')],
+  memory: [join('.claude', 'memory')],
+  standards: ['standards', join('.claude', 'standards')],
 }
 
 /**
@@ -30,6 +46,7 @@ export const FINDING_KINDS = [
   'title-missing',
   'title-is-slug',
   'section-missing',
+  'scope-unanchored',
   'entry-unreasoned',
   'suggestion-missing',
   'question-unanswerable',
@@ -67,14 +84,37 @@ export interface ValidateRefused {
 
 export type ValidateOutcome = ValidateReport | ValidateRefused
 
+/** Every folder a kind would accept, whether or not it is on disk. */
+export function recordDirs(root: string, kind: RecordKind): string[] {
+  return FOLDERS_BY_KIND[kind].map((folder) => join(root, folder))
+}
+
+/**
+ * The folder a kind reads. The first candidate on disk wins, and the first
+ * candidate stands in when none exists, so a refusal and a test fixture both
+ * name the location the kind prefers.
+ */
 export function recordsDir(root: string, kind: RecordKind): string {
-  return join(root, FOLDER_BY_KIND[kind])
+  const dirs = recordDirs(root, kind)
+  return dirs.find((dir) => existsSync(dir)) ?? dirs[0]
 }
 
 export function isRecordKind(value: string): value is RecordKind {
   return (RECORD_KINDS as readonly string[]).includes(value)
 }
 
+/**
+ * Whether a kind's folder is shared session scratch at the main worktree root.
+ *
+ * The four record folders are, so every session validates the records every
+ * other session reads. The corpus is tracked instead, so a linked worktree holds
+ * its own edited copy, and defaulting that kind to the main root would report on
+ * a tree the session never touched and say nothing about which one it read.
+ */
+export function isSharedScratch(kind: RecordKind): boolean {
+  return kind !== 'standards'
+}
+
 const NONE_IDENTIFIED = 'None identified.'
 const NUMBERED_FILE = /^\d{2}-[a-z0-9]+(-[a-z0-9]+)*\.md$/
 
@@ -673,6 +713,165 @@ function checkMemoryBody(
   return findings
 }
 
+const STANDARD_INDEX = 'index.md'
+const STANDARD_FIELDS = ['title', 'description'] as const
+
+const SCOPE_HEADING = /^##[ \t]+Scope[ \t]*$/
+const ANY_HEADING = /^#{1,6}[ \t]+\S/
+const DOES_NOT_GOVERN = 'Does not govern:'
+const ATTRIBUTE_MARKER = 'attribute standard'
+const CODE_SPAN = /`([^`]+)`/g
+
+interface Scope {
+  /** The first non-blank line under the heading, which is the statement. */
+  readonly statement: string
+  readonly lines: readonly string[]
+}
+
+export function readScope(text: string): Scope | undefined {
+  const lines = linesOutsideFences(text)
+  const opened = lines.findIndex((line) => SCOPE_HEADING.test(line.trim()))
+  if (opened === -1) return undefined
+
+  const body: string[] = []
+
+  for (const line of lines.slice(opened + 1)) {
+    if (ANY_HEADING.test(line.trim())) break
+    body.push(line)
+  }
+
+  const statement = body.find((line) => line.trim().length > 0)
+
+  return { statement: statement?.trim() ?? '', lines: body }
+}
+
+/**
+ * The paths a scope statement declares, read the way `scripts/standards/list.sh`
+ * reads them for the catalog's `appliesTo` field: backticked spans in the first
+ * sentence alone. One sentence read two ways would let a standard pass here
+ * while publishing a different jurisdiction to every consumer of the catalog.
+ */
+export function governedPaths(statement: string): string[] {
+  const [sentence] = statement.split('. ')
+  return [...sentence.matchAll(CODE_SPAN)].map((match) => match[1])
+}
+
+/**
+ * The words a governed path offers a filename. Each segment gives its own word
+ * and, where it carries a prefix or a placeholder, the parts either side of a
+ * hyphen, so `.claude/tasks/session-<slug>.md` offers `tasks` and `session`.
+ *
+ * A dotted segment gives nothing. It names the folder holding the artifact
+ * rather than the artifact, and a standard named for it would pass this check
+ * while naming the container every sibling shares.
+ */
+export function pathWords(path: string): string[] {
+  const words: string[] = []
+
+  for (const segment of path.split('/')) {
+    if (segment.startsWith('.')) continue
+
+    const stem = segment.replace(/\.[a-z]+$/i, '').toLowerCase()
+    words.push(stem)
+    if (stem.includes('-')) words.push(...stem.split('-'))
+  }
+
+  return words.filter((word) => /^[a-z]+$/.test(word))
+}
+
+/**
+ * Accepts the singular and the plural of one word. A standard over a single
+ * document is named for the document and one over a folder of them is named for
+ * either, and picking a side would report a conforming half of the corpus.
+ */
+function namesWord(stem: string, word: string): boolean {
+  return stem === word || `${stem}s` === word || stem === `${word}s`
+}
+
+function checkStandardName(name: string, statement: string): Finding[] {
+  const paths = governedPaths(statement)
+
+  // The marker is read only where the first sentence backticks nothing, which
+  // is the catalog's own rule. A statement naming a path publishes that path
+  // however the rest of the statement describes itself.
+  if (paths.length === 0) {
+    if (statement.includes(ATTRIBUTE_MARKER)) return []
+
+    return [
+      finding(
+        'scope-unanchored',
+        name,
+        name,
+        'backticks no path in its first scope sentence and does not call itself an attribute standard, so it names no artifact to be named for.',
+      ),
+    ]
+  }
+
+  const stem = name.replace(/\.md$/, '')
+  const words = paths.flatMap(pathWords)
+
+  if (words.some((word) => namesWord(stem, word))) return []
+
+  return [
+    finding(
+      'name-malformed',
+      name,
+      name,
+      `names no part of ${paths.join(', ')}, which is what it governs. A rename reaches every target that installed the corpus and every surface citing it by bare filename.`,
+    ),
+  ]
+}
+
+export function checkStandard(name: string, text: string): Finding[] {
+  const findings: Finding[] = []
+  const frontmatter = parseFrontmatter(text)
+
+  const missing = STANDARD_FIELDS.filter(
+    (field) => !readField(frontmatter, field),
+  )
+
+  if (missing.length > 0) {
+    findings.push(
+      finding(
+        'frontmatter-incomplete',
+        name,
+        name,
+        `carries no ${missing.join(' and no ')}.`,
+      ),
+    )
+  }
+
+  const scope = readScope(text)
+
+  // The name derives from the scope statement, so an absent section leaves
+  // nothing to derive against. Reporting the name as well would name one defect
+  // twice and point the fix at the wrong file.
+  if (!scope) {
+    return [
+      ...findings,
+      finding(
+        'section-missing',
+        name,
+        '## Scope',
+        'is absent, so the standard claims no jurisdiction and can refuse no rule.',
+      ),
+    ]
+  }
+
+  if (!scope.lines.some((line) => line.trim().startsWith(DOES_NOT_GOVERN))) {
+    findings.push(
+      finding(
+        'section-missing',
+        name,
+        DOES_NOT_GOVERN,
+        'is absent from the scope section, so no boundary names the owner it hands off to.',
+      ),
+    )
+  }
+
+  return [...findings, ...checkStandardName(name, scope.statement)]
+}
+
 function refuse(reason: ValidateRefusal, message: string): ValidateRefused {
   return { ok: false, reason, message }
 }
@@ -696,9 +895,12 @@ async function validateFiles(
 }
 
 /**
- * Reports what every record in one gitignored folder claims against the shape
- * its standard fixes. It writes nothing: the folder is per-machine scratch with
- * no history behind it, so a repair that guessed wrong could not be undone.
+ * Reports what every record in one folder claims against the shape its standard
+ * fixes. It writes nothing whichever kind runs, and the reason differs by kind.
+ * A session record is per-machine scratch with no history behind it, so a repair
+ * that guessed wrong could not be undone. A standard installs into every target
+ * and is cited by bare filename, so a rename costs more than the file move it
+ * looks like.
  */
 export async function validateRecords(
   root: string,
@@ -707,7 +909,10 @@ export async function validateRecords(
   const dir = recordsDir(root, kind)
 
   if (!existsSync(dir)) {
-    return refuse('no-folder', `No ${kind} folder at ${dir}.`)
+    return refuse(
+      'no-folder',
+      `No ${kind} folder at ${recordDirs(root, kind).join(' or ')}.`,
+    )
   }
 
   if (kind === 'plans') return validateFiles(dir, kind, checkPlan)
@@ -721,6 +926,18 @@ export async function validateRecords(
     )
   }
 
+  // The walk stays flat, matching install and the catalog. `standards/bundled/`
+  // is a subfolder whose members are named for the skill that reads them rather
+  // than for a path they govern, so the derivation below reports every one.
+  if (kind === 'standards') {
+    return validateFiles(
+      dir,
+      kind,
+      checkStandard,
+      (file) => file === STANDARD_INDEX,
+    )
+  }
+
   const folders = await listFolders(dir)
   const check = kind === 'groundwork' ? checkTrack : checkDump
   const perFolder = await Promise.all(

package/src/sandbox/expect.ts

@@ -220,15 +220,39 @@ function checkPaths(
   )
 }
 
+/**
+ * An entry carrying `*` is matched as a glob, which is what lets an arm forbid
+ * a file whose name a run derives rather than fixes. Pinning one spelling of a
+ * derived name passes vacuously against every other spelling, which reads as
+ * coverage the arm does not have. Returns the offending path so a failure names
+ * the file the run wrote rather than the pattern that caught it.
+ */
+function writtenUnder(pattern: string, sandboxDir: string): string | undefined {
+  if (!pattern.includes('*')) {
+    return existsSync(join(sandboxDir, pattern)) ? pattern : undefined
+  }
+
+  for (const match of new Bun.Glob(pattern).scanSync({
+    cwd: sandboxDir,
+    dot: true,
+  })) {
+    return match
+  }
+
+  return undefined
+}
+
 function checkAbsent(
   expectation: Expectation,
   sandboxDir: string,
 ): AssertionResult[] {
-  return expectation.absent.map((path) =>
-    existsSync(join(sandboxDir, path))
-      ? { ok: false, message: `should not exist: ${path}` }
-      : { ok: true, message: `absent: ${path}` },
-  )
+  return expectation.absent.map((path) => {
+    const written = writtenUnder(path, sandboxDir)
+
+    return written
+      ? { ok: false, message: `should not exist: ${written}` }
+      : { ok: true, message: `absent: ${path}` }
+  })
 }
 
 /**

package/src/tasks/archive.ts

@@ -9,12 +9,21 @@ const PLANS_DIR = join('.claude', 'plans')
 
 /**
  * Siblings that sit on the board without being tasks: the generated index, the
- * hand-maintained ordering, and the pre-compaction session map. `validate`
- * reads the same list, so neither verb can count a sibling as a task the other
- * does not.
+ * hand-maintained ordering, and a handoff a session wrote before the file took
+ * one name per session. `validate` reads the same list, so neither verb can
+ * count a sibling as a task the other does not.
  */
 export const RESERVED_STEMS = ['index', 'priority', 'session'] as const
 
+/** The pre-compaction handoff takes one file per session, so its stems vary. */
+const SESSION_MAP_PREFIX = 'session-'
+
+export function isReservedStem(stem: string): boolean {
+  const reserved: readonly string[] = RESERVED_STEMS
+
+  return reserved.includes(stem) || stem.startsWith(SESSION_MAP_PREFIX)
+}
+
 /**
  * `bad-input` describes the command line rather than the board, which is the
  * split `record.ts` draws for the same reason. A caller naming two selectors
@@ -190,12 +199,11 @@ function isLivePlan(target: string, dir: string, root: string): boolean {
 
 export async function listTaskStems(dir: string): Promise<string[]> {
   const entries = await readdir(dir)
-  const reserved: readonly string[] = RESERVED_STEMS
 
   return entries
     .filter((entry) => entry.endsWith('.md'))
     .map((entry) => entry.slice(0, -'.md'.length))
-    .filter((stem) => !reserved.includes(stem))
+    .filter((stem) => !isReservedStem(stem))
     .sort()
 }
 

package/src/tasks/validate.ts

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs'
 import { readdir, readFile } from 'node:fs/promises'
 import { join, resolve } from 'node:path'
-import { RESERVED_STEMS, tasksDir } from '@/tasks/archive'
+import { isReservedStem, tasksDir } from '@/tasks/archive'
 
 const ORDERING_FILE = 'priority.md'
 
@@ -204,12 +204,11 @@ export function readBoard(text: string): {
 
 async function listTaskStems(dir: string): Promise<string[]> {
   const entries = await readdir(dir)
-  const reserved: readonly string[] = RESERVED_STEMS
 
   return entries
     .filter((entry) => entry.endsWith('.md'))
     .map((entry) => entry.slice(0, -'.md'.length))
-    .filter((stem) => !reserved.includes(stem))
+    .filter((stem) => !isReservedStem(stem))
     .sort()
 }
 

package/src/worktree.ts

@@ -1,5 +1,21 @@
 import { $ } from 'bun'
 
+/**
+ * Resolves the root of the checkout the caller is standing in, which is the
+ * linked worktree rather than the main one when a session is inside one.
+ *
+ * A tracked tree differs per worktree, so a verb reading one answers about the
+ * files the session has edited only if it resolves the root this way. The
+ * working directory is not a substitute, since a caller invoking from a
+ * subdirectory would resolve a root holding none of the trees a verb reads.
+ */
+export async function currentWorktreeRoot(): Promise<string> {
+  const result = await $`git rev-parse --show-toplevel`.quiet().nothrow()
+  if (result.exitCode !== 0) return process.cwd()
+
+  return result.stdout.toString().trim() || process.cwd()
+}
+
 /**
  * Resolves the root every shared-scratch folder lives under. `git worktree
  * list` puts the main worktree first, and trusting the working directory

package/standards/index.md

@@ -21,6 +21,7 @@ Reference docs for consistent authoring across the toolkit and target projects.
 - [Readme reference](readme.md): Readme voice, structure, and content conventions
 - [Requirements reference](requirements.md): Shape and content rules for .claude/REQUIREMENTS.md
 - [Governance rule reference](rule.md): Rule frontmatter, body shape, and voice for .claude/rules files
+- [Session map reference](session.md): Filename and location, the sections a handoff carries, the write and read procedures, and how a role extends it
 - [Claude skill reference](skill.md): Claude skill structure and authoring rules
 - [Slug reference](slug.md): Transform from a git branch name to a slug, and the three responses to an empty result
 - [Standard reference](standard.md): Shape and content rules for authoring a standard

package/standards/session.md

@@ -0,0 +1,106 @@
+---
+title: Session map reference
+description: Filename and location, the sections a handoff carries, the write and read procedures, and how a role extends it
+---
+
+# Session map reference
+
+Applies to `.claude/tasks/session-<slug>.md`. A session writes one before a compaction, because a compaction keeps conclusions and drops the reasoning that produced them. It is rewritten whenever the session that owns it learns something the next session would otherwise re-derive, and it is optional: a project whose sessions never approach a compaction carries none.
+
+Any session writes one. The role a session holds decides which sections it adds on top of the core, never whether it may write at all.
+
+## Scope
+
+Governs the pre-compaction handoff at `.claude/tasks/session-<slug>.md`: its filename, its sections, what a writer puts in each, and how a reader picks one up.
+
+Does not govern:
+
+- The task board the file sits beside, its filenames, and its archiving: `tasks.md`
+- The transform from a branch name to the slug in the filename: `slug.md`
+- The role-specific sections a caller adds over the core, which belong to that caller
+- Which memories a session captures before writing, which is the capture surface's own subject
+
+## What a working session map looks like
+
+A session map works when the session reading it can act on the reasoning without asking the session that wrote it:
+
+- What is clean, what is running, and what is open right now?
+- Which mistake already made would this session repeat?
+- Which command, tool, or held instruction lies about the tree?
+- Where did each claim come from, so a reader can tell a read from a recall?
+
+A session map failing these is non-conforming even when it satisfies every shape rule below.
+
+## Filename and location
+
+- Write one file per session, named `session-<slug>.md`, where `<slug>` is the branch-derived slug
+- Fall back to `session-latest.md` when the branch resolves empty, since a handoff is scratch rather than a commit and a stop would lose the reasoning it exists to save
+- Resolve the containing folder at the main worktree root, never inside a linked worktree
+- Overwrite the file the writing session already owns. A stale entry read as current is worse than no handoff.
+- Never write into a file another session owns. One file per session is what keeps two sessions closing near each other from each writing the whole file, where the loser leaves no trace.
+
+## Frontmatter
+
+- `title` (required): `Session map`, so every handoff reads the same in a generated catalog
+- `description` (required): what the board cannot show, and the date the file was written
+
+## Sections
+
+Three sections form the core, in this order, and every session fills all three.
+
+- `## State`: what is clean, what is running, what is open, and any untracked file that needs committing
+- `## Mistakes worth not repeating`: what went wrong and the rule it yields
+- `## Standing cautions`: commands that lie, tools that measure the wrong tree, and anything unbacked
+
+Add a section only for content that fits none of the three and would otherwise be lost.
+
+## Writing one
+
+1. Capture what the session learned first, so the map cites what was written instead of restating the same lesson in prose.
+2. Run `aitk claude skills drift <the commit this session started from>` and record what it names under `## Standing cautions`. A skill body enters a session once and re-invoking the skill replays the held copy rather than the file, so the drift is worst at exactly this moment and a name here is a body the session has been following out of date. This step belongs to session length rather than to any role, so every writer runs it, and a refusal names the boundary of what the verb can read rather than a fault.
+3. Recover that commit from how long the session has been running with `git log -1 --format=%H --before='<duration> ago'`, rounding the duration up rather than down. Nothing on the machine records it. A ref older than the oldest load over-reports, and confirming a name costs one read of the body, so the generous end is the safe one and a guess at the exact commit is not worth making.
+4. Write only what a compaction destroys and no other artifact already carries. The board holds the ordering and what each task waits on, a task file holds its own findings, and a measurement folder holds its track.
+5. Cite a commit, a task, or a file and line for every claim, so the next session can tell a read from a recall.
+6. Fill a section from reasoning the session actually holds. A session with no cross-feature picture that fills `## State` from what is already in git has written a summary of the tree, which the reader can produce faster than they can read it.
+
+Do not restate the board, and do not summarize the work that shipped, since version control already carries it.
+
+## Reading one back
+
+- Read the newest map in the folder, by modification time, and treat it as the previous session's scratch rather than as a source
+- Say nothing when no map exists. Absence is the common case, and a line reporting it every run is the noise that makes the present case unnoticeable.
+- Re-measure every count, size, and cost the map states, since each was true when written
+
+## Extending it
+
+- Carry every core section whatever else a role adds, and state in the surface that adds a section why the core cannot carry it
+- Let the adding surface fix where its own section sits, so a role can place one between core sections where that reads better. The core order holds among the core sections alone.
+- Keep a section out of the core when a session holding no such role would leave it unfilled. An unfilled section teaches a reader to skip the file.
+- Carry a resume instruction inside the map itself when the routing to that instruction is what a compaction takes. The map survives what the instruction was loaded from, so each reaches a reader the other cannot.
+
+## Template
+
+```markdown
+---
+title: Session map
+description: <what the board cannot show, and the date it was written>
+---
+
+# Session map
+
+<one line marking the file throwaway and naming the board as the real source>
+
+## State
+
+<what is clean, what is running, what is open, and any untracked file that needs committing>
+
+## Mistakes worth not repeating
+
+<what went wrong and the rule it yields>
+
+## Standing cautions
+
+<commands that lie, tools that measure the wrong tree, and anything unbacked>
+```
+
+A role-specific section is placed by the surface that adds it, so the skeleton above shows the core alone.

package/standards/standard.md

@@ -46,6 +46,14 @@ A standard failing these questions is non-conforming even when it satisfies ever
 - Separate a jurisdiction exclusion from a content exclusion. The first names a concern another standard owns and belongs in `## Scope`. The second names what does not belong inside the document and stays with the shape rules. Merging them puts a boundary claim where no sibling will read it.
 - Stay silent on a section the standard holds today but should not own. Claiming it makes the scope statement false the moment it moves, and the mismatch is the evidence that moves it.
 
+### Naming the file
+
+- Name the file for the artifact the scope statement governs, taking the word from the deepest path segment that names the artifact rather than the folder holding it. `plan.md` over `.claude/plans/feature-<slug>.md` and `session.md` over `.claude/tasks/session-<slug>.md` both follow it.
+- Take the singular or the plural of that word, whichever reads as the artifact. A standard over one document takes the singular, and one over a set may take either.
+- Name an attribute standard for the attribute itself, since it governs no path to derive a word from.
+- Write the derived word alone. A standard installs as a sibling and is cited by bare filename, so a qualifier makes an outlier that every later citation has to carry.
+- Rename an outlier at the moment it is found, and state the reach in the change that does it. The name is installed in every target and cited in surfaces that never see the rename, so the cost only grows.
+
 ### Staying inside it
 
 - Name no path, filename, or folder outside the document type the standard governs. A standard reaches projects whose layout is their own, so a path borrowed from the authoring repository is wrong in a target and nothing reports it.

package/standards/tasks.md

@@ -21,6 +21,7 @@ Does not govern:
 - Phase-label format and which surfaces a label may appear on: `versioning.md`
 - Sequencing across versions and why the order is what it is: `roadmap.md`
 - Architectural reasoning that outlives a task: `architecture.md`
+- The pre-compaction handoff sitting in the folder, its filename and its sections: `session.md`
 - When a project opens a task at all, which is project policy rather than a shape rule
 
 ## Layout
@@ -29,17 +30,21 @@ Does not govern:
 .claude/tasks/
 ├── index.md              ← generated, never hand-edited
 ├── priority.md           ← hand-maintained execution order
-├── session.md            ← optional, what a compaction is about to destroy
+├── session-<slug>.md     ← optional, what a compaction is about to destroy
 ├── v09.0-sync-paths.md
 └── v13.0-toolkit-drift.md
 ```
 
 One file per task is what keeps the board safe under parallel sessions. Two sessions working different tasks never write the same file, which matters because a gitignored board has no history to recover a clobbered write from.
 
-Three siblings sit in the folder without being tasks, and each earns its place by being governed somewhere. `index.md` and `priority.md` are governed here. `session.md` is the pre-compaction handoff, written by `orchestrator-handoff` and read by `orchestrator-resume`, and it is optional: a project running no orchestrator carries no such file. Anything reading the folder as a task list skips all three, so a name outside the set is a task whatever it holds.
+Siblings sit in the folder without being tasks, and each earns its place by being governed somewhere. `index.md` and `priority.md` are governed here. Every `session-` file is a pre-compaction handoff governed by `session.md`, and each is optional: a project whose sessions never approach a compaction carries none. Anything filtering the folder to tasks skips all of them, so a name outside the set is a task whatever it holds.
+
+The handoff takes one file per session for the reason a task does. A single shared path puts two sessions closing near each other on one file that neither can watch the other write, and the loser leaves no trace on a board with no history behind it.
 
 `index.md` is generated from sibling frontmatter. The folder is gitignored, so the whole-repo index walk skips it and a hook passing the changed path regenerates it instead. Never hand-edit it.
 
+The catalog is the one reader that filters nothing, so it carries a row per sibling alongside the tasks. That is what a folder catalog is for, and the handoffs are what make it worth stating: a board accumulates one row per session that ever wrote one, with nothing pruning them. Anything reading the catalog as the backlog therefore does its own filtering, and a reader that takes every row as a task reports the handoffs as queued work.
+
 The `claude-tasks` skill creates and archives task files. `claude-docs` marks outcomes `[x]` in an existing file and sweeps the plans those tasks cite. Neither does the other's job.
 
 ## Ordering