@erclx/canon 5.21.0 → 5.23.0

package/src/slides/package/motion.ts

@@ -0,0 +1,316 @@
+import type JSZip from 'jszip'
+
+/**
+ * Slide transitions and entrance animations, written into a slide's XML after
+ * pptxgenjs has written it, since pptxgenjs declares neither. A slide states
+ * them in its HTML, `walk.ts` reads the attributes, and the converter resolves
+ * each animated element to the object names `planSlide` gave its shapes. This
+ * module turns those names into the shape ids the written XML assigned.
+ */
+
+export interface TransitionSpec {
+  readonly effect: string
+  readonly duration?: string
+}
+
+export interface EntranceSpec {
+  /** The element that declared it, which every notice names. */
+  readonly selector: string
+  readonly effect: string
+  readonly order?: string
+  readonly duration?: string
+  /** Every shape drawn from the element and the elements inside it. */
+  readonly shapes: readonly string[]
+}
+
+export interface SlideMotion {
+  readonly transition?: TransitionSpec
+  readonly entrances: readonly EntranceSpec[]
+}
+
+export interface MotionResult {
+  readonly xml: string
+  readonly notices: readonly string[]
+}
+
+/** A slide's motion, numbered as the package numbers its slide parts. */
+export interface SlideMotionEdit {
+  readonly slide: number
+  readonly motion: SlideMotion
+}
+
+export interface MotionNotice {
+  readonly slide: number
+  readonly message: string
+}
+
+/** The child element `<p:transition>` holds, each in its default direction. */
+const TRANSITIONS: Readonly<Record<string, string>> = {
+  fade: '<p:fade/>',
+  push: '<p:push/>',
+  wipe: '<p:wipe/>',
+  cover: '<p:cover/>',
+}
+
+/**
+ * The strict schema states a transition's length only as one of three speeds,
+ * 0.5, 0.75, and 1 second. A length in milliseconds needs the PowerPoint 2010
+ * extension namespace, so a declared duration rounds to the nearest speed.
+ */
+function speedOf(duration: number | undefined): 'fast' | 'med' | 'slow' {
+  if (duration === undefined) return 'med'
+  if (duration < 625) return 'fast'
+  return duration < 875 ? 'med' : 'slow'
+}
+
+type Behaviors = (spid: string, duration: number, next: () => number) => string
+
+const target = (spid: string): string =>
+  `<p:tgtEl><p:spTgt spid="${spid}"/></p:tgtEl>`
+
+const animEffect =
+  (filter: string): Behaviors =>
+  (spid, duration, next) =>
+    `<p:animEffect transition="in" filter="${filter}"><p:cBhvr><p:cTn id="${next()}" dur="${duration}"/>${target(spid)}</p:cBhvr></p:animEffect>`
+
+function anim(
+  spid: string,
+  duration: number,
+  id: number,
+  attribute: string,
+  from: string,
+  to: string,
+): string {
+  return `<p:anim calcmode="lin" valueType="num"><p:cBhvr additive="base"><p:cTn id="${id}" dur="${duration}" fill="hold"/>${target(spid)}<p:attrNameLst><p:attrName>${attribute}</p:attrName></p:attrNameLst></p:cBhvr><p:tavLst><p:tav tm="0"><p:val><p:strVal val="${from}"/></p:val></p:tav><p:tav tm="100000"><p:val><p:strVal val="${to}"/></p:val></p:tav></p:tavLst></p:anim>`
+}
+
+interface Preset {
+  readonly id: number
+  readonly subtype: number
+  readonly behaviors: Behaviors
+}
+
+/**
+ * PowerPoint's own preset ids, so the effect shows by name in its animation
+ * pane. Fly comes in from the bottom and wipe from the left, the directions
+ * PowerPoint picks when none is chosen. A wipe filter names the edge the
+ * reveal starts from, so from the left pairs with `wipe(left)`.
+ */
+const ENTRANCES: Readonly<Record<string, Preset>> = {
+  fade: { id: 10, subtype: 0, behaviors: animEffect('fade') },
+  fly: {
+    id: 2,
+    subtype: 4,
+    behaviors: (spid, duration, next) =>
+      anim(spid, duration, next(), 'ppt_x', '#ppt_x', '#ppt_x') +
+      anim(spid, duration, next(), 'ppt_y', '1+#ppt_h/2', '#ppt_y'),
+  },
+  wipe: { id: 22, subtype: 8, behaviors: animEffect('wipe(left)') },
+  zoom: {
+    id: 53,
+    subtype: 16,
+    behaviors: (spid, duration, next) =>
+      anim(spid, duration, next(), 'ppt_w', '0', '#ppt_w') +
+      anim(spid, duration, next(), 'ppt_h', '0', '#ppt_h') +
+      animEffect('fade')(spid, duration, next),
+  },
+}
+
+const DEFAULT_ENTRANCE_MS = 500
+
+const ANCHOR = '</p:clrMapOvr>'
+
+const list = (names: readonly string[]): string =>
+  `${names.slice(0, -1).join(', ')}, or ${names.at(-1)}`
+
+/**
+ * The object names an entrance on `root` brings in: every shape drawn from it
+ * and from the elements inside it, so a card's box and its text arrive on one
+ * click. A descendant in `roots` declares its own entrance and keeps its
+ * subtree for that click. A record follows its parent in document order, which
+ * lets one pass collect the subtree.
+ */
+export function entranceShapes(
+  root: number | null,
+  records: readonly { readonly id: number; readonly parent: number | null }[],
+  names: readonly { readonly record: number; readonly name: string }[],
+  roots: ReadonlySet<number>,
+): string[] {
+  if (root === null) return []
+  const subtree = new Set([root])
+  for (const record of records) {
+    const isOwnEntrance = roots.has(record.id)
+    if (
+      record.parent !== null &&
+      subtree.has(record.parent) &&
+      !isOwnEntrance
+    ) {
+      subtree.add(record.id)
+    }
+  }
+  return names
+    .filter((named) => subtree.has(named.record))
+    .map((named) => named.name)
+}
+
+/** Milliseconds from `500`, `500ms`, or `0.5s`, or undefined when unreadable. */
+export function millisecondsOf(value: string | undefined): number | undefined {
+  const match = /^\s*(\d+(?:\.\d+)?)\s*(ms|s)?\s*$/.exec(value ?? '')
+  if (!match?.[1]) return undefined
+  const amount = Number(match[1])
+  return Math.round(match[2] === 's' ? amount * 1000 : amount)
+}
+
+/**
+ * pptxgenjs numbers a table `n * slideNumber + 1` and every other shape by its
+ * index plus two, so a table can share an id with a shape beside it. A timing
+ * target has to name one shape, so each repeat after the first takes a fresh id.
+ */
+function uniqueIds(xml: string): string {
+  const pattern = /<p:cNvPr id="(\d+)"/g
+  let highest = Math.max(
+    0,
+    ...[...xml.matchAll(pattern)].map((match) => Number(match[1])),
+  )
+  const seen = new Set<string>()
+  return xml.replace(pattern, (whole, id: string) => {
+    if (!seen.has(id)) {
+      seen.add(id)
+      return whole
+    }
+    highest += 1
+    return `<p:cNvPr id="${highest}"`
+  })
+}
+
+function shapeIds(xml: string): Map<string, string> {
+  const ids = new Map<string, string>()
+  for (const [, id, name] of xml.matchAll(
+    /<p:cNvPr id="(\d+)" name="([^"]*)"/g,
+  )) {
+    if (id && name && !ids.has(name)) ids.set(name, id)
+  }
+  return ids
+}
+
+interface Click {
+  readonly preset: Preset
+  readonly duration: number
+  readonly spids: readonly string[]
+}
+
+function timingXml(clicks: readonly Click[]): string {
+  let counter = 2
+  const next = (): number => {
+    counter += 1
+    return counter
+  }
+  const pars = clicks.map((click) => {
+    const outer = next()
+    const inner = next()
+    const effects = click.spids.map((spid, index) => {
+      const nodeType = index === 0 ? 'clickEffect' : 'withEffect'
+      const effect = next()
+      const visible = `<p:set><p:cBhvr><p:cTn id="${next()}" dur="1" fill="hold"><p:stCondLst><p:cond delay="0"/></p:stCondLst></p:cTn>${target(spid)}<p:attrNameLst><p:attrName>style.visibility</p:attrName></p:attrNameLst></p:cBhvr><p:to><p:strVal val="visible"/></p:to></p:set>`
+      const behaviors = click.preset.behaviors(spid, click.duration, next)
+      return `<p:par><p:cTn id="${effect}" presetID="${click.preset.id}" presetClass="entr" presetSubtype="${click.preset.subtype}" fill="hold" nodeType="${nodeType}"><p:stCondLst><p:cond delay="0"/></p:stCondLst><p:childTnLst>${visible}${behaviors}</p:childTnLst></p:cTn></p:par>`
+    })
+    return `<p:par><p:cTn id="${outer}" fill="hold"><p:stCondLst><p:cond delay="indefinite"/></p:stCondLst><p:childTnLst><p:par><p:cTn id="${inner}" fill="hold"><p:stCondLst><p:cond delay="0"/></p:stCondLst><p:childTnLst>${effects.join('')}</p:childTnLst></p:cTn></p:par></p:childTnLst></p:cTn></p:par>`
+  })
+  return `<p:timing><p:tnLst><p:par><p:cTn id="1" dur="indefinite" restart="never" nodeType="tmRoot"><p:childTnLst><p:seq concurrent="1" nextAc="seek"><p:cTn id="2" dur="indefinite" nodeType="mainSeq"><p:childTnLst>${pars.join('')}</p:childTnLst></p:cTn><p:prevCondLst><p:cond evt="onPrev" delay="0"><p:tgtEl><p:sldTgt/></p:tgtEl></p:cond></p:prevCondLst><p:nextCondLst><p:cond evt="onNext" delay="0"><p:tgtEl><p:sldTgt/></p:tgtEl></p:cond></p:nextCondLst></p:seq></p:childTnLst></p:cTn></p:par></p:tnLst></p:timing>`
+}
+
+/** Declared order first, then document order for ties and for no order. */
+function ordered(entrances: readonly EntranceSpec[]): EntranceSpec[] {
+  const rank = (entrance: EntranceSpec): number => {
+    const order = Number.parseFloat(entrance.order ?? '')
+    return Number.isFinite(order) ? order : Number.POSITIVE_INFINITY
+  }
+  return entrances.toSorted((a, b) => rank(a) - rank(b))
+}
+
+/**
+ * Inserts the transition and an on-click main sequence after the slide's color
+ * map override, where the schema orders them. Each entrance is one click, and
+ * every shape drawn from its element comes in on that click together. A slide
+ * missing the anchor is returned unchanged rather than patched elsewhere.
+ */
+export function addMotion(xml: string, motion: SlideMotion): MotionResult {
+  const notices: string[] = []
+  let transition = ''
+  if (motion.transition) {
+    const element = TRANSITIONS[motion.transition.effect]
+    if (element) {
+      const speed = speedOf(millisecondsOf(motion.transition.duration))
+      transition = `<p:transition spd="${speed}">${element}</p:transition>`
+    } else {
+      notices.push(
+        `unknown transition ${motion.transition.effect}. Use ${list(Object.keys(TRANSITIONS))}`,
+      )
+    }
+  }
+
+  const numbered = uniqueIds(xml)
+  const ids = shapeIds(numbered)
+  const clicks: Click[] = []
+  for (const entrance of ordered(motion.entrances)) {
+    const preset = ENTRANCES[entrance.effect]
+    if (!preset) {
+      notices.push(
+        `${entrance.selector}: unknown entrance ${entrance.effect}. Use ${list(Object.keys(ENTRANCES))}`,
+      )
+      continue
+    }
+    const spids = entrance.shapes.flatMap((name) => {
+      const id = ids.get(name)
+      return id ? [id] : []
+    })
+    if (spids.length === 0) {
+      notices.push(
+        `${entrance.selector}: draws no shape, so its entrance has nothing to animate`,
+      )
+      continue
+    }
+    const duration = millisecondsOf(entrance.duration) ?? DEFAULT_ENTRANCE_MS
+    clicks.push({ preset, duration, spids })
+  }
+
+  const timing = clicks.length > 0 ? timingXml(clicks) : ''
+  if (!transition && !timing) return { xml, notices }
+  if (!xml.includes(ANCHOR)) {
+    return {
+      xml,
+      notices: [
+        ...notices,
+        `no ${ANCHOR} to anchor motion after, so none was written`,
+      ],
+    }
+  }
+  return {
+    xml: (timing ? numbered : xml).replace(
+      ANCHOR,
+      `${ANCHOR}${transition}${timing}`,
+    ),
+    notices,
+  }
+}
+
+/** Writes each slide's motion into the opened package and returns its notices. */
+export async function writeMotion(
+  zip: JSZip,
+  edits: readonly SlideMotionEdit[],
+): Promise<MotionNotice[]> {
+  const notices: MotionNotice[] = []
+  for (const { slide, motion } of edits) {
+    const path = `ppt/slides/slide${slide}.xml`
+    const xml = await zip.file(path)?.async('string')
+    if (xml === undefined) {
+      notices.push({ slide, message: `no ${path} in the written deck` })
+      continue
+    }
+    const result = addMotion(xml, motion)
+    if (result.xml !== xml) zip.file(path, result.xml)
+    notices.push(...result.notices.map((message) => ({ slide, message })))
+  }
+  return notices
+}

