@erclx/canon 5.55.0 → 5.56.0

package/docs/agents/markdown-audit.md

@@ -26,24 +26,31 @@ The ban set and checkpoints ship in `src/markdown/bans.ts` and `src/markdown/str
 | --------------- | ------------------------------------------------------------------------------------ | ----------------- |
 | Bans            | The two characters `markdown.md` bans, outside frontmatter, fences, spans, and links | Always            |
 | Links           | A relative link resolving to nothing on disk                                         | Always            |
-| Density         | The six limits below, under `density`                                                | On a gated prefix |
+| Density         | The six limits and two table limits below, under `density`                           | On a gated prefix |
 | Reference shape | A `kind: reference` page breaking its shape, under `referenceShape`                  | On a gated prefix |
-| Tables          | The four table limits below, under `tables`                                          | Never             |
+| Tables          | The row count and wide token limits below, under `tables`                            | Never             |
 | Colons          | A colon followed by more text in a prose line, under `colons`                        | Never             |
 | Heading case    | A capital after the first word of a heading or `title`, under `headingCase`          | Never             |
 
 A page marked `kind: reference` holds its opening, then `Output`, `Refusals`, and `See also` as H2s, each at most once and in that order. It takes no H3 and no table headed `Flag` or `Option`. An unmarked page is never measured.
 
-Tables take the four limits in the `markdown-craft` skill's `tables.md`, on the density paths but never `CLAUDE.md`. A cell past 120 visible characters reports as `table-cell`, more than 8 body rows as `table-rows`, a list after a table as `table-then-list`, and a code span with a run past 30 characters as `table-token`. None sets the exit code.
+Tables take the four limits in the `markdown-craft` skill's `tables.md`, on the density paths but never `CLAUDE.md`.
+
+- A cell past 120 visible characters reports as `table-cell` and a list after a table as `table-then-list`, both under `density`
+- More than 8 body rows reports as `table-rows` and a code span with a run past 30 characters as `table-token`, both under `tables` and neither setting the exit code
 
 | Density limit       | Finding                                                    |
 | ------------------- | ---------------------------------------------------------- |
 | Paragraph length    | A prose paragraph past 350 characters                      |
 | Paragraphs in a row | More than 2 paragraphs with nothing else between them      |
-| Bullet length       | A top-level bullet past 200 characters                     |
+| Bullet length       | A bullet past 200 characters, a nested one on its own      |
 | Bullets in a row    | More than 5 plain top-level bullets                        |
 | Heading depth       | Any heading past H3                                        |
 | H3 opening          | An H3 whose first block is neither a paragraph nor a table |
+| Table cell          | A table cell past 120 visible characters                   |
+| List after table    | A list as the block directly after a table                 |
+
+Five notes fix how the limits count and where they apply.
 
 - A paragraph under a list item counts toward that bullet, never as a paragraph
 - A table, fence, list, heading, or bold section marker ends a run of paragraphs

package/docs/agents/migrate.md

@@ -8,21 +8,23 @@ kind: reference
 
 `canon migrate <verb>` moves a project off a retired name or layout. Each verb reports its plan and writes nothing until `--write`, takes `--json`, and, except `rename`, takes `--root`. A second run rewrites nothing, which confirms the exclusions and markers fired.
 
-| Verb               | Moves                                                                                                                                       |
-| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------- |
-| `status`           | Nothing. It lists every migration the project still needs, in run order.                                                                    |
-| `rename`           | The retired `aitk` name. `--scope target` rewrites toolkit-owned folders only.                                                              |
-| `skill-names`      | Plugin skills off their `claude-` and `draft-` prefixes and other retired names, with every citation                                        |
-| `records`          | Session records from `.claude/` to `.canon/`, with every tracked citation                                                                   |
-| `surface-roots`    | `context/`, `wireframes/`, `ARCHITECTURE.md`, `REQUIREMENTS.md`, `DESIGN.md`, and the stamp folder from `.claude/` to `canon/`, by `git mv` |
-| `record-tree`      | Citations inside `.canon/` folders a session still follows: `diagrams`, `memory`, `plans`, `proposals`, `review`, `tasks`, `teach`          |
-| `rule-layout`      | A flat installed-rule layout onto the `canon/`-wrapped one                                                                                  |
-| `scratch-evidence` | A folder a durable record cites out of `.tmp/`, with its citations                                                                          |
-| `record-layout`    | Review receipts, memory archives, feedback, renders, picks, and evidence into their current folders                                         |
-| `session-defaults` | The seeded session defaults into an existing `.claude/settings.json`: `Agent`, `Task`, and both merge commands denied, auto memory off      |
+| Verb               | Moves                                                                                                           |
+| ------------------ | --------------------------------------------------------------------------------------------------------------- |
+| `status`           | Nothing. It lists every migration the project still needs, in run order.                                        |
+| `rename`           | The retired `aitk` name. `--scope target` rewrites toolkit-owned folders only.                                  |
+| `skill-names`      | Plugin skills off their `claude-` and `draft-` prefixes and other retired names, with every citation            |
+| `records`          | Session records from `.claude/` to `.canon/`, with every tracked citation                                       |
+| `surface-roots`    | Records such as `context/` and `REQUIREMENTS.md`, and the stamp folder, from `.claude/` to `canon/` by `git mv` |
+| `record-tree`      | Citations inside the `.canon/` folders a session still follows, listed below the table                          |
+| `rule-layout`      | A flat installed-rule layout onto the `canon/`-wrapped one                                                      |
+| `scratch-evidence` | A folder a durable record cites out of `.tmp/`, with its citations                                              |
+| `record-layout`    | Review receipts, memory archives, feedback, renders, picks, and evidence into their current folders             |
+| `session-defaults` | The seeded session defaults into an existing `.claude/settings.json`, listed below the table                    |
+
+`record-tree` follows citations in `diagrams`, `memory`, `plans`, `proposals`, `review`, `tasks`, and `teach`. `session-defaults` denies `Agent`, `Task`, and both merge commands, and turns auto memory off. The bullets below add detail per verb.
 
 - `skill-names` takes no `--scope`, and skips the changelog, eval transcripts, and the pointer each renamed `draft-` skill leaves at its old name
-- `surface-roots` leaves `rules/`, `skills/`, `hooks/`, and `settings.json` where Claude Code reads them
+- `surface-roots` moves `context/`, `wireframes/`, `ARCHITECTURE.md`, `REQUIREMENTS.md`, `DESIGN.md`, and the stamp folder, and leaves `rules/`, `skills/`, `hooks/`, and `settings.json` in place
 - `rule-layout` classifies each flat file against the stamp as clean, edited, or unclaimed. Clean and edited files move untouched, and an unclaimed name stays.
 - `record-layout` labels each evidence folder `(pick)` or `(evidence)` in the dry run
 - `session-defaults` adds a key only when absent, merge entries included, and each older project runs it once. `--write` restores a removed `Agent` or `Task` and never removes a deny entry.

package/docs/agents/output-shape.md

@@ -54,6 +54,8 @@ Discover names at runtime rather than hardcoding them.
 | `canon docs list --json`          | Consumer docs plus per-domain context                            |
 | `canon audits list --json`        | Audits the set runs, the corpus each reads, and whether it gates |
 
+The table names the verbs, and three notes cover what some of them carry.
+
 - `gov list` expands each stack to its rules and carries `unreferenced`, the rules no stack reaches, which install only through `--add`
 - `claude skills list` reports shipped skills only. Each carries `family` (or `null`) and `requirement`, and a `false` requirement is a gap to close. `--names` and `--by-family` change the render.
 - A skill with unparseable frontmatter returns an empty description rather than failing the listing

package/docs/target/migrations.md

@@ -62,19 +62,19 @@ The seven `draft-` skills took verb-first names for what each makes. `canon migr
 | `draft-ready`      | `plan-ready` <!-- canon-keep-retired -->        |
 | `draft-screencast` | `script-screencast` <!-- canon-keep-retired --> |
 
