@erclx/canon 5.31.0 → 5.32.0

package/src/commands/records.ts

@@ -300,10 +300,10 @@ export function register(program: Command): void {
         'Entries are ordered due first, then those citing a missing path, then the',
         'longest unreviewed, then by name, so a review takes the first N as a batch.',
         '',
-        'canonical: reads REQUIREMENTS.md and ARCHITECTURE.md at whichever surface',
-        'root carries each, in the current worktree since both are tracked. Each',
-        'reports its reviewed date and the release tags merged into HEAD after that',
-        'day, or never when it carries no date. --days does not apply.',
+        'canonical: reads REQUIREMENTS.md at whichever surface root carries it,',
+        'in the current worktree since it is tracked. It reports its reviewed date',
+        'and the release tags merged into HEAD after that day, or never when it',
+        'carries no date. --days does not apply.',
         '',
         'Exit codes:',
         '  0  the reading completed, whatever it found',
@@ -645,7 +645,7 @@ async function runStaleCanonical(
   logStep('Canonical')
 
   if (outcome.docs.length === 0) {
-    logInfo('neither REQUIREMENTS.md nor ARCHITECTURE.md exists')
+    logInfo('REQUIREMENTS.md does not exist')
   } else {
     for (const doc of outcome.docs) logInfo(describeCanonical(doc, outcome))
   }

package/src/commands/sync.ts

@@ -282,7 +282,7 @@ function renderTooling(report: CheckReport): void {
 /**
  * Seeds print their own section because no sync command applies them. A `stale`
  * seed is safe to take whole and a `drifted` one holds edits, which is the split
- * `seed-sync` reads to decide what needs a section-level merge.
+ * that decides what needs a hand merge.
  */
 function renderSeeds(report: CheckReport): void {
   const notable = report.seeds.entries.filter(
@@ -300,7 +300,9 @@ function renderSeeds(report: CheckReport): void {
     logWarn(`${entry.rel} (${entry.state})`)
   }
 
-  logInfo('Run /canon:seed-sync to reconcile these section by section.')
+  logInfo(
+    'A stale seed is safe to take whole. Merge a drifted one by hand against the toolkit copy.',
+  )
 }
 
 /**
@@ -401,7 +403,7 @@ async function runSync(target: string): Promise<number> {
 
   if (existsSync(join(resolved, '.claude'))) {
     process.stderr.write(
-      `${GREY}Tip: run \`/seed-sync\` to audit seed drift per section, preserving local customizations.${NC}\n`,
+      `${GREY}Tip: merge a drifted seed by hand against the toolkit copy, and take a stale one whole.${NC}\n`,
     )
   }
 

package/src/commands/upstream.ts

@@ -1,23 +1,36 @@
 import { resolve } from 'node:path'
+import { $ } from 'bun'
 import type { Command } from 'commander'
 import { intro, logInfo, logStep, logWarn, outro, plural } from '@/cli/ui'
 import { currentWorktreeRoot, mainWorktreeRoot } from '@/git/worktree'
 import { buildCatalog, renderCatalog } from '@/upstream/catalog'
 import {
   advanceCursor,
+  compareVersions,
   llmsDifference,
   readCursor,
   readLastLlms,
 } from '@/upstream/cursor'
 import { buildDigest } from '@/upstream/digest'
+import {
+  decideDue,
+  passesVocabulary,
+  readDueCache,
+  writeDueCache,
+  type DueReason,
+  type Gap,
+} from '@/upstream/due'
 import {
   githubPageFetcher,
   grepHint,
+  keepLines,
+  walkReleases,
   type FetchFailure,
 } from '@/upstream/releases'
 
 const LLMS_URL = 'https://code.claude.com/docs/llms.txt'
 const VERSION = /^\d+(\.\d+)*$/
+const READ_BUDGET_MS = 5000
 
 interface RootOption {
   readonly root?: string
@@ -128,6 +141,33 @@ export function register(program: Command): void {
       process.exitCode = await runCatalog(opts)
     })
 
+  upstream
+    .command('due')
+    .description('Say whether a digest is due, from the cursor and the install')
+    .helpOption('-h, --help', 'Show this help message')
+    .option('--root <path>', 'Repository to read, defaulting to the main root')
+    .option('--json', 'Add a machine-readable record on stdout')
+    .addHelpText(
+      'after',
+      [
+        '',
+        'Due when the cursor is a week old and the installed version is ahead of',
+        'it, or sooner when an Added line in the gap names a canon surface. The',
+        'gap is read from GitHub at most once a day and cached under the scratch',
+        'folder, and a failed read is held for the day as well.',
+        '',
+        'Exit codes:',
+        '  0  answered, whether or not a digest is due',
+        '',
+        'Examples:',
+        '  canon upstream due --json',
+        '',
+      ].join('\n'),
+    )
+    .action(async (opts: RootOption) => {
+      process.exitCode = await runDue(opts)
+    })
+
   upstream
     .command('advance')
     .description('Move the cursor to a version once its digest is filed')
@@ -240,6 +280,101 @@ async function runFetch(opts: FetchOptions): Promise<number> {
   return 0
 }
 
+const DUE_TEXT: Record<DueReason, string> = {
+  'no-cursor': 'No digest has been run, so there is no cursor.',
+  week: 'A week has passed since the last digest.',
+  vocabulary: 'A release since the last digest added something canon may use.',
+  current: 'The installed version is at or below the cursor.',
+  recent:
+    'The last digest is under a week old and nothing in the gap stands out.',
+  'unknown-version': 'The installed version could not be read.',
+}
+
+async function installedVersion(): Promise<string | null> {
+  try {
+    const result = await $`claude --version`.quiet().nothrow()
+    const match = /^\d+(\.\d+)*/.exec(result.stdout.toString().trim())
+
+    return match ? match[0] : null
+  } catch {
+    return null
+  }
+}
+
+// A failed read is stored as a null gap, so a rate limit hit by one session of
+// a wave is not retried by the nineteen after it.
+async function readGap(
+  root: string,
+  installed: string,
+  cursor: string,
+  now: Date,
+): Promise<Gap | null> {
+  const cached = readDueCache(root, installed, cursor, now)
+  if (cached) return cached.gap
+
+  // The hook that calls this has a 10 second timeout, and a network that drops
+  // packets would otherwise hold every session start to it with nothing cached.
+  const walk = await walkReleases(
+    cursor,
+    githubPageFetcher(process.env, AbortSignal.timeout(READ_BUDGET_MS)),
+  )
+  const gap: Gap | null =
+    walk.kind === 'reached'
+      ? {
+          releases: walk.releases.length,
+          lines: walk.releases
+            .flatMap(keepLines)
+            .map((line) => line.text)
+            .filter(passesVocabulary),
+        }
+      : null
+
+  try {
+    await writeDueCache(root, {
+      checkedAt: now.toISOString(),
+      installed,
+      cursor,
+      gap,
+    })
+  } catch {
+    // A cache that cannot be written costs a request, not a wrong answer.
+  }
+
+  return gap
+}
+
+async function runDue(opts: RootOption): Promise<number> {
+  const root = opts.root ? resolve(opts.root) : await mainWorktreeRoot()
+  const now = new Date()
+  const cursor = readCursor(root)
+  const installed = await installedVersion()
+  const isAhead =
+    cursor !== null &&
+    installed !== null &&
+    compareVersions(installed, cursor.version) > 0
+  const gap = isAhead
+    ? await readGap(root, installed, cursor.version, now)
+    : null
+  const result = decideDue({ installed, cursor, gap, now })
+
+  intro('canon upstream due')
+  logStep(result.due ? 'Due' : 'Not due')
+  logInfo(DUE_TEXT[result.reason])
+  outro()
+
+  if (opts.json) {
+    process.stdout.write(
+      `${JSON.stringify({
+        ...result,
+        installed,
+        cursor: cursor?.version ?? null,
+      })}\n`,
+    )
+  }
+
+  return 0
+}
+
 async function runCatalog(opts: RootOption): Promise<number> {
   const root = opts.root ? resolve(opts.root) : await currentWorktreeRoot()
   const catalog = buildCatalog(root)

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,9 +155,8 @@ 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.
@@ -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)
 }