package/src/slides/package/test-face.ts

@@ -0,0 +1,113 @@
+/**
+ * Builds the smallest sfnt the font step reads, holding only the `OS/2`,
+ * `head`, and `name` tables an EOT header is built from, plus `fvar` when the
+ * face should read as variable. It carries no glyphs, so it embeds and never
+ * renders. Tests use it in place of a real face, whose license the repository
+ * would then have to carry.
+ */
+
+export interface TestFaceOptions {
+  readonly family?: string
+  readonly subfamily?: string
+  readonly weight?: number
+  readonly isItalic?: boolean
+  readonly fsType?: number
+  readonly isVariable?: boolean
+  /** The first four bytes, `0x00010000` for TrueType. */
+  readonly version?: number
+}
+
+/** Values distinct enough that a header copying the wrong field shows it. */
+export const TEST_FACE = {
+  panose: [2, 11, 5, 3, 3, 4, 3, 2, 2, 4],
+  unicodeRanges: [0xe0000aff, 0x5000e5ff, 0x00000009, 0x00000001],
+  codePages: [0x0000019f, 0x01020000],
+  checkSumAdjustment: 0x1234abcd,
+} as const
+
+function os2(options: TestFaceOptions): Buffer {
+  const table = Buffer.alloc(96)
+  table.writeUInt16BE(4, 0)
+  table.writeUInt16BE(options.weight ?? 400, 4)
+  table.writeUInt16BE(options.fsType ?? 0, 8)
+  Buffer.from(TEST_FACE.panose).copy(table, 32)
+  TEST_FACE.unicodeRanges.forEach((range, index) => {
+    table.writeUInt32BE(range, 42 + index * 4)
+  })
+  table.write('TEST', 58, 'latin1')
+  table.writeUInt16BE(options.isItalic ? 0x0001 : 0x0040, 62)
+  TEST_FACE.codePages.forEach((page, index) => {
+    table.writeUInt32BE(page, 78 + index * 4)
+  })
+  return table
+}
+
+function head(): Buffer {
+  const table = Buffer.alloc(54)
+  table.writeUInt32BE(0x00010000, 0)
+  table.writeUInt32BE(TEST_FACE.checkSumAdjustment, 8)
+  table.writeUInt32BE(0x5f0f3cf5, 12)
+  return table
+}
+
+function name(strings: ReadonlyMap<number, string>): Buffer {
+  const encoded = [...strings].map(([id, text]) => ({
+    id,
+    bytes: Buffer.from(text, 'utf16le').swap16(),
+  }))
+  const header = Buffer.alloc(6 + encoded.length * 12)
+  header.writeUInt16BE(0, 0)
+  header.writeUInt16BE(encoded.length, 2)
+  header.writeUInt16BE(header.length, 4)
+  let offset = 0
+  encoded.forEach(({ id, bytes }, index) => {
+    const at = 6 + index * 12
+    header.writeUInt16BE(3, at)
+    header.writeUInt16BE(1, at + 2)
+    header.writeUInt16BE(0x0409, at + 4)
+    header.writeUInt16BE(id, at + 6)
+    header.writeUInt16BE(bytes.length, at + 8)
+    header.writeUInt16BE(offset, at + 10)
+    offset += bytes.length
+  })
+  return Buffer.concat([header, ...encoded.map(({ bytes }) => bytes)])
+}
+
+export function testFace(options: TestFaceOptions = {}): Buffer {
+  const family = options.family ?? 'Fixture Sans'
+  const subfamily = options.subfamily ?? 'Regular'
+  const tables = new Map<string, Buffer>([
+    ['OS/2', os2(options)],
+    ['head', head()],
+    [
+      'name',
+      name(
+        new Map([
+          [1, family],
+          [2, subfamily],
+          [4, `${family} ${subfamily}`],
+          [5, 'Version 1.000'],
+        ]),
+      ),
+    ],
+  ])
+  if (options.isVariable) tables.set('fvar', Buffer.alloc(16))
+
+  const entries = [...tables].sort(([a], [b]) => a.localeCompare(b))
+  const directory = Buffer.alloc(12 + entries.length * 16)
+  directory.writeUInt32BE(options.version ?? 0x00010000, 0)
+  directory.writeUInt16BE(entries.length, 4)
+  let offset = directory.length
+  const bodies: Buffer[] = []
+  entries.forEach(([tag, table], index) => {
+    const at = 12 + index * 16
+    directory.write(tag, at, 'latin1')
+    directory.writeUInt32BE(offset, at + 8)
+    directory.writeUInt32BE(table.length, at + 12)
+    const padded = Buffer.alloc(Math.ceil(table.length / 4) * 4)
+    table.copy(padded)
+    bodies.push(padded)
+    offset += padded.length
+  })
+  return Buffer.concat([directory, ...bodies])
+}