+Replace a citation of a skill with no successor by hand, or delete the sentence.
+
 - `canvas` is now `canvas-board`. The sweep rewrites only `canon:canvas` and `skills/canvas`, so replace a bare prose mention by hand. <!-- canon-keep-retired -->
 - `draft-ready` is rewritten only as `canon:draft-ready` and `skills/draft-ready`, since bare it also describes a pull request. Replace a bare mention of the skill by hand. <!-- canon-keep-retired -->
 - `design-extract` and `sketch-design` are replaced by `canon:canvas-board`. <!-- canon-keep-retired -->
 - `review-branch`, `seed-sync`, `restate-plainly`, `bash-cli-script`, `canon-operator`, and `canon-rollout` have no successor <!-- canon-keep-retired -->
 - `create-standard`, `markdown-propose`, `memory-review`, `project-commands`, `repo-metadata`, and `ux-walkthrough` have no successor <!-- canon-keep-retired -->
 
-Replace a citation of a skill with no successor by hand, or delete the sentence.
+The `memory` record kind left `canon records`, so `canon records validate memory` refuses as an unknown kind and `canon records migrate` is gone.
 
 - `canon repo metadata`, `canon autoship`, and the `120-bash` rule are gone, and `canon gov sync` removes the rule <!-- canon-keep-retired -->
 - `memory-capture`, the `603-memory` rule, and the `memory` standard are gone, so send a lesson to the context entry that owns the fact <!-- canon-keep-retired -->
 
