@erclx/canon 5.30.0 → 5.32.0

package/src/context/audit.ts

@@ -18,7 +18,7 @@ import { isStubSeed } from '@/tooling/seed-marker'
  * Every reason `canon context audit` refuses for.
  *
  * `no-folders` is the one ordinary absence: a project that never adopted
- * `canon/context/` or `canon/wireframes/`, and holds no `.canon/diagrams/`
+ * `canon/context/`, and holds no `.canon/diagrams/`
  * folder an older install left, names no corpus this audit can measure, the
  * same state `no-skills` reads for the skill corpora. The other four are a malformed invocation or a checkout git
  * cannot read, which stay a break rather than an absence.
@@ -54,16 +54,13 @@ const CATALOG_NAMED_RATIO = 0.6
  *
  * These names do not generalize the way a length threshold does, which is why
  * each list is keyed on the folder whose standard states it. `context.md`
- * requires an overview and a layout. `wireframes.md` asks four questions of a
- * surface and answers each in a section, so those four are required and
- * `## Behavior` is not, since a static surface has no interaction to state. A
+ * requires an overview and a layout. A
  * diagram entry declares a heading per kind and its standard requires none.
  */
 export const REQUIRED_SECTIONS_BY_FOLDER: Readonly<
   Record<string, readonly string[]>
 > = {
   context: ['Overview', 'Layout'],
-  wireframes: ['Regions', 'States', 'Copy', 'Not on this surface'],
 }
 
 /**
@@ -158,15 +155,14 @@ const SENTENCE_END = /[.!?:;]\s(?=[^.!?:;]*$)/
  * reading that field for a gain of one word.
  *
  * `standards/context.md` opens its scope by handing figures to the
- * `draft-figure` skill and wireframes to `wireframes.md`, so a marker reported
- * in a diagrams or wireframes entry would cite a rule that entry's own
- * standard routes elsewhere. The length and table
+ * `draft-figure` skill, so a marker reported in a diagrams entry would cite a
+ * rule that entry's own standard routes elsewhere. The length and table
  * checkpoints are quoted from the same standard and keep reaching every audited
  * folder, because a threshold on how far a reader travels generalizes across
  * entry types while a rule about what an entry may say does not.
  *
  * What gates here is a rule only this standard states. Bullet weight does not,
- * since `standards/markdown.md` owns that checkpoint across document types and
+ * since `claude/skills/markdown-craft/references/markdown.md` owns that checkpoint across document types and
  * its remedy sends the overflow to prose, which any entry type can act on.
  * `standards/context.md` specializes that remedy for an entry carrying
  * decisions, and specializing a rule narrows the advice rather than the measure.
@@ -495,7 +491,7 @@ function bareReferences(
  * path prefix hardcodes what `--folder` exists to override and misses a domain
  * split into `context/<sub-area>/`. Sibling names arrive the same way and for
  * the same reason, since the folder an entry sits in is what holds them. The
- * required sections arrive apart from jurisdiction, since a wireframe owes
+ * required sections arrive apart from jurisdiction, since a folder can owe
  * sections under a standard that states no provenance rule.
  */
 export function measureEntry(
@@ -652,11 +648,6 @@ export function matchesSiblings(folder: AuditedFolder): boolean {
  * The standard sanctions omitting `## Layout` from a domain owning no paths,
  * which no measure can tell from an entry that forgot it. An entry of that
  * shape therefore reports, which is a reason this is printed and never gated on.
- *
- * A wireframe folder answers per file whether nested or not, since its
- * standard keeps one surface per file. A subfolder of wireframes groups
- * surfaces the way the named context folder groups domains, so a conforming
- * sibling there says nothing about the surface beside it.
  */
 export function missingSections(
   root: string,

package/src/context/classify/extract.ts

@@ -7,15 +7,13 @@ import { listChangedFiles, resolveBaseRef } from '@/git/files'
 import { surfaceDir } from '@/roots/surface'
 
 /**
- * The five canonical doc types the classifier reaches, matching the file
+ * The three canonical doc types the classifier reaches, matching the file
  * pattern the groundwork spike scoped its fixture to
  * (`scripts/hunks.py`'s `DOC_PATH`) and the file-type catalog both system
  * prompts state.
  */
 export const CANONICAL_DOC_TYPES = [
   'context',
-  'architecture',
-  'wireframes',
   'design',
   'requirements',
 ] as const
@@ -24,23 +22,19 @@ export type CanonicalDocType = (typeof CANONICAL_DOC_TYPES)[number]
 
 const DOC_PATTERNS: Record<CanonicalDocType, RegExp> = {
   context: /(^|\/)context\/.+\.md$/,
-  architecture: /(^|\/)ARCHITECTURE\.md$/,
-  wireframes: /(^|\/)wireframes\/.+\.md$/,
   design: /(^|\/)DESIGN\.md$/,
   requirements: /(^|\/)REQUIREMENTS\.md$/,
 }
 
 const INDEX_NAME = 'index.md'
 
-/** The two doc types `resolveFolders` discovers, paired with the folder name it takes. */
+/** The doc type `resolveFolders` discovers, paired with the folder name it takes. */
 const MULTI_DOC_TYPES: readonly { type: CanonicalDocType; name: string }[] = [
   { type: 'context', name: 'context' },
-  { type: 'wireframes', name: 'wireframes' },
 ]
 
-/** The three doc types that resolve to one file each, paired with `surfaceDir`'s entry name. */
+/** The two doc types that resolve to one file each, paired with `surfaceDir`'s entry name. */
 const SINGLE_DOC_TYPES: readonly { type: CanonicalDocType; entry: string }[] = [
-  { type: 'architecture', entry: 'ARCHITECTURE.md' },
   { type: 'design', entry: 'DESIGN.md' },
   { type: 'requirements', entry: 'REQUIREMENTS.md' },
 ]
@@ -388,11 +382,10 @@ function readSections(
 /**
  * Every sweep-mode section across the requested canonical doc types.
  *
- * `context` and `wireframes` resolve through `resolveFolders`, the same
+ * `context` resolves through `resolveFolders`, the same
  * folder discovery `canon context audit` uses, so a domain split into a
- * folder of its own is swept the same way it is audited. The three
- * single-file types resolve through `surfaceDir`, agreeing with
- * `architectureRel`'s own resolution.
+ * folder of its own is swept the same way it is audited. The two
+ * single-file types resolve through `surfaceDir`.
  */
 export async function extractSweepSections(
   root: string,

package/src/context/classify/patterns.ts

@@ -37,44 +37,17 @@ export interface PatternVerdict<V extends string> {
 const NARRATION =
   /moved (again|twice|on)|has since|at this branch|on `feat|Measured in PR|did not survive|the operator picked|picked arm|\barm \d|closed on|was retired|no longer|used to|\bround\b|a review pass|this pass/i
 
-/**
- * A source-file path inside prose, the shape of implementation detail landing
- * on a surface that should describe layout and intent instead. Ported
- * verbatim from `heuristic.py`.
- */
-const MECHANISM_IN_WIREFRAME = /`[\w./-]+\.(tsx?|py|css|spec\.ts)`/
-
 function narrationQuote(text: string): string | undefined {
   return text.match(NARRATION)?.[0]
 }
 
-/**
- * Classifies one diff-mode chunk from its added text alone.
- *
- * `file` decides whether the wireframe-only MOVE test applies. A file argument
- * rather than a boolean matches `run.ts`'s other call sites, which hold the
- * path and not a pre-computed flag.
- */
-export function diffPatternVerdict(
-  file: string,
-  added: string,
-): PatternVerdict<DiffVerdict> {
+/** Classifies one diff-mode chunk from its added text alone. */
+export function diffPatternVerdict(added: string): PatternVerdict<DiffVerdict> {
   const quote = narrationQuote(added)
   if (quote !== undefined) {
     return { verdict: 'HISTORY', quote, reason: 'narrates how this got here' }
   }
 
-  if (file.includes('wireframes/')) {
-    const match = added.match(MECHANISM_IN_WIREFRAME)
-    if (match) {
-      return {
-        verdict: 'MOVE',
-        quote: match[0],
-        reason: 'names a source file, which is implementation detail',
-      }
-    }
-  }
-
   return { verdict: 'KEEP', reason: 'no narration or wrong-surface pattern' }
 }
 
@@ -87,7 +60,6 @@ export function diffPatternVerdict(
  * regex layer follows it.
  */
 export function sweepPatternVerdict(
-  file: string,
   body: string,
 ): PatternVerdict<SweepVerdict> {
   const quote = narrationQuote(body)
@@ -99,16 +71,5 @@ export function sweepPatternVerdict(
     }
   }
 
-  if (file.includes('wireframes/')) {
-    const match = body.match(MECHANISM_IN_WIREFRAME)
-    if (match) {
-      return {
-        verdict: 'MOVE',
-        quote: match[0],
-        reason: 'names a source file, which is implementation detail',
-      }
-    }
-  }
-
   return { verdict: 'KEEP', reason: 'no narration or wrong-surface pattern' }
 }

package/src/context/classify/prompts.ts

@@ -13,15 +13,13 @@ export const DIFF_SYSTEM_PROMPT = `You review one hunk just added to a project's
 
 File types and what they hold:
 - context/<domain>.md: one domain's structure, decisions (choice + the alternative that lost), gotchas. No history of how the domain got here, no change numbers, branch names, or dates attached to a change.
-- ARCHITECTURE.md: cross-domain decisions only, each a few sentences: what was chosen, over what, why. A measurement or mechanism specific to one domain belongs in that domain's context entry. Loaded every session, so weight matters.
-- wireframes/<surface>.md: layout sketches, reachable states, exact on-screen copy, interaction intent. Would the line still be true if the surface were rebuilt in another framework? Component names, test files, pixel constants, and mechanism belong in context.
 - DESIGN.md: tokens and visual rules, current state only.
 
 Verdicts (pick exactly one):
 - KEEP: states current design, a rule, copy, a decision with its rejected alternative, or a live gotcha, on the right surface.
 - REPLACE: restates a fact or figure the existing section already carries ("moved again", "now", "the count moved", a newer number appended after an older one). The old statement should be rewritten in place, not appended to.
 - HISTORY: narrates how things got here: which branch/PR changed what, "closed on", "did not survive", review-pass stories, pick-by-pick rounds. The current state is what belongs; the trail goes to the PR.
-- MOVE: correct content on the wrong surface (domain mechanism in ARCHITECTURE.md, implementation detail in a wireframe).
+- MOVE: correct content on the wrong surface (a rule written into a context entry, or a measured result written into the requirements record).
 
 Return only JSON: {"verdict": "...", "quote": "<the shortest added phrase that decided it>", "reason": "<one sentence>"}
 
@@ -35,15 +33,13 @@ export const SWEEP_SYSTEM_PROMPT = `You review one whole section of a project's
 
 File types and what they hold:
 - context/<domain>.md: one domain's structure, decisions (choice + the alternative that lost), gotchas. No history of how the domain got here, no change numbers, branch names, or dates attached to a change.
-- ARCHITECTURE.md: cross-domain decisions only, each a few sentences: what was chosen, over what, why. A measurement or mechanism specific to one domain belongs in that domain's context entry.
-- wireframes/<surface>.md: layout, reachable states, exact on-screen copy, interaction intent. Would the line still be true if the surface were rebuilt in another framework? Component names, test files, and pixel constants belong in context.
 - DESIGN.md: tokens and visual rules, current state only.
 - REQUIREMENTS.md: problem, goals, non-goals, scope, constraints. Never measured results.
 
 Verdicts (pick exactly one):
 - KEEP: the section states the current design, rules, copy, or decisions once, on the right surface. A single commit anchor on a figure is fine.
 - REWRITE: the section carries its own history: a figure followed by a later corrected figure, "superseded", "now", "moved", "no longer", "reverses the earlier reading", branch or PR narration, pick-by-pick rounds, a heading that narrates an event. The subject belongs here, but it must be restated as the current state.
-- MOVE: the section, or most of it, belongs on another surface (results in requirements, one domain's mechanism in architecture, implementation detail in a wireframe).
+- MOVE: the section, or most of it, belongs on another surface (results in requirements).
 
 Decision checks, in order:
 1. Judge what the text says, not how long it is. A long section that states current design once is KEEP.

package/src/context/classify/run.ts

@@ -245,7 +245,7 @@ async function modelVerdictFor<V extends string>(opts: {
  * A finding's `verdict` takes the model's reading when the model ran and
  * parsed, and the regex reading otherwise, since the groundwork measurements
  * show the model catching what the regex layer structurally cannot
- * (REPLACE, and MOVE outside a wireframe). Both readings stay on the finding
+ * (REPLACE and MOVE). Both readings stay on the finding
  * regardless of which one decided, so a caller can see where they disagreed.
  */
 export async function classifyDiff(
@@ -263,7 +263,7 @@ export async function classifyDiff(
 
   const findings: DiffFinding[] = []
   for (const chunk of extraction.chunks) {
-    const regex = withQuote(diffPatternVerdict(chunk.file, chunk.added))
+    const regex = withQuote(diffPatternVerdict(chunk.added))
     const model = await modelVerdictFor({
       plan,
       client,
@@ -312,7 +312,7 @@ export async function classifySweep(
 
   const findings: SweepFinding[] = []
   for (const section of extraction.sections) {
-    const regex = withQuote(sweepPatternVerdict(section.file, section.body))
+    const regex = withQuote(sweepPatternVerdict(section.body))
     const model = await modelVerdictFor({
       plan,
       client,

package/src/context/folders.ts

@@ -17,19 +17,14 @@ import { SURFACE_ROOTS } from '@/roots/surface'
  * these names. A folder left off the list is never resolved, so a path into one
  * goes stale silently rather than failing a push.
  */
-export const DEFAULT_FOLDERS: readonly string[] = [
-  'context',
-  'diagrams',
-  'wireframes',
-]
+export const DEFAULT_FOLDERS: readonly string[] = ['context', 'diagrams']
 
 /**
  * The bases every folder in the default list is looked for under.
  *
  * `diagrams` is a session record and resolves under `RECORD_ROOTS`, while
- * `context` and `wireframes` are tracked and resolve under `SURFACE_ROOTS`, so
- * the split this comment used to describe as hypothetical is real: two
- * folders on this list read from two different root lists. The base array is
+ * `context` is tracked and resolves under `SURFACE_ROOTS`, so two folders on
+ * this list read from two different root lists. The base array is
  * their union rather than a per-name map, since a name resolving at the wrong
  * root costs one extra `existsSync` and nothing else, where a map states the
  * split a second time next to the one each resolver module already carries.
@@ -90,10 +85,10 @@ export interface AuditedFolder {
  * Names the requested record-root folders that actually exist, which is the
  * citation check's scope.
  *
- * A skill or seed pointing into `canon/wireframes/` is a live instruction for
+ * A skill or seed pointing into an optional folder is a live instruction for
  * a project that carries the folder and says nothing about one that does not.
- * Checking a path into an absent folder would fail eight shipped references
- * here for the sole reason that this repository has no wireframes.
+ * Checking a path into an absent folder would fail shipped references here for
+ * the sole reason that this repository does not carry it.
  *
  * A folder resolved at the project root is measured and stays out of this. The
  * pattern the citation check builds spells the `.claude/` prefix, so admitting
@@ -172,7 +167,7 @@ function locate(
  * beside `node_modules` and a build output.
  *
  * The project root is reached only when the caller opts in, so a target holding
- * a root `wireframes/` is not audited against a standard it never adopted by
+ * a root folder of its own name is not audited against a standard it never adopted by
  * the mere act of running the command. `.claude/` still wins a name carried by
  * both, and the scope line prints the resolved path so a caller reads which
  * base was taken rather than inferring it.

package/src/context/gate.ts

@@ -1,61 +1,19 @@
 import type { SectionFinding } from '@/context/audit'
 import type { FolderDrift } from '@/context/index-drift'
-import type { WireframeStatesReport } from '@/context/wireframe-states'
 
 export interface GateInput {
   /** Cited paths that resolved to nothing, which gate under either mode. */
   readonly unresolvedCitations: number
-  /**
-   * Whether the architecture record is longer than the ceiling it derives for
-   * itself, which gates under either mode for the reason a citation does.
-   *
-   * False when the project carries no record and false under
-   * `--citations-only`, which never measures it. That mode runs one check by
-   * construction, so widening it here would gate on a reading it never took.
-   */
-  readonly recordOverLength: boolean
-  /**
-   * Whether the record holds more decisions than the cap it states, which
-   * gates under the same two modes and is false in the same two cases.
-   */
-  readonly recordOverCount: boolean
-  /**
-   * Whether a decision lacks the revisit sentence the record requires of
-   * every decision, which gates under the same two modes and is false in the
-   * same two cases, plus a record stating no such clause.
-   */
-  readonly recordMissingRevisit: boolean
-  /**
-   * Whether a decision holds more words than the cap the record states, which
-   * gates under the same two modes and is false in the same two cases, plus a
-   * record stating no word cap.
-   */
-  readonly recordOverWords: boolean
-  /** The same reading for the Risks section's bullet cap. */
-  readonly recordOverRisks: boolean
   /**
    * Whether the requirements record holds more words than the cap it states,
-   * which gates for the reason the architecture record's caps do.
+   * which gates under either mode for the reason a citation does. False when
+   * the project carries no record and false under `--citations-only`, which
+   * never measures it. That mode runs one check by construction, so widening
+   * it here would gate on a reading it never took.
    */
   readonly requirementsOverWords: boolean
   readonly sections: readonly SectionFinding[]
   readonly drift: readonly FolderDrift[]
-  /**
-   * Every wireframe entry's states report, empty for a project carrying no
-   * `canon/wireframes/` folder. A states/evidence mismatch is a fact read off
-   * the file, the same standing the missing-section and index-drift findings
-   * already have, so it gates alongside them under the widened mode.
-   *
-   * A sketch beside existing evidence stays out of the gate on both modes.
-   * `sketchWithEvidence` reads the whole entry against whether any of its
-   * states has evidence, not the sketched layout against the evidence for
-   * that same layout, since the standard's `## States` table names states
-   * rather than layouts and the report has no narrower unit to match on. An
-   * entry with a captured default layout and a sketch for a breakpoint layout
-   * that is not built yet is conforming and still trips this reading, so the
-   * finding stays a judgment for a reader rather than a fact a push fails on.
-   */
-  readonly wireframes: readonly WireframeStatesReport[]
   /**
    * Whether the caller asked for the widened gate. False leaves a missing
    * section and a drifted index advisory, which is what the project-root stage
@@ -71,65 +29,27 @@ export function hasDrift(drift: readonly FolderDrift[]): boolean {
   )
 }
 
-/** Whether any wireframe's States table disagrees with its evidence folders. */
-export function hasStatesMismatch(
-  wireframes: readonly WireframeStatesReport[],
-): boolean {
-  return wireframes.some(
-    (entry) =>
-      entry.missingFolders.length > 0 || entry.unlistedFolders.length > 0,
-  )
-}
-
-/** Whether any wireframe carries a sketch beside evidence that already exists. */
-export function hasSketchWithEvidence(
-  wireframes: readonly WireframeStatesReport[],
-): boolean {
-  return wireframes.some((entry) => entry.sketchWithEvidence)
-}
-
 /**
  * Whether the audit found something that should fail the caller.
  *
  * An unresolved citation is a broken pointer and gates unconditionally, and so
- * does a record past its own ceiling, entry cap, word cap, or bullet cap, or
- * missing a revisit sentence it requires, and a requirements record past its
- * own word cap: each record states its rules for itself, which makes those the
- * measures here that are facts
- * rather than thresholds a reader weighs. The findings `--gate` adds are
+ * does a requirements record past its own word cap: the record states its rule
+ * for itself, which makes it a fact rather than a threshold a reader weighs. The findings `--gate` adds are
  * the ones answerable from the file itself: a required section it does not
- * declare, an index disagreeing with its folder, and a wireframe's States
- * table disagreeing with its evidence folders. Entry length, depth, bullet,
- * table, provenance, the record's claim coverage, and a sketch beside
- * existing evidence are judgments, so they stay out under both modes. The
- * `wireframes` field's own doc states why the sketch finding is a judgment
- * rather than a fact.
+ * declare, and an index disagreeing with its folder. Entry length, depth, bullet,
+ * table, provenance, and the record's claim coverage are judgments, so they
+ * stay out under both modes.
  */
 export function isGating({
   unresolvedCitations,
-  recordOverLength,
-  recordOverCount,
-  recordMissingRevisit,
-  recordOverWords,
-  recordOverRisks,
   requirementsOverWords,
   sections,
   drift,
-  wireframes,
   widened,
 }: GateInput): boolean {
   if (unresolvedCitations > 0) return true
-  if (
-    recordOverLength ||
-    recordOverCount ||
-    recordMissingRevisit ||
-    recordOverWords ||
-    recordOverRisks ||
-    requirementsOverWords
-  ) {
-    return true
-  }
+  if (requirementsOverWords) return true
   if (!widened) return false
 
-  return sections.length > 0 || hasDrift(drift) || hasStatesMismatch(wireframes)
+  return sections.length > 0 || hasDrift(drift)
 }

package/src/context/requirements.ts

@@ -1,17 +1,26 @@
 import { readFile } from 'node:fs/promises'
 import { join, relative } from 'node:path'
-import { wordCount } from '@/context/architecture'
 import { bodyLines } from '@/markdown/scan'
 import { surfaceDir } from '@/roots/surface'
 
 /**
  * The record this measures, relative to `root`, resolved at either surface
- * root for the reason `architectureRel` gives.
+ * root, since a project that has moved holds it under either.
  */
 export function requirementsRel(root: string): string {
   return relative(root, surfaceDir(root, 'REQUIREMENTS.md'))
 }
 
+/**
+ * Counts whitespace-delimited tokens, the unit the record's word cap is stated
+ * in. A code span counts as the tokens it holds, so a line citing a long path
+ * pays for it the way a reader does. A caller gating on the count hands in
+ * prose with fenced lines already dropped.
+ */
+export function wordCount(text: string): number {
+  return text.match(/\S+/g)?.length ?? 0
+}
+
 export interface RequirementsReport {
   readonly rel: string
   /** The whole record's word count, frontmatter left out. */
@@ -43,8 +52,8 @@ function isMissing(error: unknown): boolean {
 /**
  * Measures the record, or reports nothing when the project carries none.
  *
- * Absent rather than zeroed, for the reason `measureArchitecture` gives, and a
- * record present and unreadable propagates the same way.
+ * Absent rather than zeroed, so a project with no record is never told it holds an
+ * empty one, and a record present and unreadable propagates.
  */
 export async function measureRequirements(
   root: string,

package/src/counts/scan.ts

@@ -35,8 +35,8 @@ export type CountsReport =
 
 /**
  * A calendar date, which reads a sentence as a historical record rather than
- * a live claim about the tree. `canon/ARCHITECTURE.md` and the context
- * entries carry a figure this way deliberately, and every one of them stays
+ * a live claim about the tree. The context entries
+ * carry a figure this way deliberately, and every one of them stays
  * correct forever, so a sentence carrying one is read past rather than
  * matched.
  */
@@ -142,7 +142,7 @@ const QUANTIFIERS = ['all']
  * match at all. No syntactic rule tells a qualifier that narrows a catalog
  * from one that only restates it, and the sentence was true when written, so
  * the fix was not a narrower matcher: the clause was dated as a past state,
- * the way `canon/ARCHITECTURE.md` dates its own figures, which is the class
+ * the way a context entry dates its own figures, which is the class
  * the date exclusion below already reads past.
  */
 const ARTICLES = ['the', 'a', 'an']

package/src/design/components.ts

@@ -250,8 +250,8 @@ const TEACH_CHROME: Component = {
     'navigation shared by every teach page. Recovered from two gitignored',
     'course.css files that predate a regression that dropped this layer from the',
     "generator, and rewritten onto this module's tokens rather than the",
-    'incompatible palette they carried. See canon/wireframes/teach/chrome.md for',
-    'the shape.',
+    'incompatible palette they carried. See canon/context/features/teach/chrome.md',
+    'for the shape.',
   ].join('\n   '),
   reads: [
     '--color-background',

package/src/feedback/body.ts

@@ -1,5 +1,3 @@
-const SLUG_FALLBACK = 'general'
-const SLUG_MAX_LENGTH = 40
 const TITLE_MAX_LENGTH = 72
 
 /**
@@ -79,16 +77,6 @@ function surfaceField(body: string): string | undefined {
   return readField(body, 'Surface')?.split('\n')[0]?.trim()
 }
 
-export function deriveSlug(body: string): string {
-  const slug = (surfaceField(body) ?? '')
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-    .slice(0, SLUG_MAX_LENGTH)
-    .replace(/-+$/g, '')
-  return slug || SLUG_FALLBACK
-}
-
 /**
  * Each label must exist on the toolkit repository, because `gh issue create`
  * refuses the whole issue on an unknown label rather than dropping it.

package/src/gate/measures.ts

@@ -7,14 +7,6 @@ import {
   type ClientCommand,
   clientCommandCitationsIn,
 } from '@/gate/client-commands'
-import {
-  isOverCount,
-  isOverLength,
-  isOverRisks,
-  measureArchitecture,
-  missingRevisit,
-  overWords,
-} from '@/context/architecture'
 import { isOverWordCap, measureRequirements } from '@/context/requirements'
 import {
   auditSkills,
@@ -253,62 +245,19 @@ function citedPaths(record: { paths?: unknown } | undefined): string[] {
 }
 
 /**
- * The canonical records against the caps each states for itself. The
- * architecture record carries five: the line ceiling its allowances derive,
- * the entry cap, the revisit sentence closing each decision, the words a
- * decision may hold, and the bullets its Risks section may hold. The
- * requirements record carries one, its own word count.
+ * The requirements record against the word cap it states for itself.
  *
  * Read in-process rather than through `context audit`, whose one gating stage
- * here runs `--citations-only` and never opens either record, which is why
- * the line ceiling went unenforced by `bun run check` until this stage. A
- * project carrying neither record, or records stating none of the caps,
- * passes, since each rule belongs to the record rather than to the toolkit.
+ * here runs `--citations-only` and never opens the record. A project carrying
+ * no record, or a record stating no cap, passes, since the rule belongs to the
+ * record rather than to the toolkit.
  */
 export const canonicalRecords: Measure = async (ctx) => {
-  const [report, requirements] = await Promise.all([
-    measureArchitecture(ctx.root),
-    measureRequirements(ctx.root),
-  ])
+  const requirements = await measureRequirements(ctx.root)
 
   const failures: string[] = []
   const emissions: Emission[] = []
 
-  if (report === undefined) {
-    emissions.push(info('No architecture record to measure'))
-  } else {
-    const decisions = report.decisions.length
-    const lackingRevisit = missingRevisit(report)
-    const longDecisions = overWords(report)
-    failures.push(
-      ...[
-        isOverCount(report) &&
-          `${decisions} decisions against a cap of ${report.entryCap}. Merge two or retire one in ${report.rel}, never compress.`,
-        isOverLength(report) &&
-          `${report.lines} lines against a ceiling of ${report.ceiling} in ${report.rel}.`,
-        lackingRevisit.length > 0 &&
-          `No revisit sentence in ${lackingRevisit.map((heading) => `"${heading}"`).join(', ')}. Close each with one opening "Revisit when" in ${report.rel}.`,
-        longDecisions.length > 0 &&
-          `${longDecisions.map((entry) => `"${entry.heading}" (${entry.words})`).join(', ')} past ${report.wordCap} words a decision in ${report.rel}. Cut the reasoning to the trade, never split one decision across two headings.`,
-        isOverRisks(report) &&
-          `${report.risksBullets} risk bullets against a cap of ${report.riskCap} in ${report.rel}. Drop what is no longer open.`,
-      ].filter((failure): failure is string => typeof failure === 'string'),
-    )
-
-    const cap =
-      report.entryCap === undefined
-        ? 'no entry cap stated'
-        : `a cap of ${report.entryCap}`
-    emissions.push(info(`${decisions} decisions against ${cap}`))
-    if (report.riskCap !== undefined && report.risksBullets === undefined) {
-      emissions.push(
-        info(
-          `No Risks section to count against a cap of ${report.riskCap} in ${report.rel}`,
-        ),
-      )
-    }
-  }
-
   if (requirements === undefined) {
     emissions.push(info('No requirements record to measure'))
   } else if (isOverWordCap(requirements)) {
@@ -415,7 +364,7 @@ export const skillProvenance: Measure = async (ctx) => {
 /**
  * Every listed practice skill against the closing sections, and every skill on
  * the wider ledger list against the ledger, both of which
- * `standards/skill-practice.md` requires.
+ * `claude/skills/create-skill/references/skill-practice.md` requires.
  *
  * Read in-process for the reason `skillProvenance` is, so the verb keeps its
  * missing-requirement-only exit. The list names shipped folders alone, so a

package/src/gate/stages.ts

@@ -110,7 +110,6 @@ export const TEST_CORPORA_PATTERNS = [
   '^governance/rules/',
   '^\\.claude/hooks/',
   '^tooling/claude/seeds/\\.claude/hooks/',
-  '^standards/markdown\\.md$',
   '^tooling/base/reference\\.md$',
   '^tooling/web/configs/scripts/worktree-port\\.sh$',
 ]