@erclx/canon 5.31.0 → 5.33.0

package/src/commands/claude.ts

@@ -157,21 +157,17 @@ interface RoutingOptions {
   readonly json?: boolean
 }
 
-const SEEDED_FILES: readonly string[] = [
-  'ARCHITECTURE.md',
-  'REQUIREMENTS.md',
-  'DESIGN.md',
-]
-const SEEDED_DIRS: readonly string[] = ['memory', 'tasks', 'wireframes']
+const SEEDED_FILES: readonly string[] = ['REQUIREMENTS.md', 'DESIGN.md']
+const SEEDED_DIRS: readonly string[] = ['tasks']
 
 /**
  * Where a `SEEDED_DIRS` entry resolves for the sync presence check.
  *
- * `wireframes` is a tracked surface entry, resolved under `canon/` ahead of
- * `.claude/`, while `memory` and `tasks` are session records resolved under
- * `.canon/` ahead of `.claude/`. Routing every name through `recordDir`
- * reported a migrated target's `canon/wireframes/` as missing, since that
- * resolver never checks `canon/`.
+ * A tracked surface entry resolves under `canon/` ahead of `.claude/`, while
+ * `tasks` is a session record resolved under `.canon/` ahead of
+ * `.claude/`. Routing every name through `recordDir` would report a migrated
+ * target's surface folder as missing, since that resolver never checks
+ * `canon/`.
  */
 export function seededDirPath(resolved: string, name: string): string {
   return SURFACE_ENTRIES.includes(name)
@@ -390,7 +386,7 @@ export function register(program: Command): void {
   skills
     .command('audit')
     .description(
-      'Report both skill corpora against the mechanical rules in standards/skill.md',
+      'Report both skill corpora against the mechanical rules in claude/skills/create-skill/references/skill.md',
     )
     .argument('[path]', 'Project root, defaulting to the current directory')
     .helpOption('-h, --help', 'Show this help message')
@@ -615,9 +611,7 @@ async function runSync(target: string): Promise<number> {
 
   // A record folder resolves at either root, so a migrated target is reported as
   // seeded rather than sent to `canon claude init` to re-create records it
-  // already holds. `wireframes` is a tracked surface entry instead, resolved
-  // through `surfaceDir`, since a migrated target holds it at `canon/` rather
-  // than under either record root.
+  // already holds.
   logStep('Seeded')
   for (const name of SEEDED_FILES) {
     if (existsSync(join(resolved, '.claude', name))) logInfo(name)

package/src/commands/context.ts

@@ -18,18 +18,6 @@ import {
   requiredSections,
   type SectionFinding,
 } from '@/context/audit'
-import {
-  architectureRel,
-  type ArchitectureReport,
-  coveredCount,
-  isOverCount,
-  isOverLength,
-  isOverRisks,
-  measureArchitecture,
-  missingRevisit,
-  overWords,
-  testableCount,
-} from '@/context/architecture'
 import { auditCitations, type CitationReport } from '@/context/citations'
 import {
   CANONICAL_DOC_TYPES,
@@ -65,10 +53,6 @@ import {
   type RequirementsReport,
 } from '@/context/requirements'
 import { auditIndexes, type FolderDrift } from '@/context/index-drift'
-import {
-  measureWireframeFolder,
-  type WireframeStatesReport,
-} from '@/context/wireframe-states'
 import { RENDER_WIDTH } from '@/markdown/structure'
 import {
   frameError,
@@ -104,7 +88,7 @@ export function register(program: Command): void {
   context
     .command('audit')
     .description(
-      'Report required sections, entry length, citations, reference form, catalog tables, provenance, index drift, the architecture record against its own ceiling, entry cap, word cap, and risk cap, the requirements record against its own word cap, and wireframe states against their evidence folders',
+      'Report required sections, entry length, citations, reference form, catalog tables, provenance, index drift, and the requirements record against its own word cap',
     )
     .argument('[path]', 'Project root, defaulting to the current directory')
     .helpOption('-h, --help', 'Show this help message')
@@ -127,21 +111,14 @@ export function register(program: Command): void {
         '  1  refused, with the reason on stderr',
         '  2  a gating finding is present',
         '',
-        'An unresolved citation always gates. An architecture record that',
-        'states its own line allowances gates when it is past the ceiling',
-        'those derive, on any run except --citations-only, which never',
-        'measures it. A record stating an entry cap gates the same way when',
-        'it holds more decisions than the cap, and a record stating that',
-        'every decision closes with a revisit sentence gates when one lacks',
-        'it. A record stating a word cap a decision or a risk bullet cap',
-        'gates past either, and a requirements record stating a word cap',
-        'gates past it. A record stating none of these is reported and',
-        'never gated. --gate widens the gate to the other two',
-        'findings that are facts rather than judgments: a missing required',
-        'section and index drift. A context entry requires Overview and',
-        'Layout, and a wireframe requires Regions, States, Copy, and Not on',
-        'this surface. Entry length, reference form, table, provenance, and the',
-        'record claim classification are judgments under both.',
+        'An unresolved citation always gates. A requirements record',
+        'stating a word cap gates past it, on any run except',
+        '--citations-only, which never measures it. A record stating no',
+        'cap is reported and never gated. --gate widens the gate to the',
+        'other two findings that are facts rather than judgments: a',
+        'missing required section and index drift. A context entry',
+        'requires Overview and Layout. Entry length, reference form,',
+        'table, and provenance are judgments under both.',
         '',
         'Depth and bullet weight are stated over every markdown file rather',
         'than over a context entry, so `canon markdown audit` measures them.',
@@ -177,7 +154,7 @@ export function register(program: Command): void {
     .option('--base <ref>', 'Far side of the range, defaulting to the trunk')
     .option(
       '--doc-types <list>',
-      `Comma-separated canonical doc types (default: all five: ${CANONICAL_DOC_TYPES.join(', ')})`,
+      `Comma-separated canonical doc types (default: all three: ${CANONICAL_DOC_TYPES.join(', ')})`,
     )
     .option(
       '--backend <name>',
@@ -201,7 +178,7 @@ export function register(program: Command): void {
         'Examples:',
         '  canon context classify diff',
         '  canon context classify diff --base origin/main --json',
-        '  canon context classify diff --doc-types context,wireframes',
+        '  canon context classify diff --doc-types context',
         '',
       ].join('\n'),
     )
@@ -212,13 +189,13 @@ export function register(program: Command): void {
   classify
     .command('sweep')
     .description(
-      'Classify every section of the five canonical doc types, split at H3',
+      'Classify every section of the three canonical doc types, split at H3',
     )
     .argument('[path]', 'Project root, defaulting to the current directory')
     .helpOption('-h, --help', 'Show this help message')
     .option(
       '--doc-types <list>',
-      `Comma-separated canonical doc types (default: all five: ${CANONICAL_DOC_TYPES.join(', ')})`,
+      `Comma-separated canonical doc types (default: all three: ${CANONICAL_DOC_TYPES.join(', ')})`,
     )
     .option(
       '--backend <name>',
@@ -612,7 +589,7 @@ async function runAudit(
     return refuse('bad-folder-list', names, gateOnly, root, opts.json ?? false)
   }
 
-  // The root base is opt-in. A target carrying a root `wireframes/` would
+  // The root base is opt-in. A target carrying a root folder of its own would
   // otherwise be audited against a standard it never adopted, on a bare run
   // that named nothing.
   const named = opts.folder !== undefined
@@ -667,17 +644,7 @@ async function runAudit(
   // Absent under `--citations-only` and null when the project carries no
   // record. A run that never looked and a project with nothing to look at are
   // different answers, and one value for both reports the second as the first.
-  const record = gateOnly ? undefined : await measureArchitecture(root)
   const requirements = gateOnly ? undefined : await measureRequirements(root)
-  const wireframes = gateOnly
-    ? []
-    : (
-        await Promise.all(
-          folders
-            .filter((folder) => folder.name === 'wireframes')
-            .map((folder) => measureWireframeFolder(root, folder)),
-        )
-      ).flat()
 
   if (gateOnly) {
     reportGate(citations)
@@ -691,9 +658,7 @@ async function runAudit(
     reportTables(entries)
     reportProvenance(entries, folders)
     reportDrift(drift)
-    reportRecord(record, root)
     reportRequirements(requirements, root)
-    reportWireframeStates(wireframes)
     outro()
   }
 
@@ -730,22 +695,15 @@ async function runAudit(
         // Null says the run opened the project and found no record, which a
         // target that never wrote one is entitled to. Absent says the run
         // never looked, which is `--citations-only`.
-        architecture: gateOnly ? undefined : (record ?? null),
-        // The same three states for the requirements record.
         requirements: gateOnly ? undefined : (requirements ?? null),
-        // Absent under `--citations-only`, for the same reason as above. An
-        // empty array under the ordinary run says the project carries no
-        // wireframes folder or no entry carrying a States table, which is a
-        // fact rather than an unmeasured run.
-        wireframes: gateOnly ? undefined : wireframes,
         checkpoints: {
           lines: LENGTH_CHECKPOINT,
           renderWidth: RENDER_WIDTH,
           provenanceFolder: PROVENANCE_FOLDER,
           requiredSections: REQUIRED_SECTIONS,
           // Keyed on the audited folder name. The flat key above stays for a
-          // caller that read it before wireframes owed a section, since turning
-          // it into this map would break that caller without an error.
+          // caller that read it first, since removing it would break that
+          // caller without an error.
           requiredSectionsByFolder: REQUIRED_SECTIONS_BY_FOLDER,
         },
       })}\n`,
@@ -754,17 +712,10 @@ async function runAudit(
 
   const gating = isGating({
     unresolvedCitations: citations.unresolved.length,
-    recordOverLength: record !== undefined && isOverLength(record),
-    recordOverCount: record !== undefined && isOverCount(record),
-    recordMissingRevisit:
-      record !== undefined && missingRevisit(record).length > 0,
-    recordOverWords: record !== undefined && overWords(record).length > 0,
-    recordOverRisks: record !== undefined && isOverRisks(record),
     requirementsOverWords:
       requirements !== undefined && isOverWordCap(requirements),
     sections,
     drift,
-    wireframes,
     widened,
   })
 
@@ -945,8 +896,7 @@ function reportReferenceForm(
 
 /**
  * Names the path each finding belongs to, which is an entry in the folder named
- * under `.claude/`, the folder itself in a domain split across one, and the
- * file in any wireframe folder. States
+ * under `.claude/`, and the folder itself in a domain split across one. States
  * the reach on every run for the reason the provenance report does.
  *
  * This prints ahead of the four readability measures because a missing section
@@ -983,7 +933,7 @@ function reportSections(
     )
   }
   logInfo(
-    'A heading at any level counts. Each entry answers for itself, except in a context domain split across a folder, where a sibling answers for the rest. A wireframe answers for itself in every folder.',
+    'A heading at any level counts. Each entry answers for itself, except in a context domain split across a folder, where a sibling answers for the rest.',
   )
 
   if (missing.length === 0) {
@@ -1136,178 +1086,6 @@ function reportProvenance(
   )
 }
 
-/** How each classification reads in the report. */
-const CLAIM_LABEL: Record<string, string> = {
-  countable: 'countable claim',
-  invariant: 'structural invariant',
-  neither: 'reasoning only',
-}
-
-/**
- * Reports the architecture record against the ceiling it states for itself and
- * against what a machine could test in it.
- *
- * The length reading is a fact and gates. Everything below it names candidates
- * a reader adjudicates, because deciding whether a sentence states a claim is a
- * judgment no parser settles, and a stored verdict would age the way the
- * anchors it sits beside already do. Nothing is stored: every run reclassifies,
- * so an entry rewritten tomorrow is read as it stands then.
- */
-function reportRecord(
-  report: ArchitectureReport | undefined,
-  root: string,
-): void {
-  logStep('Architecture record')
-
-  if (report === undefined) {
-    logInfo(
-      `Out of scope. The project carries no ${architectureRel(root)}, so there was no record to measure.`,
-    )
-    return
-  }
-
-  const decisions = report.decisions.length
-  const { allowances } = report
-
-  logInfo(
-    `${plural(report.words, 'word')} across ${plural(report.lines, 'line')}. The whole file's count never gates.`,
-  )
-  if (report.risksWords !== undefined) {
-    logInfo(
-      `\`## Risks / open questions\` holds ${plural(report.risksWords, 'word')}.`,
-    )
-  }
-
-  const longDecisions = overWords(report)
-  if (report.wordCap === undefined) {
-    logInfo(
-      'No word cap a decision stated, so each decision word count is reported and never gated.',
-    )
-  } else if (longDecisions.length > 0) {
-    for (const entry of longDecisions) {
-      logError(
-        `"${entry.heading}" holds ${entry.words} words against a cap of ${report.wordCap} a decision.`,
-      )
-    }
-  } else {
-    logInfo(
-      `Every decision fits the cap of ${report.wordCap} words a decision.`,
-    )
-  }
-
-  if (report.riskCap === undefined) {
-    logInfo('No risk bullet cap stated, so the Risks section is never gated.')
-  } else if (report.risksBullets === undefined) {
-    logWarn(
-      `The record states a cap of ${report.riskCap} risk bullets and carries no \`## Risks / open questions\` section to count.`,
-    )
-  } else if (isOverRisks(report)) {
-    logError(
-      `${plural(report.risksBullets, 'risk bullet')} against a cap of ${report.riskCap}, nested bullets counted.`,
-    )
-  } else {
-    logInfo(
-      `${plural(report.risksBullets, 'risk bullet')} against a cap of ${report.riskCap}, nested bullets counted.`,
-    )
-  }
-
-  if (allowances === undefined) {
-    logInfo(
-      `Covers ${report.rel} alone. No standard sets a length rule for it and this record states none, so its ${plural(report.lines, 'line')} across ${plural(decisions, 'decision')} are reported and nothing is gated.`,
-    )
-    logInfo(
-      'A record declaring an allowance for its frame and one a decision is measured against the ceiling those two derive. That rule belongs to whichever record writes it, never to the toolkit.',
-    )
-  } else {
-    logInfo(
-      `Covers ${report.rel} alone, which states its own allowance of ${plural(allowances.frame, 'line')} for the frame and ${allowances.perDecision} a decision.`,
-    )
-    if (isOverLength(report)) {
-      logError(
-        `${report.lines} lines against a ceiling of ${report.ceiling} from ${plural(decisions, 'decision')}`,
-      )
-    } else {
-      logInfo(
-        `${report.lines} lines against a ceiling of ${report.ceiling} from ${plural(decisions, 'decision')}.`,
-      )
-    }
-    logInfo(
-      `The ceiling rises with the decision count, so adding a decision buys ${allowances.perDecision} lines and the check passes exactly when the file grew.`,
-    )
-  }
-
-  if (report.entryCap === undefined) {
-    logInfo(
-      `${plural(decisions, 'decision')} and no entry cap stated, so the count is reported and never gated.`,
-    )
-  } else if (isOverCount(report)) {
-    logError(
-      `${plural(decisions, 'decision')} against a cap of ${report.entryCap}. Merge two or retire one, never compress.`,
-    )
-  } else {
-    logInfo(
-      `${plural(decisions, 'decision')} against a cap of ${report.entryCap}.`,
-    )
-  }
-
-  const revisited = report.decisions.filter((entry) => entry.revisit).length
-  const lackingRevisit = missingRevisit(report)
-  if (!report.revisitRequired) {
-    logInfo(
-      `${revisited} of ${plural(decisions, 'decision')} close with a revisit sentence, and the record states no revisit clause, so this is reported and never gated.`,
-    )
-  } else if (lackingRevisit.length > 0) {
-    for (const heading of lackingRevisit) {
-      logError(
-        `"${heading}" carries no sentence opening "Revisit when", which the record requires of every decision.`,
-      )
-    }
-  } else {
-    logInfo(
-      `Every one of ${plural(decisions, 'decision')} closes with the revisit sentence the record requires.`,
-    )
-  }
-
-  if (decisions === 0) {
-    logWarn('The record declares no decision, so nothing was classified.')
-    return
-  }
-
-  const testable = testableCount(report)
-  const covered = coveredCount(report)
-
-  logInfo(
-    'A countable claim carries a figure a run could recompute and an invariant quantifies over a named tree a walk could falsify. Both are candidates a reader settles, and neither gates.',
-  )
-  logInfo(
-    'A figure spelled in words reads as uncounted, since a cardinal in prose is pronominal more often than measured. Entries are counted by heading, so a heading carrying several decisions counts once and the total reads low by however many it holds.',
-  )
-  const line = `${testable} of ${decisions} carry a claim a machine could test, ${covered} of which name a check that exists`
-  // A record whose every testable claim names a check has nothing to act on,
-  // and so does one carrying no testable claim at all. Warning on both is how
-  // a section becomes one nobody reads after the second run.
-  if (testable > covered) logWarn(line)
-  else logInfo(`${line}.`)
-  logInfo(
-    'Coverage reads the entry rather than the tree, so a claim some check happens to cover without the entry naming it reads as unchecked.',
-  )
-
-  pipeOutput(
-    report.decisions
-      .map((entry) => {
-        const kind = CLAIM_LABEL[entry.claim] ?? entry.claim
-        const evidence =
-          entry.figures.length > 0 ? `  ${entry.figures.join(' ')}` : ''
-        const checks =
-          entry.checks.length > 0
-            ? `\n  checked by ${entry.checks.join(', ')}`
-            : ''
-        return `${report.rel}:${entry.line}  ${kind}${evidence}  ${plural(entry.words, 'word')}\n  ${entry.heading}${checks}`
-      })
-      .join('\n'),
-  )
-}
-
 /** Reports the requirements record against the word cap it states, if any. */
 function reportRequirements(
   report: RequirementsReport | undefined,
@@ -1353,43 +1131,3 @@ function reportDrift(drift: readonly FolderDrift[]): void {
   logWarn(plural(lines.length, 'disagreement'))
   pipeOutput(lines.join('\n'))
 }
-
-function reportWireframeStates(
-  wireframes: readonly WireframeStatesReport[],
-): void {
-  logStep('Wireframe states')
-
-  const withRows = wireframes.filter((entry) => entry.rows.length > 0)
-  if (withRows.length === 0) {
-    logInfo(
-      'No wireframe carries a States table, so nothing was checked against its evidence folders.',
-    )
-    return
-  }
-
-  const lines = withRows.flatMap((entry) => [
-    ...entry.missingFolders.map(
-      (finding) =>
-        `${entry.rel}:${finding.line}  ${finding.state}  no folder at ${finding.path}`,
-    ),
-    ...entry.unlistedFolders.map(
-      (finding) =>
-        `${entry.rel}  ${finding.root}/${finding.folder}  named in no row`,
-    ),
-    ...(entry.sketchWithEvidence
-      ? [
-          `${entry.rel}:${entry.sketchLine}  a plaintext sketch sits beside evidence that already exists`,
-        ]
-      : []),
-  ])
-
-  if (lines.length === 0) {
-    logInfo(
-      `${plural(withRows.length, 'wireframe')} checked, every state matched one-to-one with its evidence folder.`,
-    )
-    return
-  }
-
-  logWarn(plural(lines.length, 'finding'))
-  pipeOutput(lines.join('\n'))
-}

package/src/commands/feedback.ts

@@ -1,18 +1,13 @@
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
-import type { Command } from 'commander'
+import { Option, type Command } from 'commander'
 import {
   deriveDomainLabels,
-  deriveSlug,
   deriveTitle,
   missingField,
   missingFieldMessage,
 } from '@/feedback/body'
-import { checkoutMismatchWarning, PROJECT_ROOT } from '@/roots/project'
-import { creationRel } from '@/roots/record'
 import { createGithubIssue } from '@/feedback/github'
 import { issueFailureMessage } from '@/feedback/github-format'
-import { frameError, frameSuccess, logWarn, palette } from '@/cli/ui'
+import { frameError, frameSuccess } from '@/cli/ui'
 
 function readStdin(): Promise<string> {
   return new Promise((resolveStream, rejectStream) => {
@@ -25,62 +20,17 @@ function readStdin(): Promise<string> {
   })
 }
 
-function timestamp(): string {
-  const d = new Date()
-  const pad = (n: number): string => n.toString().padStart(2, '0')
-  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`
-}
-
-/**
- * A registry install ships no `.claude/`, so a local write would land inside
- * `node_modules/` and report a project-relative path the operator cannot find.
- * The toolkit source is the only root where local scratch reaches a maintainer.
- */
-function isToolkitSource(): boolean {
-  return existsSync(join(PROJECT_ROOT, '.claude'))
-}
-
-/**
- * One producer, one record folder. Feedback is not a review, so it writes
- * under a root folder of its own rather than inside `review/`, and `canon
- * records push` backs it with no list edit, since it carries every `.canon/`
- * entry it does not exclude.
- */
-function writeLocal(body: string, mismatch: string | undefined): string {
-  // Resolved against the same root the write joins onto. `creationRel` reads
-  // whichever root already carries a `feedback/` folder and falls back to the
-  // creation root when neither does.
-  const relativeDir = creationRel(PROJECT_ROOT, 'feedback')
-  const feedbackDir = join(PROJECT_ROOT, relativeDir)
-  mkdirSync(feedbackDir, { recursive: true })
-  const filename = `feedback-${deriveSlug(body)}-${timestamp()}.md`
-  const filePath = join(feedbackDir, filename)
-  writeFileSync(filePath, `${body}\n`, 'utf8')
-
-  // Manual frame rather than `frameSuccess`, since the mismatch warning is a
-  // frame-interior line landing between the opener and the command title,
-  // matching the convention `#1587` set at its other six sites.
-  const { GREEN, GREY, NC, WHITE } = palette(process.stderr)
-  process.stderr.write(`${GREY}┌${NC}\n`)
-  if (mismatch !== undefined) logWarn(mismatch)
-  process.stderr.write(
-    `${GREY}│${NC} ${WHITE}canon feedback${NC}\n${GREY}│${NC}\n${GREY}│${NC} ${GREEN}✓${NC} ${join(relativeDir, filename)}\n${GREY}└${NC}\n`,
-  )
-  return filePath
-}
-
 export function register(program: Command): void {
   program
     .command('feedback')
     .helpOption('-h, --help', 'Show this help message')
     .description(
-      'Write toolkit feedback from stdin to .canon/feedback/, or open a GitHub issue with --github',
-    )
-    .option(
-      '--github',
-      'Open a GitHub issue on the toolkit repo instead of writing local scratch',
+      'Open a GitHub issue on the toolkit repo from a feedback block on stdin',
     )
-    .action(async (opts: { github?: boolean }) => {
+    // A cached plugin still pipes `--github`, and commander rejects an unknown
+    // option, so the flag stays accepted and hidden for one release.
+    .addOption(new Option('--github').hideHelp())
+    .action(async () => {
       if (process.stdin.isTTY) {
         frameError(
           'No feedback on stdin. Pipe a markdown block: pbpaste | canon feedback',
@@ -95,8 +45,8 @@ export function register(program: Command): void {
         return
       }
 
-      // Both write paths, not `--github` alone. A report missing its surface is
-      // no more useful sitting in the triage queue on disk than in the tracker.
+      // A report missing its surface is no more useful in the tracker than
+      // anywhere else, so validation runs before any `gh` call.
       const absent = missingField(body)
       if (absent) {
         frameError(missingFieldMessage(absent))
@@ -104,39 +54,20 @@ export function register(program: Command): void {
         return
       }
 
-      if (opts.github) {
-        const result = await createGithubIssue({
-          title: deriveTitle(body),
-          body,
-          labels: ['feedback', ...deriveDomainLabels(body)],
-        })
-        if (result.ok) {
-          frameSuccess('canon feedback', result.url)
-          process.stdout.write(`${result.url}\n`)
-          return
-        }
-        const reason = issueFailureMessage(result)
-        if (!isToolkitSource()) {
-          frameError(reason)
-          process.exitCode = 1
-          return
-        }
-        const { NC, YELLOW } = palette(process.stderr)
-        process.stderr.write(
-          `${YELLOW}! ${reason} Wrote local scratch instead.${NC}\n`,
-        )
-      }
-
-      if (!isToolkitSource()) {
-        frameError(
-          'Local scratch needs the toolkit source. Re-run with --github to open an issue instead.',
-        )
-        process.exitCode = 1
+      const result = await createGithubIssue({
+        title: deriveTitle(body),
+        body,
+        labels: ['feedback', ...deriveDomainLabels(body)],
+      })
+      if (result.ok) {
+        frameSuccess('canon feedback', result.url)
+        process.stdout.write(`${result.url}\n`)
         return
       }
-
-      const mismatch = checkoutMismatchWarning(process.cwd())
-      const filePath = writeLocal(body, mismatch)
-      process.stdout.write(`${filePath}\n`)
+      // The block goes to stdout so the session can paste it where the issue
+      // would have gone, and the reason frames on stderr.
+      frameError(issueFailureMessage(result))
+      process.stdout.write(`${body}\n`)
+      process.exitCode = 1
     })
 }

package/src/commands/gov.ts

@@ -12,7 +12,6 @@ import { checkoutMismatchWarning, PROJECT_ROOT } from '@/roots/project'
 import { creationRel, SCRATCH } from '@/roots/record'
 import { createGovAdapter } from '@/gov/adapter'
 import { regenConsumedRules } from '@/gov/consumed'
-import { regenStandardRules } from '@/gov/standard-rules'
 import { installRules, lookupRules } from '@/gov/install'
 import { buildGovCatalog, describeRule, describeStack } from '@/gov/list'
 import { buildRulesPayload, listRuleFiles } from '@/gov/payload'
@@ -191,18 +190,14 @@ export function register(program: Command): void {
 
   gov
     .command('regen')
-    .description(
-      "Rebuild the standard-pointer rules and a repository's own .claude/rules/",
-    )
+    .description("Rebuild a repository's own .claude/rules/")
     .helpOption('-h, --help', 'Show this help message')
     .option('--root <path>', 'Repository root to regenerate', PROJECT_ROOT)
     .addHelpText(
       'after',
       [
         '',
-        'First writes governance/rules/standards/ from the paths: and rule:',
-        'fields in each standard under standards/. Then reads',
-        'internal/governance.toml and installs the stack it names, plus any',
+        'Reads internal/governance.toml and installs the stack it names, plus any',
         'rules under internal/rules/. Unlike install and sync, this runs',
         'against the toolkit root, whose .claude/rules/ is produced output.',
         '',
@@ -1121,14 +1116,6 @@ async function runRegen(
 
   const root = resolve(opts.root ?? PROJECT_ROOT)
 
-  // The consumed copy installs from `governance/rules/`, so the band this
-  // writes has to be fresh before that copy is built from it.
-  const generated = await regenStandardRules(root)
-  if (!generated.ok) {
-    process.stderr.write(`Standard-rules regen failed: ${generated.reason}\n`)
-    return 1
-  }
-
   const result = await regenConsumedRules(root)
 
   if (!result.ok) {