-The `memory` record kind left `canon records`, so `canon records validate memory` refuses as an unknown kind and `canon records migrate` is gone.
-
 Two held files run, `.husky/post-merge` and `.claude/hooks/pr-create-log.sh`, and a stale copy calls a missing binary or names a removed skill. Resync what the toolkit owns before sweeping what the project wrote, and run the second line once per stack.
 
 ```bash

package/docs/workflow/operating-model.md

@@ -17,6 +17,8 @@ One warm session holds the cross-feature call and reviews. Cold worker sessions
 | Planner      | One session per row, warm or cold     | Measure the row against the tree, write one plan     | Enter a worktree, write the board  |
 | Worker       | One cold worktree session per feature | Implement, self-check, open PR, answer the reviewer  | Write the shared board, merge      |
 
+Each role keeps to its own writes, and five rules cover how the roles meet.
+
 - The orchestrator loads `role-orchestrator`, a worker loads `role-worker` through `auto-ship` Step 0, and a planner and a reviewer load theirs from the launch that dispatches them
 - The orchestrator decides which rows conflict, what merges first, and whether a row runs at all. Per-row planning can go cold.
 - A dispatched planner writes only the plan, and reports what the task file got wrong rather than repairing it

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@erclx/canon",
   "type": "module",
-  "version": "5.55.0",
+  "version": "5.56.0",
   "description": "Runs your agent's work and keeps its code good, on one setup for every repo.",
   "license": "MIT",
   "bin": {

package/src/commands/markdown.ts

@@ -141,9 +141,10 @@ export function register(program: Command): void {
         'Depth weight is a judgment a reader settles, so it reports and never',
         'fails a run.',
         '',
-        'Density holds six limits: a 350-character paragraph, 2 paragraphs in',
-        'a row, a 200-character bullet, 5 plain bullets in a row, no H4, and a',
-        'paragraph or table opening every H3. Only context, docs, skills, tooling',
+        'Density holds eight limits: a 350-character paragraph, 2 paragraphs in',
+        'a row, a 200-character bullet, 5 plain bullets in a row, no H4, a',
+        'paragraph or table opening every H3, a 120-character table cell, and no',
+        'list as the block after a table. Only context, docs, skills, tooling',
         'seeds and references, the wiki, README.md, and CONTRIBUTING.md take a',
         'finding. CLAUDE.md and its seed take only the bullet run and the H3',
         'opening, inside Key paths. In a canon checkout one gates under a',
@@ -154,10 +155,9 @@ export function register(program: Command): void {
         'and none gates.',
         'A config that does not parse refuses with its path named.',
         '',
-        'Tables take four limits on the same paths, CLAUDE.md aside: a',
-        '120-character cell, 8 body rows, a list as the next block, and a code',
-        'span with a run past 30 characters. A table finding reports and never',
-        'fails a run.',
+        'Tables take two more limits on the same paths, CLAUDE.md aside: 8 body',
+        'rows, and a code span with a run past 30 characters. Each reports and',
+        'never fails a run.',
         '',
         'A page whose frontmatter carries kind: reference takes the reference',
         'shape: no H2 beyond Output, Refusals, and See also, each at most once',
@@ -637,15 +637,19 @@ const DENSITY_LABELS: Record<DensityKind, string> = {
   'bullet-run': 'bullets in a row',
   'heading-depth': 'heading depth',
   'h3-opening': 'H3 opening',
+  'table-cell': 'cell length',
+  'table-then-list': 'list after table',
 }
 
 function describeDensity(finding: GatedDensityFinding): string {
   const measured =
     finding.kind === 'h3-opening'
       ? 'opens with neither a paragraph nor a table'
-      : finding.kind === 'heading-depth'
-        ? `H${finding.value} past H${finding.limit}`
-        : `${finding.value} past ${finding.limit}`
+      : finding.kind === 'table-then-list'
+        ? 'follows the table with no lead sentence'
+        : finding.kind === 'heading-depth'
+          ? `H${finding.value} past H${finding.limit}`
+          : `${finding.value} past ${finding.limit}`
   const gate = finding.gating ? '  gating' : ''
   return `  :${finding.line}  ${DENSITY_LABELS[finding.kind]}  ${measured}${gate}`
 }
@@ -662,10 +666,10 @@ function reportDensity(
 ): void {
   logStep('Density')
   logInfo(
-    `Paragraphs past ${CHECKPOINTS.paragraph} characters, more than 2 paragraphs in a row, bullets past ${CHECKPOINTS.bullet} characters, more than 5 plain bullets in a row, a heading past H3, and an H3 opening with neither a paragraph nor a table.`,
+    `Paragraphs past ${CHECKPOINTS.paragraph} characters, more than 2 paragraphs in a row, bullets past ${CHECKPOINTS.bullet} characters, more than 5 plain bullets in a row, a heading past H3, an H3 opening with neither a paragraph nor a table, a table cell past ${TABLE_CELL} characters, and a list directly after a table.`,
   )
   logInfo(
-    'Measured on context entries, docs, skill bodies, references, and requirements, tooling seeds and stack references, the wiki, README.md, and CONTRIBUTING.md. CLAUDE.md and its seed take the bullet run and the H3 opening inside Key paths alone. Every other path takes no density finding.',
+    'Measured on context entries, docs, skill bodies, references, and requirements, tooling seeds and stack references, the wiki, README.md, and CONTRIBUTING.md. CLAUDE.md and its seed take the bullet run and the H3 opening inside Key paths alone, with no table finding. Every other path takes no density finding.',
   )
   logInfo(densityGatingLine(gated, source))
 
@@ -689,7 +693,7 @@ function reportDensity(
   )
   if (gating > 0) logWarn('A gating finding fails the run.')
   logInfo(
-    'Split a long block at its seam, put a heading or a table between paragraphs, give a long list H3s, and open each H3 with a sentence or a table.',
+    'Split a long block at its seam, put a heading or a table between paragraphs, give a long list H3s, open each H3 with a sentence or a table, move a long cell into a bullet under the lead, and give a trailing list its own lead sentence.',
   )
   pipeOutput(
     carrying
@@ -718,29 +722,23 @@ function densityGatingLine(
 }
 
 const TABLE_LABELS: Record<TableKind, string> = {
-  'table-cell': 'cell length',
   'table-rows': 'rows',
-  'table-then-list': 'list after table',
   'table-token': 'wide token',
 }
 
 function describeTable(finding: TableFinding): string {
-  const measured =
-    finding.kind === 'table-then-list'
-      ? 'follows the table with no lead sentence'
-      : `${finding.value} past ${finding.limit}`
-  return `  :${finding.line}  ${TABLE_LABELS[finding.kind]}  ${measured}`
+  return `  :${finding.line}  ${TABLE_LABELS[finding.kind]}  ${finding.value} past ${finding.limit}`
 }
 
 /**
- * Lists every table finding on the density scope's paths. None gates yet,
- * since a gate is decided per path rather than per kind, and a new density
- * kind would fail every gated folder carrying a table hit at once.
+ * Lists the table findings that only report, on the density scope's paths. The
+ * cell and the trailing list gate as density kinds, so `reportDensity` lists
+ * them.
  */
 function reportTables(reports: readonly FileReport[]): void {
   logStep('Tables')
   logInfo(
-    `Cells past ${TABLE_CELL} characters, tables past ${TABLE_ROWS} body rows, a list directly after a table, and a code span in a cell holding a run past ${TABLE_TOKEN} characters.`,
+    `Tables past ${TABLE_ROWS} body rows and a code span in a cell holding a run past ${TABLE_TOKEN} characters.`,
   )
   logInfo(
     'Measured on the paths density measures in full, so never on CLAUDE.md, outside fenced blocks. This never fails a run.',
@@ -760,7 +758,7 @@ function reportTables(reports: readonly FileReport[]): void {
     `${plural(total, 'finding')} across ${plural(carrying.length, 'file')}`,
   )
   logInfo(
-    'Move a long cell into a bullet under the lead, split a long table into groups each under a lead sentence, give a trailing list its own lead, and move a wide token out of the table.',
+    'Split a long table into groups each under a lead sentence, and move a wide token out of the table.',
   )
   pipeOutput(
     carrying
@@ -917,11 +915,9 @@ function reportBullets(
 ): void {
   logStep('Bullets')
   logInfo(
-    'Top-level bullets measure characters, folding in continuation lines.',
-  )
-  logInfo(
-    'Nested items and fenced blocks are excluded. Weight is a judgment, never a defect.',
+    'Bullets measure characters, folding in continuation lines, and a nested bullet measures on its own.',
   )
+  logInfo('Fenced blocks are excluded. Weight is a judgment, never a defect.')
 
   const carrying = reports
     .filter((report) => report.structure.heavyBullets.length > 0)

package/src/labels/density.ts

@@ -1,10 +1,6 @@
-import {
-  type DensityFinding,
-  type DensityKind,
-  densityFindings,
-} from '@/markdown/density'
-import { type BodyLine, bodyLines, visibleText } from '@/markdown/scan'
-import { CHECKPOINTS, LIST_ITEM } from '@/markdown/structure'
+import { type DensityKind, densityFindings } from '@/markdown/density'
+import { type BodyLine, bodyLines } from '@/markdown/scan'
+import { LIST_ITEM } from '@/markdown/structure'
 
 /**
  * The four counted limits a pull request section carries. The heading limits
@@ -119,7 +115,6 @@ export interface PostDensityFinding extends Omit<BodyDensityFinding, 'kind'> {
 }
 
 const LENGTHS: readonly DensityKind[] = ['paragraph-length', 'bullet-length']
-const NESTED_ITEM = /^(\s+)(?:[-*+]|\d+\.)\s+(.*)$/
 const CHECKBOX = /^\s*[-*+]\s+\[[ xX]\]/
 const FOOTER = /^🤖/
 
@@ -134,8 +129,8 @@ const FOOTER = /^🤖/
  * paragraph run, and a checklist box under `What to look at` takes no length
  * limit, since a driver needs its route, action, and result.
  *
- * A nested item is measured as a bullet of its own, which `densityFindings()`
- * leaves out of its parent, so a finding's subject and its evidence never sum.
+ * A nested item is measured as a bullet of its own by `densityFindings()`, which
+ * leaves it out of its parent, so a finding's subject and its evidence never sum.
  */
 export function postDensity(body: string): PostDensityFinding[] {
   const lines = bodyLines(body).map((line) =>
@@ -153,7 +148,6 @@ export function postDensity(body: string): PostDensityFinding[] {
         (chunk) => densityFindings(chunk),
       ),
       ...densityFindings(inside).filter(({ kind }) => LENGTHS.includes(kind)),
-      ...nestedLengths(section.lines),
     ]
 
     for (const finding of measured) {
@@ -214,41 +208,6 @@ function foldedApart(lines: readonly BodyLine[]): {
   return { outside, inside }
 }
 
-/**
- * A `bullet-length` finding for each nested item past the bullet limit, its
- * length taken over the item and the lines indented under it that open no
- * item of their own.
- */
-function nestedLengths(lines: readonly BodyLine[]): DensityFinding[] {
-  const found: DensityFinding[] = []
-
-  for (const [index, line] of lines.entries()) {
-    const match = line.fenced ? null : NESTED_ITEM.exec(line.text)
-    if (!match) continue
-
-    const indent = match[1].length
-    const parts = [match[2].trim()]
-    for (const next of lines.slice(index + 1)) {
-      const lead = /^\s*/.exec(next.text)?.[0].length ?? 0
-      if (next.fenced || next.text.trim() === '' || lead <= indent) break
-      if (LIST_ITEM.test(next.text)) break
-      parts.push(next.text.trim())
-    }
-
-    const length = visibleText(parts.join(' ')).length
-    if (length > CHECKPOINTS.bullet) {
-      found.push({
-        kind: 'bullet-length',
-        line: line.number,
-        value: length,
-        limit: CHECKPOINTS.bullet,
-      })
-    }
-  }
-
-  return found
-}
-
 function sectionsOf(lines: readonly BodyLine[]): Section[] {
   const sections: Section[] = []
   let current: { name: string | null; lines: BodyLine[] } = {

package/src/markdown/density.ts

@@ -22,6 +22,8 @@ export type DensityKind =
   | 'bullet-run'
   | 'heading-depth'
   | 'h3-opening'
+  | 'table-cell'
+  | 'table-then-list'
 
 export interface DensityFinding {
   readonly kind: DensityKind
@@ -52,14 +54,16 @@ type Block =
  * here it belongs to the item: it counts toward the bullet's length and never
  * toward a paragraph run, since a reader sees it inside the list.
  *
- * A nested item is left out of its parent, as `heavyBullets` leaves it, and so
- * is everything indented under the nested item. An indented fence inside an
- * item stays with the item, and a column-zero one ends it.
+ * A nested item is a block of its own, taking the lines indented past its
+ * marker, and its parent leaves it out along with everything indented under it.
+ * An indented fence inside an item joins neither and ends the nested item, and
+ * a column-zero one ends both.
  */
 function blocksOf(lines: readonly BodyLine[]): Block[] {
   const blocks: Block[] = []
   let paragraph: { line: number; parts: string[] } | undefined
   let item: { line: number; parts: string[]; nested: boolean } | undefined
+  let child: { line: number; parts: string[]; indent: number } | undefined
   let inFence = false
   let afterBlank = false
 
@@ -74,7 +78,19 @@ function blocksOf(lines: readonly BodyLine[]): Block[] {
     paragraph = undefined
   }
 
+  const closeChild = (): void => {
+    if (child) {
+      blocks.push({
+        kind: 'item',
+        line: child.line,
+        text: child.parts.join(' '),
+      })
+    }
+    child = undefined
+  }
+
   const closeItem = (): void => {
+    closeChild()
     if (item) {
       blocks.push({ kind: 'item', line: item.line, text: item.parts.join(' ') })
     }
@@ -95,7 +111,8 @@ function blocksOf(lines: readonly BodyLine[]): Block[] {
       // The opening delimiter decides who owns the block. `bodyLines` marks a
       // delimiter and the body alike, so the opener is the first fenced line.
       if (!inFence) {
-        if (!(item && indented)) {
+        if (item && indented) closeChild()
+        else {
           closeAll()
           blocks.push({ kind: 'other', line: line.number, table: false })
         }
@@ -108,13 +125,27 @@ function blocksOf(lines: readonly BodyLine[]): Block[] {
 
     if (text === '') {
       closeParagraph()
+      closeChild()
       afterBlank = true
       continue
     }
 
     if (indented && item) {
-      if (LIST_ITEM.test(raw)) item.nested = true
-      else if (!item.nested && !TABLE_ROW.test(raw)) item.parts.push(text)
+      const lead = leadOf(raw)
+      if (LIST_ITEM.test(raw)) {
+        closeChild()
+        item.nested = true
+        child = {
+          line: line.number,
+          parts: [text.replace(LIST_ITEM, '')],
+          indent: lead,
+        }
+      } else if (child && lead > child.indent) {
+        if (!TABLE_ROW.test(raw)) child.parts.push(text)
+      } else {
+        closeChild()
+        if (!item.nested && !TABLE_ROW.test(raw)) item.parts.push(text)
+      }
       afterBlank = false
       continue
     }
@@ -163,6 +194,10 @@ function blocksOf(lines: readonly BodyLine[]): Block[] {
   return blocks
 }
 
+function leadOf(raw: string): number {
+  return raw.length - raw.trimStart().length
+}
+
 /**
  * Every breach of the six density limits, in line order.
  *

package/src/markdown/scope.ts

@@ -4,6 +4,7 @@ import {
   densityFindings,
 } from '@/markdown/density'
 import type { BodyLine } from '@/markdown/scan'
+import { tableDensityFindings } from '@/markdown/tables'
 
 /** The surfaces the retired bullet-stacks stage held, per `ALWAYS_GATED`. */
 const BULLET_RUN_SCOPE = [
@@ -68,12 +69,16 @@ function keyPathsSection(lines: readonly BodyLine[]): readonly BodyLine[] {
  * The density findings a path takes, being every finding on a density-scope
  * file and the Key paths findings on a `CLAUDE.md`. The audit, the init probe,
  * and `canon claude sync` all read this, so the three agree on what counts.
+ * The table cell and trailing-list findings join on a density-scope path only,
+ * since `densityFindings` stays what its direct callers grade.
  */
 export function scopedDensityFindings(
   rel: string,
   lines: readonly BodyLine[],
 ): DensityFinding[] {
-  if (inDensityScope(rel)) return densityFindings(lines)
+  if (inDensityScope(rel)) {
+    return [...densityFindings(lines), ...tableDensityFindings(lines)]
+  }
   if (!KEY_PATHS_SCOPE.test(rel)) return []
   return densityFindings(keyPathsSection(lines)).filter((finding) =>
     KEY_PATHS_KINDS.includes(finding.kind),

package/src/markdown/structure.ts

@@ -415,10 +415,10 @@ export function longestRun(
 }
 
 /**
- * Finds the top-level bullets carrying more than a decision.
+ * Finds the bullets carrying more than a decision, nested ones included.
  *
- * A nested item is left out rather than folded into its parent, since the
- * checkpoint asks what one bullet carries and a child carries its own. Lines
+ * A nested item is measured on its own and never folded into its parent, since
+ * the checkpoint asks what one bullet carries and a child carries its own. Lines
  * continuing a bullet do fold in, so a heavy bullet cannot fall under the
  * checkpoint by being wrapped across two source lines. A fenced line closes the
  * open bullet, which keeps a bullet from absorbing the example below it.
@@ -436,6 +436,8 @@ export function heavyBullets(
 interface FoldedBullet extends BulletFinding {
   /** The bullet's source lines joined by the space a wrap would have carried. */
   readonly text: string
+  /** The width of the indent before the marker, which a continuation must pass. */
+  readonly indent: number
 }
 
 /** The walk `heavyBullets` reports from. */
@@ -459,18 +461,18 @@ function foldBullets(
 
     const item = line.text.match(LIST_ITEM)
     const text = line.text.trim()
+    const lead = line.text.length - line.text.trimStart().length
 
     // Structure is read off the raw line and only the weight is masked. A line
     // carrying nothing but an autolink has no visible text at all, and reading
     // its masked form as blank would close the bullet it continues.
     if (item) {
       close()
-      if (item[1].length === 0) {
-        open = {
-          line: line.number,
-          characters: visibleText(text).length,
-          text,
-        }
+      open = {
+        line: line.number,
+        characters: visibleText(text).length,
+        text,
+        indent: item[1].length,
       }
       continue
     }
@@ -480,6 +482,13 @@ function foldBullets(
       continue
     }
 
+    // An indented line that does not pass the marker's indent belongs to a
+    // parent or to nothing, so it ends a nested item rather than extending it.
+    if (open && lead > 0 && lead <= open.indent) {
+      close()
+      continue
+    }
+
     // The joining space a wrapped line would have carried, so folding two
     // source lines measures what one unwrapped line would have.
     if (open)

package/src/markdown/tables.ts

@@ -1,3 +1,4 @@
+import type { DensityFinding } from '@/markdown/density'
 import { type BodyLine, visibleText } from '@/markdown/scan'
 import { LIST_ITEM, TABLE_ROW, TABLE_SEPARATOR } from '@/markdown/structure'
 
@@ -10,19 +11,14 @@ export const TABLE_ROWS = 8
 /** The longest unbroken run a code span in a table cell may carry. */
 export const TABLE_TOKEN = 30
 
-export type TableKind =
-  | 'table-cell'
-  | 'table-rows'
-  | 'table-then-list'
-  | 'table-token'
+export type TableKind = 'table-rows' | 'table-token'
 
 export interface TableFinding {
   readonly kind: TableKind
-  /** The row holding the cell or span, the header for a row count, or the list's first item. */
+  /** The span's row, or the header for a row count. */
   readonly line: number
-  /** What was measured, or null for a trailing list, which is a shape rather than a count. */
-  readonly value: number | null
-  readonly limit: number | null
+  readonly value: number
+  readonly limit: number
 }
 
 /**
@@ -55,16 +51,22 @@ function cellsOf(row: string): string[] {
 }
 
 /**
- * Every breach of the four table limits, in line order.
+ * Every breach of the four table limits, in line order, split by whether it
+ * gates.
  *
  * A table is a run of pipe rows whose second row is a delimiter, the shape a
  * renderer draws. Pipe lines with no delimiter render as paragraph text, and a
  * fenced line is an example, so neither is measured. The limits are a
  * 120-character cell, 8 body rows, a list as the next block, and a code span
- * holding a run past 30 characters. Every finding reports and none gates.
+ * holding a run past 30 characters. The cell and the trailing list are density
+ * findings, and the row count and the wide token report and never gate.
  */
-export function tableFindings(lines: readonly BodyLine[]): TableFinding[] {
-  const found: TableFinding[] = []
+function measureTables(lines: readonly BodyLine[]): {
+  reported: TableFinding[]
+  density: DensityFinding[]
+} {
+  const reported: TableFinding[] = []
+  const density: DensityFinding[] = []
   let index = 0
 
   while (index < lines.length) {
@@ -96,7 +98,7 @@ export function tableFindings(lines: readonly BodyLine[]): TableFinding[] {
       for (const cell of cellsOf(row.text)) {
         const length = visibleText(cell).length
         if (length > TABLE_CELL) {
-          found.push({
+          density.push({
             kind: 'table-cell',
             line: row.number,
             value: length,
@@ -106,7 +108,7 @@ export function tableFindings(lines: readonly BodyLine[]): TableFinding[] {
         for (const span of codeSpans(cell)) {
           const run = unbrokenRun(span)
           if (run > TABLE_TOKEN) {
-            found.push({
+            reported.push({
               kind: 'table-token',
               line: row.number,
               value: run,
@@ -119,7 +121,7 @@ export function tableFindings(lines: readonly BodyLine[]): TableFinding[] {
 
     const bodyRows = tableRows.length - 1
     if (bodyRows > TABLE_ROWS) {
-      found.push({
+      reported.push({
         kind: 'table-rows',
         line: header.number,
         value: bodyRows,
@@ -135,7 +137,7 @@ export function tableFindings(lines: readonly BodyLine[]): TableFinding[] {
       !following.fenced &&
       LIST_ITEM.test(following.text)
     ) {
-      found.push({
+      density.push({
         kind: 'table-then-list',
         line: following.number,
         value: null,
@@ -146,5 +148,17 @@ export function tableFindings(lines: readonly BodyLine[]): TableFinding[] {
     index = end
   }
 
-  return found.sort((a, b) => a.line - b.line)
+  return { reported, density }
+}
+
+/** The row count and wide token findings, which report and never gate. */
+export function tableFindings(lines: readonly BodyLine[]): TableFinding[] {
+  return measureTables(lines).reported.sort((a, b) => a.line - b.line)
+}
+
+/** The cell and trailing-list findings, which gate as density kinds do. */
+export function tableDensityFindings(
+  lines: readonly BodyLine[],
+): DensityFinding[] {
+  return measureTables(lines).density.sort((a, b) => a.line - b.line)
 }