@erclx/aitk 0.107.1 → 0.108.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.107.1",
+  "version": "0.108.0",
   "author": {
     "name": "Eric Le",
     "url": "https://github.com/erclx"

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

@@ -102,6 +102,8 @@ For each doc with relevant changes, apply updates following these rules. Read a
 
 The verb resolves the board at the main worktree root in-process, which is the route because this is an edit inside an existing file and the file-editing tools refuse that path from a linked worktree.
 
+Read `ok` and `reason` out of that record rather than the exit, for the reason the plans sweep below states at length. A refusal arriving as success leaves the outcome unmarked while the chain moves on, so the board reports shipped work as open and the next session re-plans it.
+
 **REQUIREMENTS.md, ARCHITECTURE.md, DESIGN.md, `.claude/wireframes/<surface>.md`**
 
 - Update only the sections affected by session decisions.

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

@@ -114,7 +114,7 @@ Write no shape for a correction. A correction is a sentence, and a format for ad
    - Learning that a PR moved is the mechanical half, so read `${CLAUDE_SKILL_DIR}/references/orchestrator-poll.md` and start the poll it carries on the first dispatch rather than checking the board by hand. That runbook holds the routing, and a summary of it here is a second source that drifts from it.
 7. Dispatch the handback. A pass posting a finding at any severity tells the session holding that branch to run `claude-address-review`, rather than waiting for a person to relay it. Re-review when the answer lands, then the human merges. Tell the trailing worker to rebase when its branch shares a seam with the merged one.
    - Read the threshold off `claude-pr-review`, which states it once and governs the heading with it, so an open heading and an owed dispatch answer the same question and either one is enough to send
-   - Resolve the target from a fresh session listing at the moment of sending, never from a mapping written down earlier, since names rotate as sessions end and one recorded earlier in a session has failed inside the hour
+   - Resolve the target at the moment of sending with `aitk sessions list --branch`, never from a mapping written down earlier, since names rotate as sessions end and one recorded earlier in a session has failed inside the hour. The runbook read at step 6 routes on the count and the confidence it answers with
    - Open the message with the worktree and branch the sender believes the reader holds, asking to be corrected, whenever that mapping is inferred rather than confirmed
    - Name the skill for the reader to run rather than writing an invocation, which arrives as text
    - Read the pull request's own draft flag rather than the state a worker reports, since two reported a draft that read ready inside ninety seconds

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

@@ -80,10 +80,12 @@ The board is gitignored, so an archived task has no history behind it and nothin
 Pass the task's filename stem, or the pull request number when the request names one:
 
 ```bash
-aitk tasks archive <stem>
+aitk tasks archive <stem> --json
 ```
 
-The command refuses rather than reports, so read its exit code. On success it prints what moved, what row it cleared, and whether the index changed.
+The command refuses rather than reports, and the refusal reaches this skill through the record rather than through the exit. Branch on `ok`, then on `reason`. An operator's shell profile may wrap `aitk` in a function that runs the binary and then a second command and takes the second status, which masks every non-zero exit rather than only an absent verb. The binary exits 1 for an unknown subcommand and 1 for an ordinary refusal alike, so the record is the only signal that survives the wrapper.
+
+On success the record carries `from`, `to`, `priorityRowRemoved`, and `indexRegenerated`, which is what moved, what row it cleared, and whether the index changed.
 
 ### Step 3: route on a refusal
 

package/claude/skills/cli-script/SKILL.md

@@ -27,6 +27,7 @@ Load `${CLAUDE_SKILL_DIR}/references/template.md` for the base skeleton. Copy it
 - Include actionable context in error messages.
 - Guard commands that return non-zero on a valid empty result with `|| true`.
 - Set explicit exit codes. Reserve 0 for success.
+- Read a called command's machine-readable record where it emits one. An exit status separates success from failure and never names which failure, so a script routing on the reason reads the record and keeps the exit for the pass-fail decision alone.
 
 ## Code style
 

package/claude/skills/project-commands/SKILL.md

@@ -53,6 +53,8 @@ Decide from what the entry says the command does, not from its name. When the en
 
 If a command fails or never comes up, report the failure and the last output. Do not retry with a different command, and do not abandon the others.
 
+An exit status here is part of the report rather than the basis for one. Step 3 confirms a service came up against what it printed, so the number is passed through to the reader and decides nothing. A documented command reaching `aitk` is the case worth naming, since an operator's shell profile may wrap the binary in a function that takes its status from a later command, and judging that run by its exit would call a refusal a success.
+
 ## Step 4: stop
 
 Report and end the turn. Specifically do not:

package/claude/skills/setup-indexes/SKILL.md

@@ -88,10 +88,10 @@ aitk indexes regen --dry-run --json
 Parse the JSON. On any `error` action, surface the file and reason and stop. On `would-write` for the bootstrapped folders, the dry-run is healthy. Run for real:
 
 ```bash
-aitk indexes regen
+aitk indexes regen --json
 ```
 
-Report the `written` count.
+Count the `written` actions in that record and report the number. Read the real run the same way the dry run is read, since the exit carries nothing reliable back to a session. An operator's shell profile may wrap `aitk` in a function that runs the binary and then a second command and takes the second status, so a regen that errored on a sibling missing `title` arrives here as a clean pass.
 
 ## Offer the convention seed
 

package/docs/agents/context-audit-checks.md

@@ -41,7 +41,7 @@ The measure counts fenced blocks and frontmatter, so a reference-heavy entry ran
 
 Every entry past the checkpoint carries the three questions the standard asks of it rather than a count alone: whether it still covers one domain, whether it has filled with content `ls` or `--help` reproduces, and whether it has accumulated the history of its own changes. The checkpoint is not a cap, so the count is not the finding. What a reader acts on is which question came back true, and the standard directs the fix at that rather than at the number.
 
-Only the third is mechanical, and it is the provenance check already reported below, so the length finding cites that count rather than measuring it again. An entry outside the governed folder reads open there too, since provenance is scoped to the standard stating it and a clean list there is a scan that never ran. The other two stay open beside every entry, because whether a domain is still one domain is a judgment about its subject and recognizing reproduced content needs a reader who knows what those commands emit. Omitting them would read as an entry nothing found rather than one nothing checked.
+Only the third is mechanical, and it is the provenance check already reported below, so the length finding cites that count rather than measuring it again. What it cites is a count of change markers, which is why an entry recording what its own runs cost answers `no` there while carrying dates throughout. An entry outside the governed folder reads open there too, since provenance is scoped to the standard stating it and a clean list there is a scan that never ran. The other two stay open beside every entry, because whether a domain is still one domain is a judgment about its subject and recognizing reproduced content needs a reader who knows what those commands emit. Omitting them would read as an entry nothing found rather than one nothing checked.
 
 It reports and never gates, which the standard settles rather than the usual judgment-against-fact line: there is no hard cap, so an entry that answers all three and is still long is a correct outcome. The JSON record carries the joined findings as `length`, each with a `causes` array in the standard's order, and the jurisdiction the join reads as `entries[].governed`. That flag is what parts a provenance list measured and empty from one never scanned, which the count alone cannot say. The join is published rather than left to a consumer, since deriving it means restating which question the provenance count answers.
 
@@ -55,6 +55,10 @@ The table check reports a catalog that grows a row per shipped thing, not a tabl
 
 The provenance check reports the markers narrating how a domain reached its shape rather than describing what it is: a date, a change number, or a release label. The standard admits a rejected alternative and the reasoning that killed it while refusing the provenance attached to it, so a marker names a line to read rather than a line to delete. Findings group by entry and sort left to right within a line, since what a reader acts on is which file to open.
 
+A date stamping a measurement is excluded, because the standard cuts a date attached to a change and permits one dating a figure. The check reads the clause in front of the date, back to the nearest sentence boundary, for one of five verbs: measured, verified, driven, passed, and fired. The noun `run` counts only where it sits against the date, so `A run on 2026-08-14` is excluded and `Runs on #632 and #634 landed 2026-08-02` reports. The set is closed, and a date it cannot place reports as a change marker rather than as a state of its own, which names one date too many rather than clearing one the rule cuts.
+
+A release label reports with or without its leading `v` at three segments, since the rule cuts the label rather than a spelling of it. Two segments still need the `v`, which keeps a dollar cost and a duration out. Another tool's version reports too, and the check cannot tell one from a release, so treat a version beside a tool name as a line to read rather than one to cut.
+
 Fenced blocks are excluded, which keeps a pinned version in an install command from reading as a claim the entry makes. Frontmatter is excluded with them, since the content checks read the body alone, and that is what keeps a diagram entry's dated `verified` stamp a record of its last check rather than a marker to settle. Length is the exception, counting the whole file, so a reader applying the 150-rendered-line checkpoint against the body alone lands a few lines under what the tool reports.
 
 ## Narration

package/docs/agents/indexes.md

@@ -22,6 +22,8 @@ Each is driven by a `PostToolUse` hook matching `Write|Edit|MultiEdit`, so a fil
 
 Exit codes: `0` clean, `1` frontmatter error or missing index, `2` drift found in `--dry-run`.
 
+An exit code says nothing about a call made from a session, since a shell profile may wrap the binary in a function taking its status from a later command. Read the record's `results` array rather than the exit when a skill consumes this, on the write pass as well as the dry run.
+
 When positional paths are passed inside a git repo, modified `index.md` files are staged so lint-staged and Claude `PostToolUse` hooks commit the regenerated catalog. Whole-repo walks never auto-stage, and neither does a path git ignores, since staging one always fails and the warning would fire on every edit.
 
 Skills can parse drift without branching on exit code:

package/docs/agents/intake.md

@@ -60,6 +60,8 @@ An item already carrying an answer refuses rather than being overwritten, and on
 
 Exit codes: `0` every named item now carries its answer, `1` refused. The `reason` field carries `no-intake`, `no-folder`, `no-cluster`, `no-item`, `answered`, or `bad-input`.
 
+An exit code says nothing about a call made from a session, since a shell profile may wrap the binary in a function taking its status from a later command. Read the record's `reason` rather than the exit when a skill consumes this, which matters most here because the verb writes.
+
 `bad-input` covers a malformed command line: no cluster, no selection, a selection that parses to no label and answer, an empty answer, an answer carrying a line break, or two answers for one item. It is separate from the reasons describing the folder, so a caller that mistyped a flag is not sent to repair a file that is fine.
 
 An empty answer refuses rather than writing an empty slot. The slot means unread while it is empty, so writing one back would report an item as answered that nobody decided.

package/docs/agents/markdown-audit.md

@@ -27,7 +27,9 @@ A bare run measures every markdown file git lists, tracked plus untracked-and-no
 
 ## Where the rules come from
 
-The three ban sets and all six checkpoints ship with the `aitk` package as data, in `src/markdown/bans.ts` and `src/markdown/structure.ts`. Every project is measured against the same sets whether or not it installed any standards, and no file has to resolve for a run to mean something.
+The three ban sets and all nine checkpoints ship with the `aitk` package as data, in `src/markdown/bans.ts` and `src/markdown/structure.ts`. Every project is measured against the same sets whether or not it installed any standards, and no file has to resolve for a run to mean something.
+
+Six of the nine are stated in `markdown.md` and the three cadence numbers are stated in the `write-human` skill. That split is the content boundary rather than an accident: `markdown.md` carries the enforced rules a scan can decide, and the skill carries the rhythm rules a ban list cannot express. A cadence number moved in the skill and left in the code drifts the same way, so move both.
 
 Reading them out of the standards per run was the original design. It put a parser contract on a document authored for people, and the standard had to carry a paragraph of its own warning an author that a one-word backticked example in a `- Do not use ` bullet would be lifted into a literal ban set and ban that word everywhere. A rule existing to protect a parser from the prose it parses is the argument for separating them.
 
@@ -98,9 +100,29 @@ That re-sample ran once the scan stopped counting link syntax as prose. Findings
 
 A bullet, a heading, a table row, a blockquote, a blank line, and a fence each end a paragraph, so a heavy bullet is reported by the bullet check alone and never counted twice.
 
+### Cadence
+
+Uniform cadence is the failure a ban list cannot express. A ban set states negatives, and fragments, verbless clauses, and sentences that all run one length are each the absence of something, so no addition to the thirteen banned words reaches any of them. The shape layer already measured a bullet, a paragraph, and a run, and stopped one level above where that failure lives.
+
+Cadence measures a paragraph on two numbers. The spread is the words between its longest and shortest sentence, and the opener count is the times one word opens a sentence in it. A spread of five words or under reads as one cadence, and a word opening more than two sentences is a pattern rather than a coincidence. Both come from `## Rhythm` in the `write-human` skill, which states them about prose a person reads, and this measures against that statement rather than setting a threshold of its own.
+
+Words are counted off the text a reader is shown. A link contributes its anchor text, an autolink contributes nothing, and the sentence boundaries do not move under that masking, since the boundary pattern requires whitespace after the terminal punctuation and no destination carries any. An opening word is lowercased and stripped of punctuation, so a sentence opening on a backticked command name reports the command.
+
+A paragraph carrying fewer than three sentences is skipped rather than scored. A two-sentence configuration note has no spread worth reading, and the opener rule is written about a third sentence turning a coincidence into a pattern, so neither number says anything before the floor. That is the cheap form of a wider exemption: a shape-aware one, exempting a short reference block by what it is rather than by how many sentences it holds, waits on a second case.
+
+The unit is the paragraph and each file names its worst on each measure, which follows the depth check rather than setting a precedent. A file's flattest paragraph and its most repetitive one are named only when each crosses its checkpoint, so a file reading healthy names nothing rather than offering its least healthy paragraph as a finding.
+
+Neither number gates and neither names a file wrong. This is a weaker claim than the one the weight checkpoints make, because a healthy range differs by surface: a catalog entry is several short sentences carrying one fact each, and a page arguing a decision is not, so one range applied across the corpus would report the surfaces that are correct. The run therefore states where the numbers came from beside them, and the counts are what a reader compares against.
+
+Measured at `6c273324` across the corpus, 2119 paragraphs reached the floor, 165 sat at or under the spread checkpoint and 50 past the opener checkpoint. Over the 60 files carrying at least ten measured paragraphs the flat rate runs from zero to 21 percent with a median near 6, which is the spread that makes the measure worth reading. Two wiki pages sit at either end of it: a server catalog reports 19 percent, its flattest paragraph five sentences within four words of each other and three of them verbless, while a page arguing where the prose rules came from reports none.
+
+That reading travels with the command rather than staying here. `BASELINE` in `src/markdown/structure.ts` carries the overall share, the per-file range, and the ten-paragraph floor beneath which a file's own rate says nothing, and the run prints all four in the legend beside the rate it measured. A count with no range beside it reads as a finding, and naming that a healthy range differs by surface states that a range exists rather than what it looks like. This page is toolkit-internal, so a reader running the command in a project that installed no standards would otherwise have two counts and nothing to place them against.
+
+Two of the rules `write-human` states are deliberately not implemented. A sentence's grammatical shape and whether it carries a finite verb each need a parse rather than a match, and an imperative or a heading fragment would read as a defect under a pattern that approximated either. The verbless share is the measure closest to the reported symptom, which is exactly why shipping it wrong would discredit the two that hold. It ships when something can identify a finite verb rather than guess at one.
+
 ## Exit codes
 
-Exit codes are `0` for a completed run with no gating finding, `1` for a refusal, `2` for a ban hit, and `3` for a shipped ban set that arrived empty. A banned character, word, or spelling fails the run. Bullet, paragraph, and depth weight are judgments a reader settles, so all three report under every code.
+Exit codes are `0` for a completed run with no gating finding, `1` for a refusal, `2` for a ban hit, and `3` for a shipped ban set that arrived empty. A banned character, word, or spelling fails the run. Bullet, paragraph, and depth weight are judgments a reader settles, and cadence is a distribution whose healthy range moves with the surface, so all four report under every code.
 
 `3` is separate from `1` because the two want different responses from a caller. A refusal means no corpus was built, and the `Markdown bans` stage in `scripts/core/verify.sh` is right to warn and skip. An empty set means the corpus was walked and nothing was looked for, so that stage fails the push on `3` rather than skipping.
 

package/docs/agents/records.md

@@ -58,6 +58,8 @@ A section runs to the next marker-shaped line whatever it names, so a plan carry
 
 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.
 
+An exit code says nothing about a call made from a session, since a shell profile may wrap the binary in a function taking its status from a later command. Read the record's `findings` array and its `reason` rather than the exit when a skill consumes this.
+
 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.
 
 `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.

package/docs/agents/sessions.md

@@ -24,6 +24,8 @@ It reads and never writes. The question it answers is which session to address w
 
 Exit codes: `0` the roster was read, `1` refused. The refusal carries a `reason` of `no-registry` or `no-repository`.
 
+An exit code says nothing about a call made from a session, since a shell profile may wrap the binary in a function taking its status from a later command. Read the record's `reason` rather than the exit when a skill consumes this.
+
 ## Scope and count
 
 `--branch` scopes the match to the repository the command runs in, and refuses outside one. A branch name identifies a branch inside a repository and nothing across a machine, so an unscoped match reaches a session working in a different project, and `main` collides on every machine running two of them.

package/docs/agents/skills-audit.md

@@ -67,7 +67,11 @@ aitk claude skills drift 02d7b265 --json
 | -------- | ---------------------------------------------------------- |
 | `--json` | Add a machine-readable record on stdout, keeping the frame |
 
-A skill body enters a session once and stays. Re-invoking the skill replays the copy the session already holds rather than re-reading the file, so a session that outlives a merge touching a body it loaded keeps applying what it loaded and nothing compares the two. A compaction carries the held copy forward with the summary it writes, which makes the exposure the age of the oldest load rather than the age of the session.
+A skill body enters a session once and stays. Re-invoking the skill does not re-read the file, so an edit made this session is not picked up and nothing compares the two. A session that outlives a merge touching a body it loaded keeps applying what it loaded, and a compaction carries the held copy forward with the summary it writes, which makes that exposure the age of the oldest load rather than the age of the session.
+
+Age is one route and not the only one. A session that edits a body and then invokes that same skill later in the same run replays the pre-edit text, which is what a ship chain does whenever a branch touches a body the chain runs at the end. This verb does not reach that route, because it reads history and the edit is still uncommitted when the replay happens. Re-read a body after editing it, and do not wait for a report to name it.
+
+Which shape the staleness takes decides whether anyone notices. A held body naming a file the branch deleted fails loudly by having nothing to read. One naming a file that still exists while saying something different resolves and reads current, so the session applies the stale rule and reports success.
 
 The ref is required and carries no default. `HEAD` is the only value the command could supply for itself, and it answers every run with nothing moved, which is the silence this verb exists to break. A session passes the commit it started from.
 
@@ -83,6 +87,8 @@ The report names the newest commit that rewrote each body rather than the first,
 
 The report says a file moved, not that a session holds a stale copy. A session cannot read its own loaded body as bytes, so the comparison runs against history and a ref older than the oldest load over-reports. That is the safe direction, since confirming a name costs one read of the body while the failure being answered is silence. Every run states the bound, including the run that names nothing.
 
+The verb answers only when someone runs it, and a report read is not a report acted on. A session that sees a moved body in the result and does not re-read that body stands where it started. One session reached that outcome after running the verb at session start, then followed the held copy for the rest of the day.
+
 Two cases fall outside the range. An uncommitted edit in the working tree is not history yet, so a body changed and left unstaged reports as unmoved. A target project loads the plugin from a marketplace cache with no repository behind it, where the verb refuses and names the absent history rather than reporting a clean tree.
 
 Exit codes are `0` when history was read, whether or not a body moved, and `1` when the question could not be answered. An absent shipped corpus, an absent repository, and a ref matching no commit each refuse with their own reason on stderr. A command exiting zero on a question it never answered is the failure `.claude/ARCHITECTURE.md` already records against two skills, which is why no path here reports an empty result in place of a refusal.

package/docs/operating-model.md

@@ -40,7 +40,7 @@ One feature travels this path end to end.
 2. Orchestrator plans the next feature with `claude-feature`, writing a plan to `.claude/plans/`. Planning stays in the warm session because good planning is cross-feature. It needs the contract other features consume and the shared wiring seam. A cold session would re-derive or guess.
 3. The human opens a worker worktree with `claude-worktree` and runs `claude-autoship` against the plan. The worker builds, self-checks, opens a PR, and stops at the PR boundary.
 4. Orchestrator reviews the PR with `claude-pr-review` and posts findings to it.
-5. Orchestrator tells the session holding that branch to run `claude-address-review` once the pass posted a finding at any severity, resolving the target from a session listing taken at that moment and reporting the invocation for the human when no live session holds it. The worker addresses the findings, rebases onto `origin/main` when a sibling landed first and left the branch unable to merge, then pushes a follow-up. A pass carrying only minor findings dispatches too, since the grade runs low often enough that a floor at should-fix loses fixes a worker would have made. `claude-pr-review` states that threshold and the heading follows it, so an open heading is itself the signal to send.
+5. Orchestrator tells the session holding that branch to run `claude-address-review` once the pass posted a finding at any severity, resolving the target then with `aitk sessions list --branch` and reporting the invocation for the human when no live session holds it. The worker addresses the findings, rebases onto `origin/main` when a sibling landed first and left the branch unable to merge, then pushes a follow-up. A pass carrying only minor findings dispatches too, since the grade runs low often enough that a floor at should-fix loses fixes a worker would have made. `claude-pr-review` states that threshold and the heading follows it, so an open heading is itself the signal to send.
 6. Orchestrator closes the review out with `claude-pr-review` again. The second pass reads only the commits the follow-up added, or the worker's response alone when the follow-up added none, and posts under `## Review` when it finds anything and under `## Review closed` when it finds nothing, so a reader learns from the heading whether work is still owed and takes the merge decision from the counts on the line under it. Repeat from step 5 until a pass closes the review.
 7. The human reads the result and merges. The orchestrator tells any trailing worker whose branch shares a seam with the merged one to run `claude-address-review`, which rebases whether or not the review left anything open.
 

package/governance/rules/claude/570-skill.md

@@ -13,6 +13,11 @@ paths:
 
 - Read the skill's sibling `REQUIREMENT.md` when one exists. If the change closes no gap it states, change the requirement first or drop the change.
 
+## After editing
+
+- Re-read a skill body this session edited before invoking that skill again in the same session
+- Do not read a resolved file path in a held body as evidence the body is current
+
 ## Authority
 
 - Follow `.claude/standards/skill.md` for skill structure, frontmatter fields, invocation rules, and the shape a `REQUIREMENT.md` states. It is the single source.

package/package.json

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

package/src/commands/context.ts

@@ -503,7 +503,7 @@ function readCause(cause: LengthCause): string {
   if (cause.state === 'unanswered') return `${label}: open`
   if (cause.state === 'no') return `${label}: no`
 
-  return `${label}: yes, ${plural(cause.markers ?? 0, 'marker')}`
+  return `${label}: yes, ${plural(cause.markers ?? 0, 'change marker')}`
 }
 
 /**
@@ -534,7 +534,7 @@ function reportLength(over: readonly LengthFinding[]): void {
     'The checkpoint is not a cap. Each entry carries the three questions the standard asks past it, and the fix goes to whichever is true.',
   )
   logInfo(
-    'Own history is answered from the provenance markers below. The other two are judgments no measure settles, so they stay open for a reader.',
+    'Own history is answered from the change markers below. A date stamping a measurement is not one of them, so an entry recording what its runs cost answers no. The other two are judgments no measure settles, so they stay open for a reader.',
   )
   pipeOutput(
     over
@@ -595,7 +595,9 @@ function reportProvenance(
   logInfo(
     `Covers .claude/${PROVENANCE_FOLDER}/ alone, whose standard carries the rule. The sibling standards do not restate it.`,
   )
-  logInfo('Fenced blocks are excluded. A marker is a judgment, never a defect.')
+  logInfo(
+    'Fenced blocks are excluded, and so is a date whose clause stamps a measurement. A marker is a judgment, never a defect.',
+  )
 
   const carrying = entries
     .filter((entry) => entry.provenance.length > 0)

package/src/commands/markdown.ts

@@ -11,6 +11,7 @@ import {
   scanBans,
 } from '@/markdown/scan'
 import {
+  BASELINE,
   CHECKPOINTS,
   type Checkpoints,
   measureStructure,
@@ -58,7 +59,7 @@ export function register(program: Command): void {
   markdown
     .command('audit')
     .description(
-      'Fail on a banned character, word, or spelling, and report bullet, paragraph, and depth weight',
+      'Fail on a banned character, word, or spelling, and report bullet, paragraph, cadence, and depth',
     )
     .argument(
       '[path...]',
@@ -80,6 +81,10 @@ export function register(program: Command): void {
         'depth weight are judgments a reader settles, so all three report and',
         'none of them fails a run.',
         '',
+        'Cadence reports the same way and carries one more caveat. Its range is',
+        'drawn from prose a person reads, so terse reference prose sits below',
+        'it correctly and a flat paragraph there is not a defect.',
+        '',
         'Rewrite the sentence carrying a hit rather than swapping the token for',
         'a near-synonym. A code span clears the report and is the answer only',
         'where the token is genuinely an identifier under discussion, which is',
@@ -146,6 +151,7 @@ async function runAudit(
   reportBans(reports, bans, empty)
   reportBullets(reports, checkpoints)
   reportParagraphs(reports, checkpoints)
+  reportCadence(reports, checkpoints)
   reportDepth(reports, checkpoints)
   outro()
 
@@ -168,6 +174,9 @@ async function runAudit(
           paragraph: checkpoints.paragraph,
           sentences: checkpoints.sentences,
           renderWidth: checkpoints.renderWidth,
+          cadence: checkpoints.cadence,
+          spread: checkpoints.spread,
+          opener: checkpoints.opener,
         },
         entries: reports.map((report) => ({
           path: report.rel,
@@ -176,6 +185,7 @@ async function runAudit(
           longestRunLine: report.structure.longestRunLine,
           heavyBullets: report.structure.heavyBullets,
           heavyParagraphs: report.structure.heavyParagraphs,
+          cadence: report.structure.cadence,
         })),
       })}\n`,
     )
@@ -377,6 +387,99 @@ function reportParagraphs(
   )
 }
 
+/**
+ * Reports the distribution rather than a verdict, which is what separates this
+ * step from the three above it.
+ *
+ * Bullet, paragraph, and depth weight each report a count against a checkpoint
+ * a reader settles. Cadence reports a count as well, and the range behind it is
+ * drawn from one surface class rather than from the corpus, so the step states
+ * where the numbers came from beside them. A reader whose file is terse
+ * reference prose is meant to read a flat paragraph as correct, and a number
+ * printed with no comparison beside it reads as a finding whatever the step is
+ * called.
+ */
+function reportCadence(
+  reports: readonly FileReport[],
+  checkpoints: Checkpoints,
+): void {
+  logStep('Cadence')
+  logInfo(
+    `Paragraphs of ${checkpoints.cadence} sentences or more measure the words between their longest and shortest sentence, and the times one word opens a sentence.`,
+  )
+  logInfo(
+    `A spread of ${checkpoints.spread} words or under reads as one cadence, and a word opening more than ${checkpoints.opener} sentences is a pattern rather than a coincidence.`,
+  )
+  logInfo(
+    'Both numbers are stated under Rhythm in the write-human skill, which writes them about prose a person reads.',
+  )
+  logInfo(
+    'A shorter paragraph stays unmeasured, since a two-sentence note carries no spread worth reading.',
+  )
+  logInfo(
+    'A healthy range differs by surface, so neither number gates and neither names a file wrong. Terse reference prose sits below the range a page written for a reader sits in.',
+  )
+  logInfo(
+    `The corpus these numbers were read against measured ${BASELINE.flatShare} percent flat overall, and its files carrying ${BASELINE.floor} or more measured paragraphs ran from ${BASELINE.low} to ${BASELINE.high} percent with a median near ${BASELINE.median}. Compare a rate against that rather than against zero.`,
+  )
+
+  const measured = reports.reduce(
+    (sum, report) => sum + report.structure.cadence.measured,
+    0,
+  )
+
+  if (measured === 0) {
+    logInfo(
+      `No paragraph reached ${checkpoints.cadence} sentences, so nothing was measured.`,
+    )
+    return
+  }
+
+  const flat = reports.reduce(
+    (sum, report) => sum + report.structure.cadence.flat,
+    0,
+  )
+  const repeating = reports.reduce(
+    (sum, report) => sum + report.structure.cadence.repeating,
+    0,
+  )
+
+  logInfo(
+    `${plural(measured, 'paragraph')} measured, ${flat} at or under the spread checkpoint (${Math.round((flat / measured) * 100)} percent) and ${repeating} past the opener checkpoint.`,
+  )
+
+  const carrying = reports
+    .filter(
+      (report) =>
+        report.structure.cadence.flattest ||
+        report.structure.cadence.mostRepeated,
+    )
+    .sort(
+      (a, b) =>
+        b.structure.cadence.flat +
+        b.structure.cadence.repeating -
+        (a.structure.cadence.flat + a.structure.cadence.repeating),
+    )
+
+  if (carrying.length === 0) return
+
+  pipeOutput(
+    carrying
+      .map((report) => {
+        const { flattest, mostRepeated } = report.structure.cadence
+        const lines = [
+          flattest &&
+            `  :${flattest.line}  ${plural(flattest.sentences, 'sentence')}, spread ${plural(flattest.spread, 'word')}`,
+          mostRepeated &&
+            `  :${mostRepeated.line}  ${plural(mostRepeated.sentences, 'sentence')}, "${mostRepeated.opener}" opens ${mostRepeated.repeats}`,
+        ].filter(Boolean)
+
+        return `${report.rel}\n${lines.join('\n')}`
+      })
+      .join('\n'),
+  )
+}
+
 /**
  * Names the render width and the blank-line convention on every run.
  *

package/src/context/audit.ts

@@ -60,13 +60,59 @@ const INSIDE_LIST = /^\s+\S/
  * when it records the second: when a change landed, which change carried it,
  * and which release labelled it. A marker is a judgment rather than a defect,
  * so this is measured and reported and never gates.
+ *
+ * The release pattern accepts three segments without a leading `v`, since the
+ * standard cuts a release label rather than a spelling of one and `a CLI at
+ * 0.83.0` names a release exactly as `v0.83.0` does. Two segments still require
+ * the `v`, because an unprefixed pair is a dollar cost or a duration far more
+ * often than a release in a corpus that records what its own runs cost. What
+ * the widening reaches by accident is another tool's version, which the
+ * standard asks nobody to cut, and those report rather than being excluded:
+ * an exclusion keyed on a nearby tool name goes stale with nothing saying so.
  */
 const PROVENANCE: readonly { kind: ProvenanceKind; pattern: RegExp }[] = [
   { kind: 'date', pattern: /\b\d{4}-\d{2}-\d{2}\b/g },
   { kind: 'change', pattern: /#\d{3,}\b/g },
-  { kind: 'release', pattern: /\bv\d+\.\d+(?:\.\d+)?\b/g },
+  { kind: 'release', pattern: /\b(?:v\d+\.\d+(?:\.\d+)?|\d+\.\d+\.\d+)\b/g },
 ]
 
+/**
+ * Verbs that read the date behind them as stamping a measurement.
+ *
+ * `standards/context.md` cuts a date attached to a change and permits one
+ * stamping a measurement, so a pattern matching every ISO date reports against
+ * a rule that admits half of what it finds. Separating the two needs the clause
+ * rather than the token, since `measured on 2026-08-19` and `overturned on
+ * 2026-08-19` differ only in the verb.
+ *
+ * These five are unambiguous wherever they appear in the clause, which is what
+ * lets them match at any distance from the date. `Measured across the corpus on
+ * 2026-08-14` puts four words between the two, and no line in the corpus uses
+ * any of them as a noun a change date could attach to.
+ *
+ * The set is closed and drawn from what the corpus already writes, so a
+ * phrasing nobody enumerated goes unmatched. That direction is the safe one: an
+ * unmatched date falls back to the change marker it is today, which reports one
+ * date too many rather than clearing one the standard cuts. Widening the set is
+ * how a missed phrasing is fixed, and a date the clause cannot place is never a
+ * third state, because the length finding already spends `unanswered` on the
+ * two questions nothing measures at all.
+ */
+const STAMPING = /\b(?:measured|verified|driven|passed|fired)\b/i
+
+/**
+ * The noun form, which has to sit against the date to count.
+ *
+ * `A run on 2026-08-14` stamps a measurement and `Runs on #632 and #634 landed
+ * 2026-08-02` dates a change, and the two differ only in what follows the noun.
+ * Requiring the connector and then the date immediately is what separates them,
+ * so this is anchored to the end of the clause where `STAMPING` is not.
+ */
+const STAMPING_RUN = /\b(?:an?\s+)?runs?\s+(?:on|at|in)\s+$/i
+
+/** Sentence boundary, so a clause is read rather than the whole line. */
+const SENTENCE_END = /[.!?:;]\s(?=[^.!?:;]*$)/
+
 /**
  * The folder whose standard carries the exclusion above.
  *
@@ -200,9 +246,11 @@ export interface LengthCause {
   readonly question: LengthQuestion
   readonly state: QuestionState
   /**
-   * Markers behind a `yes`, and absent wherever nothing was counted. It cites
-   * the provenance finding rather than restating it, so the two sections of the
-   * report describe the same measurement once.
+   * Change markers behind a `yes`, and absent wherever nothing was counted. It
+   * cites the provenance finding rather than restating it, so the two sections
+   * of the report describe the same measurement once. A date stamping a
+   * measurement never reaches that list, so an entry whose only dates are
+   * measurement anchors answers `no` here.
    */
   readonly markers?: number
 }
@@ -284,6 +332,12 @@ function catalogTables(entry: readonly BodyLine[]): TableFinding[] {
  * sample command or a fixture inside an example is content the entry displays
  * rather than a claim it makes, and a version pinned in an install line is the
  * ordinary shape of one.
+ *
+ * A date stamping a measurement is dropped rather than reported under a kind of
+ * its own. One list with one meaning is what lets every consumer read it
+ * without filtering: the report names what the standard cuts, and the length
+ * finding counts the same thing. A separate kind would put the split in three
+ * places and leave each free to read it differently.
  */
 function provenance(lines: readonly BodyLine[]): ProvenanceFinding[] {
   // Scanning one pattern at a time emits a line's markers grouped by kind, so
@@ -297,6 +351,10 @@ function provenance(lines: readonly BodyLine[]): ProvenanceFinding[] {
 
     for (const { kind, pattern } of PROVENANCE) {
       for (const match of line.text.matchAll(pattern)) {
+        if (kind === 'date' && stampsMeasurement(line.text, match.index)) {
+          continue
+        }
+
         found.push({
           finding: { line: line.number, kind, text: match[0] },
           column: match.index,
@@ -310,6 +368,23 @@ function provenance(lines: readonly BodyLine[]): ProvenanceFinding[] {
     .map((each) => each.finding)
 }
 
+/**
+ * Reads the clause in front of a date for a verb that stamps a measurement.
+ *
+ * The clause rather than the line, because a sentence recording a measurement
+ * and a later one dating a change sit side by side often enough that a
+ * line-wide read would clear the second from the first. A date opening its own
+ * line has no clause in front of it and stays a change marker, which is the
+ * fallback rather than a separate answer.
+ */
+function stampsMeasurement(text: string, index: number): boolean {
+  const before = text.slice(0, index)
+  const boundary = before.search(SENTENCE_END)
+  const clause = boundary === -1 ? before : before.slice(boundary + 1)
+
+  return STAMPING.test(clause) || STAMPING_RUN.test(clause)
+}
+
 function escape(term: string): string {
   return term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
@@ -536,10 +611,13 @@ export function measureEntry(
  * answered as far as anything measures them.
  *
  * Only accumulated history is mechanical, and it is already measured by the
- * provenance check, so this joins that count rather than counting again. The
- * other two are read by a person: whether an entry still covers one domain is a
- * judgment about its subject, and recognizing content `ls` or `--help`
- * reproduces needs a reader who knows what those emit.
+ * provenance check, so this joins that count rather than counting again. What
+ * it joins is a count of change markers, since a date stamping a measurement is
+ * not one and an entry recording what its runs cost would otherwise report
+ * accumulated history on the anchors dating those runs. The other two are read
+ * by a person: whether an entry still covers one domain is a judgment about its
+ * subject, and recognizing content `ls` or `--help` reproduces needs a reader
+ * who knows what those emit.
  *
  * An entry outside the governed folder has no measured question at all, since
  * provenance is scoped to the standard stating it, and reporting `no` there

package/src/markdown/structure.ts

@@ -33,6 +33,14 @@ const SENTENCE_END = /[.!?]["'’”)\]]*(?=\s+(?:["'“(\[]*[A-Z]|`)|\s*$)/g
  * degraded a number and the report had to carry a legend saying which one. The
  * standard still states every number for a reader, and moving one is an edit to
  * both.
+ *
+ * The last three come from the `## Rhythm` section of the `write-human` skill
+ * rather than from a standard. That skill states what good rhythm is and this
+ * measures against the statement, so the numbers are read off the sentences
+ * that already carry them: a longest and shortest sentence within roughly five
+ * words of each other is one cadence, an opening word repeating twice is
+ * coincidence and three times is a pattern, and both rules are written about a
+ * paragraph, which needs a third sentence before either says anything.
  */
 export const CHECKPOINTS = {
   run: 40,
@@ -41,6 +49,37 @@ export const CHECKPOINTS = {
   paragraph: 700,
   sentences: 4,
   renderWidth: 80,
+  cadence: 3,
+  spread: 5,
+  opener: 2,
+} as const
+
+/**
+ * The reading a cadence rate is compared against, rather than a checkpoint.
+ *
+ * A count with nothing beside it reads as a finding, and the two counts the
+ * cadence step reports have no range a reader can place them in: twelve flat
+ * paragraphs out of forty says the same as two without one. Naming that a
+ * healthy range differs by surface states that a range exists rather than what
+ * it looks like, so the reading travels with the command.
+ *
+ * This is an observation rather than a rule, which is why it sits apart from
+ * `CHECKPOINTS`. Nothing compares a run against it and no exit code reads it. A
+ * project whose corpus is entirely terse reference prose is expected to sit
+ * above the high end, and that is the measure working.
+ *
+ * Read across 483 markdown files at `6c273324` on 2026-08-20. A number here
+ * goes stale against the corpus it describes with nothing comparing the two, so
+ * re-measure before moving one.
+ */
+export const BASELINE = {
+  /** Share of every measured paragraph sitting at or under the spread checkpoint. */
+  flatShare: 8,
+  /** Measured paragraphs a file needs before its own rate means anything. */
+  floor: 10,
+  low: 0,
+  median: 6,
+  high: 21,
 } as const
 
 /**
@@ -58,6 +97,12 @@ export interface Checkpoints {
   readonly paragraph: number
   readonly sentences: number
   readonly renderWidth: number
+  /** Sentences a paragraph needs before its cadence is measured at all. */
+  readonly cadence: number
+  /** Words between the longest and shortest sentence, at or under which the paragraph reads as one cadence. */
+  readonly spread: number
+  /** Times one opening word may open a sentence in a paragraph before it is a pattern. */
+  readonly opener: number
 }
 
 export interface BulletFinding {
@@ -72,6 +117,47 @@ export interface ParagraphFinding {
   readonly characters: number
 }
 
+/**
+ * One measured paragraph, carrying both cadence numbers rather than one.
+ *
+ * A paragraph reported for a narrow spread is usually worth reading for its
+ * openers too, and splitting the two into separate finding types would name the
+ * same line twice with half the picture on each.
+ */
+export interface CadenceFinding {
+  readonly line: number
+  readonly sentences: number
+  /** Words between the longest and shortest sentence. */
+  readonly spread: number
+  /** Times the most repeated opening word opens a sentence here. */
+  readonly repeats: number
+  /** The opening word behind `repeats`, lowercased and stripped of punctuation. */
+  readonly opener: string
+}
+
+/**
+ * A file's cadence distribution, reported rather than listed finding by finding.
+ *
+ * Both numbers are advisory in a way even the weight checkpoints are not. A
+ * healthy range differs by surface, so terse reference prose and a page written
+ * for a reader sit at different spreads and one range applied across the corpus
+ * would report the surfaces that are correct. The counts are what a reader
+ * compares against the stated range, and the two worst paragraphs are where
+ * they open the file.
+ */
+export interface CadenceReport {
+  /** Paragraphs carrying at least the floor sentence count. */
+  readonly measured: number
+  /** Measured paragraphs at or under the spread checkpoint. */
+  readonly flat: number
+  /** Measured paragraphs past the opener checkpoint. */
+  readonly repeating: number
+  /** Narrowest paragraph among the flat ones, or undefined when none is flat. */
+  readonly flattest: CadenceFinding | undefined
+  /** Most repetitive paragraph among the repeating ones, or undefined when none repeats. */
+  readonly mostRepeated: CadenceFinding | undefined
+}
+
 export interface StructureReport {
   readonly rel: string
   /** Rendered lines at the render width, not source lines. */
@@ -80,6 +166,7 @@ export interface StructureReport {
   readonly longestRunLine: number
   readonly heavyBullets: readonly BulletFinding[]
   readonly heavyParagraphs: readonly ParagraphFinding[]
+  readonly cadence: CadenceReport
 }
 
 /**
@@ -275,48 +362,46 @@ export function heavyBullets(
   return findings
 }
 
+/**
+ * Splits a paragraph into the sentences terminal punctuation closes.
+ *
+ * A trailing span no punctuation closes is dropped rather than returned, which
+ * keeps this and the count below one definition. The pattern already matches a
+ * paragraph's final period through its end-of-text alternative, so the only
+ * span this drops is a paragraph genuinely ending without terminal punctuation,
+ * which is a fragment rather than a sentence to either measure.
+ */
+function splitSentences(text: string): string[] {
+  const sentences: string[] = []
+  let start = 0
+
+  for (const match of text.matchAll(SENTENCE_END)) {
+    const end = match.index + match[0].length
+    sentences.push(text.slice(start, end).trim())
+    start = end
+  }
+
+  return sentences
+}
+
 function countSentences(text: string): number {
-  return [...text.matchAll(SENTENCE_END)].length
+  return splitSentences(text).length
 }
 
 /**
- * Finds the prose paragraphs past either half of the standard's checkpoint.
+ * Splits the body into its prose paragraphs, each a run of consecutive lines.
  *
- * Both halves are stated in the standard and both are read from it. The weight
- * half was added there rather than borrowed from the bullet checkpoint, which
- * governs a different construct: one number feeding both would move the
- * paragraph rule whenever the bullet rule was changed, and an author reading
- * the sentence cap would find no weight rule to read at all.
- *
- * The two numbers coincide today because paragraph and bullet weight measure
- * one population, sharing a median near 170 characters with no gap behind
- * either candidate. They are separate checkpoints regardless, so either moves
- * without dragging the other.
- *
- * A paragraph is a run of consecutive prose lines. A heading, a list item, a
- * table row, a blockquote, a blank line, and a fence each end one, so a bullet
- * is measured by `heavyBullets` alone and never twice.
+ * A heading, a list item, a table row, a blockquote, a blank line, and a fence
+ * each end one, so a bullet is measured by `heavyBullets` alone and never
+ * twice. Both paragraph measures walk this rather than one each, since two
+ * walks deciding what a paragraph is would drift apart.
  */
-export function heavyParagraphs(
-  lines: readonly BodyLine[],
-  checkpoints: Checkpoints,
-): ParagraphFinding[] {
-  const findings: ParagraphFinding[] = []
+function paragraphBlocks(lines: readonly BodyLine[]): BodyLine[][] {
+  const blocks: BodyLine[][] = []
   let block: BodyLine[] = []
 
   const close = (): void => {
-    if (block.length > 0) {
-      const text = block.map((line) => line.text.trim()).join(' ')
-      const sentences = countSentences(text)
-      const characters = visibleText(text).length
-
-      if (
-        sentences > checkpoints.sentences ||
-        characters > checkpoints.paragraph
-      ) {
-        findings.push({ line: block[0].number, sentences, characters })
-      }
-    }
+    if (block.length > 0) blocks.push(block)
     block = []
   }
 
@@ -340,9 +425,168 @@ export function heavyParagraphs(
 
   close()
 
+  return blocks
+}
+
+/** Folds a paragraph's source lines into the one line they would have wrapped from. */
+function paragraphText(block: readonly BodyLine[]): string {
+  return block.map((line) => line.text.trim()).join(' ')
+}
+
+/**
+ * Finds the prose paragraphs past either half of the standard's checkpoint.
+ *
+ * Both halves are stated in the standard and both are read from it. The weight
+ * half was added there rather than borrowed from the bullet checkpoint, which
+ * governs a different construct: one number feeding both would move the
+ * paragraph rule whenever the bullet rule was changed, and an author reading
+ * the sentence cap would find no weight rule to read at all.
+ *
+ * The two numbers coincide today because paragraph and bullet weight measure
+ * one population, sharing a median near 170 characters with no gap behind
+ * either candidate. They are separate checkpoints regardless, so either moves
+ * without dragging the other.
+ */
+export function heavyParagraphs(
+  lines: readonly BodyLine[],
+  checkpoints: Checkpoints,
+): ParagraphFinding[] {
+  const findings: ParagraphFinding[] = []
+
+  for (const block of paragraphBlocks(lines)) {
+    const text = paragraphText(block)
+    const sentences = countSentences(text)
+    const characters = visibleText(text).length
+
+    if (
+      sentences > checkpoints.sentences ||
+      characters > checkpoints.paragraph
+    ) {
+      findings.push({ line: block[0].number, sentences, characters })
+    }
+  }
+
   return findings
 }
 
+/** Punctuation either side of a word, so an opener is compared on its letters. */
+const WORD_EDGE = /^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu
+
+/**
+ * The word a sentence opens on, lowercased and stripped of punctuation.
+ *
+ * A sentence opening on a code span yields the command inside it rather than a
+ * backtick, which is the word a reader hears. Casing is dropped because an
+ * opener repeating is a repetition whether or not one of the two sits mid-list
+ * and lost its capital.
+ */
+function openingWord(sentence: string): string {
+  const [first = ''] = sentence.split(/\s+/)
+  return first.replace(WORD_EDGE, '').toLowerCase()
+}
+
+/**
+ * Measures one paragraph's spread and its most repeated opener.
+ *
+ * Words are counted off the text a reader is shown, so a link contributes its
+ * anchor text and a destination contributes nothing. The sentence boundaries do
+ * not move with that masking, since the pattern requires whitespace after the
+ * terminal punctuation and no destination or autolink carries any.
+ */
+function measureParagraph(block: readonly BodyLine[]): CadenceFinding {
+  const sentences = splitSentences(visibleText(paragraphText(block)))
+  const lengths = sentences.map(
+    (sentence) => sentence.split(/\s+/).filter(Boolean).length,
+  )
+
+  const counts = new Map<string, number>()
+  for (const sentence of sentences) {
+    const word = openingWord(sentence)
+    if (word !== '') counts.set(word, (counts.get(word) ?? 0) + 1)
+  }
+
+  let opener = ''
+  let repeats = 0
+  for (const [word, count] of counts) {
+    if (count > repeats) {
+      opener = word
+      repeats = count
+    }
+  }
+
+  // A paragraph closing no sentence at all has no spread rather than a
+  // negative one, and the floor drops it before either number is read.
+  const spread =
+    lengths.length === 0 ? 0 : Math.max(...lengths) - Math.min(...lengths)
+
+  return {
+    line: block[0].number,
+    sentences: sentences.length,
+    spread,
+    repeats,
+    opener,
+  }
+}
+
+/**
+ * Reports how a file's prose is distributed across sentence length and opening
+ * word, which is the layer the ban sets cannot reach.
+ *
+ * A banned-word list expresses negatives and every symptom this answers is the
+ * absence of something, so no addition to that set catches a paragraph whose
+ * sentences are all one length. The measure stops at what is countable. A
+ * sentence's grammatical shape and whether it carries a finite verb are the two
+ * rules `write-human` states that this does not implement, because identifying
+ * either needs a parse rather than a match, and an imperative or a heading
+ * fragment would read as a defect. Reporting them wrong is worse than not
+ * reporting them, since they name the exact failure this exists to measure.
+ *
+ * A paragraph under the floor is skipped rather than scored. A two-sentence
+ * configuration note has no spread worth reading, and the opener rule is
+ * written about a third sentence turning a coincidence into a pattern, so
+ * neither measure says anything before the floor is reached.
+ */
+export function measureCadence(
+  lines: readonly BodyLine[],
+  checkpoints: Checkpoints,
+): CadenceReport {
+  const measured = paragraphBlocks(lines)
+    .map(measureParagraph)
+    .filter((finding) => finding.sentences >= checkpoints.cadence)
+
+  const flat = measured.filter(
+    (finding) => finding.spread <= checkpoints.spread,
+  )
+  const repeating = measured.filter(
+    (finding) => finding.repeats > checkpoints.opener,
+  )
+
+  return {
+    measured: measured.length,
+    flat: flat.length,
+    repeating: repeating.length,
+    flattest: worst(flat, (finding) => -finding.spread),
+    mostRepeated: worst(repeating, (finding) => finding.repeats),
+  }
+}
+
+/**
+ * The file's worst paragraph on one measure, earliest line breaking a tie.
+ *
+ * Only paragraphs already past their checkpoint are passed in, so a file
+ * reading healthy names nothing rather than naming its least healthy paragraph,
+ * which a reader would take for a finding.
+ */
+function worst(
+  findings: readonly CadenceFinding[],
+  rank: (finding: CadenceFinding) => number,
+): CadenceFinding | undefined {
+  return findings.reduce<CadenceFinding | undefined>(
+    (held, finding) => (!held || rank(finding) > rank(held) ? finding : held),
+    undefined,
+  )
+}
+
 export function measureStructure(
   rel: string,
   lines: readonly BodyLine[],
@@ -356,5 +600,6 @@ export function measureStructure(
     longestRunLine: run.line,
     heavyBullets: heavyBullets(lines, checkpoints),
     heavyParagraphs: heavyParagraphs(lines, checkpoints),
+    cadence: measureCadence(lines, checkpoints),
   }
 }

package/standards/session.md

@@ -57,7 +57,7 @@ Add a section only for content that fits none of the three and would otherwise b
 ## 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.
+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 does not re-read 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. Recording a name is not acting on it, and the verb misses a body this session edited and has not committed. 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.