package/src/sync/check.ts

@@ -10,8 +10,10 @@ import { planSync, type ScanEntry, type SyncAdapter } from '@/sync/engine'
 import {
   collectSuperseded,
   detectUnmigrated,
+  detectUnmovedSurfaces,
   type SupersededEntry,
   type UnmigratedDomain,
+  type UnmovedSurface,
 } from '@/sync/layout'
 import {
   buildReverseReport,
@@ -178,6 +180,11 @@ export interface CheckReport {
   readonly seeds: SeedsReport
   readonly superseded: readonly SupersededEntry[]
   readonly unmigrated: readonly UnmigratedDomain[]
+  /**
+   * Report-only like `superseded`, since a target's CI gating on `--exit-code`
+   * would otherwise start failing on a layout nobody asked it to move yet.
+   */
+  readonly unmovedSurfaces: readonly UnmovedSurface[]
   readonly newSkills: readonly string[]
   /**
    * Rules the toolkit authored after this target's governance anchor, filtered
@@ -440,6 +447,7 @@ export async function buildCheckReport(
       seeds: { entries: [], historyUnavailable: false },
       superseded: [],
       unmigrated: [],
+      unmovedSurfaces: [],
       newSkills: [],
       newRules: [],
       reverse: emptyReverseReport(),
@@ -456,6 +464,7 @@ export async function buildCheckReport(
     seeds: buildSeedsReport(toolkitRoot, target),
     superseded: collectSuperseded(target),
     unmigrated,
+    unmovedSurfaces: detectUnmovedSurfaces(target),
     newSkills: await readNewSkills(toolkitRoot, anchors),
     newRules: await readNewRules(toolkitRoot, target, stamp),
     reverse: buildReverseReport(toolkitRoot, target),

package/src/sync/layout.ts

@@ -2,7 +2,7 @@ import { existsSync, statSync } from 'node:fs'
 import { basename, join, relative } from 'node:path'
 import { SUBDIRS } from '@/claude/seeds'
 import { creationRel, isRecordEntry } from '@/record-root'
-import { SURFACE_ENTRIES, surfaceDir } from '@/surface-root'
+import { SURFACE_ENTRIES, spell, surfaceDir } from '@/surface-root'
 import type { StampDomain } from '@/sync/stamp'
 
 const CLAUDE_DIR = '.claude'
@@ -122,6 +122,32 @@ export function detectUnmigrated(
   return found
 }
 
+/**
+ * A tracked surface the target still reads at its `.claude/` spelling, with
+ * nothing at the `canon/` one, and where `canon migrate surface-roots` moves it.
+ */
+export interface UnmovedSurface {
+  readonly rel: string
+  readonly movesTo: string
+}
+
+/**
+ * Surfaces a target holds only at the root the surface move retired. Kept
+ * apart from `detectUnmigrated`, which models a domain stranded at the project
+ * root under a stamp domain, while a surface carries neither. A rule names the
+ * current layout only, so a target here stops loading the rules scoped to these
+ * files, and this report is what points it at the verb.
+ */
+export function detectUnmovedSurfaces(target: string): UnmovedSurface[] {
+  return SURFACE_ENTRIES.filter(
+    (entry) =>
+      relative(target, surfaceDir(target, entry)) === join(CLAUDE_DIR, entry),
+  ).map((entry) => ({
+    rel: join(CLAUDE_DIR, entry),
+    movesTo: join('canon', spell('canon', entry)),
+  }))
+}
+
 /**
  * Root files whose basename matches something the toolkit ships for this domain.
  * Basenames rather than relative paths, because the root layout an older toolkit

package/src/tasks/validate.ts

@@ -89,6 +89,20 @@ export interface FolderClaim {
   readonly message: string
 }
 
+/**
+ * A code span in a board cell that the markdown preview cannot break, so it
+ * pushes the table past the pane and makes it scroll sideways. Either the
+ * longest whitespace-free run is wider than `WIDE_LIMIT`, or the span is a
+ * brace-glob, which is written out as separate paths. The limit is a heuristic
+ * over one pane, which is why it reports beside the findings and moves no exit
+ * code.
+ */
+export interface WideToken {
+  readonly group: BoardGroup
+  readonly subject: string
+  readonly message: string
+}
+
 /**
  * A task file neither surface names. That is the normal state between a
  * session filing it and a live orchestrator placing it, so it reports beside
@@ -124,6 +138,8 @@ export interface BoardRow {
   readonly ordinal: OrdinalWord | 'last' | undefined
   /** Whether a `Waiting on` cell ranks its row against a sibling row or a class of rows, false when the group fixes no such column. */
   readonly ranked: boolean
+  /** Every cell of the row as `splitCells` read it, which the wide-token scan walks. */
+  readonly cells: readonly string[]
 }
 
 export interface ValidateReport {
@@ -135,6 +151,7 @@ export interface ValidateReport {
   readonly findings: readonly Finding[]
   readonly untested: readonly Untested[]
   readonly claims: readonly FolderClaim[]
+  readonly wide: readonly WideToken[]
   readonly unplaced: readonly Unplaced[]
 }
 
@@ -461,6 +478,7 @@ export function readBoard(text: string): {
       waiting,
       ordinal: waiting ? readOrdinal(waiting) : undefined,
       ranked: waiting ? readRank(waiting) : false,
+      cells,
     })
   }
 
@@ -992,6 +1010,52 @@ function checkFolderClaims(
   return claims
 }
 
+/**
+ * The widest the longest unbroken run in a code span may be before a table
+ * scrolls in the preview pane. A 57-character span fit and a 78-character one
+ * did not, so the limit sits at the nearest round number above the first.
+ */
+const WIDE_LIMIT = 60
+
+/**
+ * Reports a code span a table cell cannot wrap. A span breaks only at
+ * whitespace, so the longest whitespace-free run is what is measured, and a
+ * link target is stripped first because only its label renders. Every group is
+ * scanned, since the overflow this exists for happened under `## Up next`,
+ * where the folder-claim scan would not have looked. Prose breaks at spaces
+ * and bare words at hyphens, so only a span is read.
+ */
+function checkWideTokens(rows: readonly BoardRow[]): WideToken[] {
+  const wide: WideToken[] = []
+
+  for (const row of rows) {
+    for (const cell of row.cells) {
+      const spans = cell.replace(/\]\([^)]*\)/g, ']').match(/`[^`]+`/g) ?? []
+
+      for (const span of spans) {
+        const text = span.slice(1, -1)
+        const run = Math.max(...text.split(/\s+/).map((part) => part.length))
+
+        if (/\{[^}]*,[^}]*\}/.test(text)) {
+          wide.push({
+            group: row.group,
+            subject: subjectOf(row),
+            message: `holds the brace-glob ${span}, which renders as one unbroken token. Write it out as separate paths.`,
+          })
+        } else if (run > WIDE_LIMIT) {
+          wide.push({
+            group: row.group,
+            subject: subjectOf(row),
+            message: `holds a ${run}-character token, ${span}, past the ${WIDE_LIMIT} a preview pane fits, so its table scrolls sideways.`,
+          })
+        }
+      }
+    }
+  }
+
+  return wide
+}
+
 /**
  * Reports a task file neither the board nor the backlog names. Under the
  * roster-checked hand-off, filing a task and placing its row are two acts a
@@ -1327,6 +1391,7 @@ export async function validateBoard(
     findings,
     untested: parked.untested,
     claims: checkFolderClaims(rows, root),
+    wide: checkWideTokens(rows),
     unplaced: checkUnplaced(rows, backlog, stems),
   }
 }

package/standards/architecture.md

@@ -3,7 +3,6 @@ title: Architecture reference
 description: Shape and content rules for canon/ARCHITECTURE.md
 paths:
   - 'canon/ARCHITECTURE.md'
-  - '.claude/ARCHITECTURE.md'
 rule:
   - "Add a decision here only when it fills one of the standard's slots, and write any other decision into the context entry for the domain it constrains. At the record's stated cap, merge or retire an entry before adding one."
 ---
@@ -89,7 +88,7 @@ Every session pays for this file before any work starts, so a heavy read is a re
   - `This record holds at most <n> decisions.`
   - `at most <n> words a decision`, counting a decision's prose below its heading, fenced lines left out
   - `at most <n> risk bullets`, counting every list item under `## Risks / open questions`, nested ones included
-- The three can share one sentence, such as `This record holds at most 12 decisions, at most 150 words a decision, and at most 6 risk bullets.` Each cap is the record's own, so a record stating none is measured and never gated, and the template states the entry cap alone so the other two are adopted on purpose.
+- The three can share one sentence, such as `This record holds at most 12 decisions, at most 150 words a decision, and at most 6 risk bullets.` Each cap is the record's own, so a record stating none is measured and never gated. The template and the seed a new project installs state all three, and a project loosens one by editing the number in its own record.
 - Set the decision cap near one decision per slot plus a small margin, the word cap near what one trade takes to state, about 150, and the risk cap at what a reader holds in mind at once, about 6.
 - At the decision cap, merge two decisions or retire one before adding another, and name which in the change that does it. Never pack two decisions under one heading, which the count cannot see.
 - At the word cap, cut a decision to the choice, the alternative that lost, the reason, and the revisit sentence. What it sheds is a mechanism or a measurement, which goes to the domain context entry it constrains, never under a second heading.
@@ -107,7 +106,7 @@ The revisit sentence closes the reasoning of every decision. The anchor sentence
 
 ## Overview
 
-This record holds at most 12 decisions. Every decision closes with a revisit sentence.
+This record holds at most 12 decisions, at most 150 words a decision, and at most 6 risk bullets. Every decision closes with a revisit sentence.
 
 ## Key technical decisions
 

package/standards/board.md

@@ -57,6 +57,8 @@ Each group fixes its own columns, which follow from the test above it rather tha
 
 A `Touches` cell is copied from its plan's own list, so it states what the branch sets out to write rather than a bound on it, and a branch outgrows it while the row still reads as it did at dispatch. Correct the cell from the branch rather than from the plan once one is running, since the plan is the prediction that already went stale and only the diff says what was written. `canon tasks plan-reach <plan>` reads that diff against every live plan and every cell in this group, and the row's owner is the one who writes the correction: a worker never edits this board.
 
+A cell holds no code span whose longest unbroken run passes 60 characters, since a span has no break point and a wider one makes its table scroll sideways in the preview. Write a brace-glob out as separate paths for the same reason. `canon tasks validate` reports both in its `wide` array and moves no exit code.
+
 ### Row order
 
 Row position inside `## Needs a plan` is the order those tasks get planned in, top first. The three tests answer whether a task can start, which is mechanical, and none of them answers which task is worth starting, which is a judgment no column holds. Position is where that judgment is recorded, so the top row is the answer to what to plan next and a reader needs no other surface to get it. The other two groups take the same reading, and it costs them little, since a group holding what is already planned is short by construction.

package/standards/context.md

@@ -3,7 +3,6 @@ title: Context entry reference
 description: Shape and content rules for canon/context/<domain>.md entries
 paths:
   - 'canon/context/**'
-  - '.claude/context/**'
 rule:
   - 'Before non-trivial work in a domain, read its `canon/context/<domain>.md` entry. Use `canon/context/index.md` to find it.'
   - 'Leave the entry conforming when work in its domain changes what it describes.'

package/standards/design.md

@@ -3,7 +3,6 @@ title: Design reference
 description: Shape and content rules for canon/DESIGN.md
 paths:
   - 'canon/DESIGN.md'
-  - '.claude/DESIGN.md'
 ---
 
 # Design reference

package/standards/diagrams.md

@@ -3,12 +3,9 @@ title: Diagram reference
 description: Shape and content rules for .canon/diagrams/<kind>.md files
 paths:
   - '.canon/diagrams/**'
-  - '.claude/DIAGRAMS.md'
 rule:
   - 'Layout, budgets, accessibility, labels, and render verification inside the fence are a separate topic. The mermaid standard routes them.'
   - 'A diagram entry carries structure and flow, not implementation. Read the standard before adding or revising a kind.'
-  - 'Write a new diagram to `.canon/diagrams/<kind>.md`, never to `.claude/DIAGRAMS.md`'
-  - 'Convert a `.claude/DIAGRAMS.md` left by an older install into per-kind entries before editing it'
 ---
 
 # Diagram reference