@erclx/aitk 1.3.0 → 1.5.0

package/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "aitk",
   "description": "Automated governance, versioning, and discovery tools for Claude Code.",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "author": {
     "name": "Eric Le",
     "url": "https://github.com/erclx"

package/docs/agents/context-audit-checks.md

@@ -1,11 +1,11 @@
 ---
 title: Context audit checks
-description: What each non-gating check reports, the unit each checkpoint is measured in, which folders each check reaches, and what moved to the attribute tier
+description: What each non-gating check reports, the unit each checkpoint is measured in, the architecture record's length gate and claim coverage, which folders each check reaches, and what moved to the attribute tier
 ---
 
 # Context audit checks
 
-What each finding from `aitk context audit` means. The command surface, its flags, and the one gating check are in `context-audit.md`.
+What each finding from `aitk context audit` means. The command surface, its flags, and the two gating checks are in `context-audit.md`.
 
 ## Required sections
 
@@ -87,6 +87,22 @@ A rejected alternative is a back-reference in the past tense by construction, an
 
 The JSON record carries the findings per entry as `entries[].narration` and the sets as `checkpoints.narration`, which is absent under `--citations-only` where the run never loads them and null where no rule publishes both.
 
+## The architecture record
+
+Two findings read `.claude/ARCHITECTURE.md` rather than a folder, and only the first is a fact.
+
+The length check compares the record against the ceiling it derives for itself, and only a record that states its own allowances has one. No standard sets a length rule for this document, so the numbers belong to whichever record declares them. The check reads a frame allowance and an allowance per decision out of the record's own prose and puts the ceiling at the frame plus the allowance times the decision count. The JSON record carries what it read as `architecture.allowances` and the reading as `architecture.lines` against `architecture.ceiling`.
+
+A record stating no such rule is measured and reported and never gated, which is the ordinary shape of a project that wrote an architecture record and no convention about its length. Holding a pair of numbers in the toolkit and gating every project against them would fail a record on a ceiling that project never agreed to, and the framed line would credit the rule to a file that does not state it.
+
+What the derivation costs where it does apply is that the ceiling rises when a decision is added and falls for nothing, so the check passes exactly when the file grew. It gates anyway, because a record that states a limit for itself and makes it computable from a count has turned it into a fact, which is what separates it from every judgment below. A rewrite of the declaring sentence past the clauses the check reads falls back to reporting rather than to a stale ceiling, so the failure shows up in the run's own output.
+
+The coverage report classifies each decision as carrying a countable claim, a structural invariant, or neither, then reports each testable entry against whether it names a check that exists. A countable claim carries a figure a run could recompute, and an invariant quantifies over a named tree closely enough that a walk could falsify it. A check is a `scripts/**.sh` path the entry spells that is on disk, or an `aitk` invocation matching a registered audit, so coverage reads the entry rather than the tree and a claim some check happens to cover without the entry saying so reads as unchecked.
+
+Three limits are stated on every run rather than hidden. The countable signal reads digits alone, so a measured claim written in words reads as uncounted. Entries are counted by heading, and one heading holding several decisions counts once. Nothing is stored, so an entry rewritten tomorrow is classified afresh the next time the verb runs and no verdict goes stale.
+
+The report gates nothing. Deciding whether a sentence states a claim is a judgment no parser settles, so the output names candidates for a reader. This answers a different question from the verification anchors `.claude/standards/architecture.md` describes, which record that one cited number was re-read. That mechanism says whether a marked figure held, and this one says how much of the record could be checked at all.
+
 ## Which folders each check reaches
 
 The provenance, required-section, and narration checks cover `.claude/context/` alone, the reference-form check covers the split folders inside it, and length and the table finding reach every audited folder.

package/docs/agents/context-audit.md

@@ -5,7 +5,7 @@ description: Running the audit, its flags and folder scope, the exit codes, the
 
 # Context audit
 
-`aitk context audit [path]` reports the structural state of the folders following the index-plus-entry contract, meaning a generated `index.md` beside entries carrying frontmatter. It reads and reports. Fixing what it finds is separate work. What each finding means is in `context-audit-checks.md`.
+`aitk context audit [path]` reports the structural state of the folders following the index-plus-entry contract, meaning a generated `index.md` beside entries carrying frontmatter, and it measures `.claude/ARCHITECTURE.md` beside them. It reads and reports. Fixing what it finds is separate work. What each finding means is in `context-audit-checks.md`.
 
 Findings stated over every markdown file rather than over a context entry are measured by `aitk markdown audit`, described in `markdown-audit.md`. That command resolves no folder, so it reaches trees this one refuses.
 
@@ -37,7 +37,7 @@ A run where no requested name resolves refuses, whichever list it read. Naming t
 
 ## Exit codes
 
-Exit codes are `0` for a clean run, `1` for a refusal, and `2` for a gating finding. An unresolved citation gates under every mode. Length, reference form, table, provenance, and narration findings print and return `0` under every mode, because each is a judgment and failing a push on one would make the check something to route around. Narration is the weakest of the five, since whether two bullets share a subject is a call the measure approximates from structure alone, and one of the shapes it matches is the rejected alternative the standard asks an entry to keep.
+Exit codes are `0` for a clean run, `1` for a refusal, and `2` for a gating finding. An unresolved citation gates under every mode. An architecture record that states its own line allowances gates when it is past the ceiling those derive, on any run that measures it, which is every mode except `--citations-only`, and a record stating none is reported and never gated. Entry length, reference form, table, provenance, narration, and the record's claim classification print and return `0` under every mode, because each is a judgment and failing a push on one would make the check something to route around. Narration is the weakest of the five, since whether two bullets share a subject is a call the measure approximates from structure alone, and one of the shapes it matches is the rejected alternative the standard asks an entry to keep.
 
 Required-section and index findings sit between the two. Both are answerable from the file rather than weighed, so `--gate` promotes them to failing codes while a bare run leaves them advisory. The toolkit runs the bare form against itself and the widened form against the seed tree, described below.
 
@@ -47,7 +47,7 @@ Required-section and index findings sit between the two. Both are answerable fro
 
 The widened gate is correct here and wrong at the project root. A seed is authored once and read by every target, while a context entry in a live project is edited under time pressure by the people who own it. A missing section in the first is a defect shipping outward, and in the second it is a threshold worth reporting and not worth blocking a push over.
 
-Coverage follows the index-plus-entry contract, so it reaches seeded entries and the indexes beside them. Seed files sitting directly under `.claude/`, currently `ARCHITECTURE.md`, `DESIGN.md`, and `REQUIREMENTS.md`, belong to no audited folder and stay outside it.
+Coverage follows the index-plus-entry contract, so it reaches seeded entries and the indexes beside them. `DESIGN.md` and `REQUIREMENTS.md` sitting directly under `.claude/` belong to no audited folder and stay outside it, while `ARCHITECTURE.md` is measured on its own path. The seed record states no line allowance, so it is reported rather than gated, which is what a seed template showing the shape of a record should be.
 
 The stage prints the entries it measured per root and warns on a root that measured none. A root can resolve an audited folder and hold no entry in it, which `tooling/claude/seeds` does today, so a single pass line over the set would report coverage of a tree nothing opened.
 

package/docs/agents/index.md

@@ -12,7 +12,7 @@ CLI catalog and invocation rules for agents, split by command domain. Start with
 - [Capture](capture.md): Rendering committed HTML sources to PNG, what the command asserts about fonts, and why it is toolkit-only
 - [Command catalog](commands.md): Every project-level command and every domain subcommand, plus the shape each domain exposes
 - [Comments](comments.md): Comment density by language and kind, the two structural exclusions, and how the degradation sweep finds its vocabulary
-- [Context audit checks](context-audit-checks.md): What each non-gating check reports, the unit each checkpoint is measured in, which folders each check reaches, and what moved to the attribute tier
+- [Context audit checks](context-audit-checks.md): What each non-gating check reports, the unit each checkpoint is measured in, the architecture record's length gate and claim coverage, which folders each check reaches, and what moved to the attribute tier
 - [Context audit](context-audit.md): Running the audit, its flags and folder scope, the exit codes, the citation gate, and the widened gate the seed stage runs
 - [Docs](docs.md): How aitk docs resolves the toolkit's own reference surface from an install root, and how a split domain is named
 - [Indexes](indexes.md): Flags, exit codes, and JSON shape for aitk indexes regen, plus when it auto-stages what it rewrote

package/docs/agents/output-shape.md

@@ -46,6 +46,19 @@ Help skips the banner. The `Usage:` line sits directly on `├`. Help writes to
 
 `--json` and `--names` keep stdout clean and machine-readable. The frame still renders on stderr (open, banner, close) so the stream discipline is consistent across modes. Consumers that only read stdout see pure data.
 
+## Color
+
+Escape sequences reach a destination that renders them and nowhere else. The question is asked per stream rather than once for the process, so a run piping its data while keeping a terminal on stderr still gets color on the frame.
+
+Either condition alone turns color off:
+
+- `NO_COLOR` is set to any non-empty value, whatever that value says
+- The destination is not a terminal, which covers a pipe, a file, and a captured session
+
+The frame survives both. `┌`, `│`, `├`, `└`, and the `✓ ! + - ✗` marks are structure rather than color, and they are what lets a captured run still read as one block. A caller wanting neither the frame nor the color reads `--json` instead.
+
+Terminal control is a separate question this section does not cover. The cursor and key sequences an interactive prompt writes run only where a terminal already exists.
+
 ## Process exit
 
 A command action sets `process.exitCode` and returns. Calling `process.exit()` there ends the process before a stdout write drains, which truncates piped output at the 64K pipe buffer while still reporting the right exit code. Redirecting to a file hides the truncation, so it surfaces only through a pipe, which is what a check has to use to catch it.

package/docs/visual-design-workflow.md

@@ -24,6 +24,8 @@ The toolkit seed in `tooling/claude/seeds/.claude/DESIGN.md` ships a token-table
 
 The `aitk:claude-design-extract` skill drafts the file, sourcing tokens from a project's existing prose and CLI UI surfaces, or proposing them from `.claude/REQUIREMENTS.md` and a `## Personality` paragraph when no UI code exists yet. `aitk design render` writes an HTML plus CSS preview to `.claude/review/design/` for eyeballing the current system without leaving Claude Code. See `.claude/context/design.md`.
 
+A cell no source anchors ends in `? verify`, and the preview shows that marker beside the value rather than folding it in, so a swatch and a font sample stay built from the value alone. A confidence line above the sections names how many cells are anchored against how many are tagged, which is what tells a reader whether they are looking at a record of the code or a proposal about it. It reads the columns a source could anchor and leaves out the row names, so the ratio is not diluted by cells no tag could ever reach. The proposal path tags nearly all of them, so that count reads low on day one by design.
+
 ### Tools
 
 - None beyond Claude Code itself

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@erclx/aitk",
   "type": "module",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "Infrastructure and quality tooling for developer workflows",
   "license": "MIT",
   "bin": {

package/src/audits/catalog.ts

@@ -103,6 +103,61 @@ function allOf(
   return counts
 }
 
+/**
+ * Reads the architecture record's three measures, or nothing when the project
+ * carries no record.
+ *
+ * Three states rather than two, matching what the verb publishes. The key
+ * absent is a run that never opened the record, which the aggregate never asks
+ * for and so reads as a shape that moved. Null is a project entitled to carry
+ * no record, whose other context counts still stand, so it contributes no key
+ * rather than a zero that would read as a conforming record.
+ */
+function architectureCounts(
+  root: Record<string, unknown>,
+): Record<string, number> | undefined | 'absent' {
+  if (!('architecture' in root)) return undefined
+  if (root.architecture === null) return 'absent'
+
+  const record = asObject(root.architecture)
+  const decisions = record?.decisions
+  if (
+    record === undefined ||
+    !Array.isArray(decisions) ||
+    typeof record.lines !== 'number'
+  ) {
+    return undefined
+  }
+
+  // A record stating no length rule has no ceiling to be past, and reporting
+  // zero there would read as one measured and found conforming.
+  const ceiling =
+    typeof record.ceiling === 'number' ? record.ceiling : undefined
+
+  let unverifiable = 0
+  let unchecked = 0
+  for (const raw of decisions) {
+    const entry = asObject(raw)
+    const claim = entry?.claim
+    const checks = lengthOf(entry?.checks)
+    if (typeof claim !== 'string' || checks === undefined) return undefined
+
+    if (claim === 'neither') unverifiable += 1
+    else if (checks === 0) unchecked += 1
+  }
+
+  return {
+    // A boolean, counted so the aggregate reads it the way it reads every
+    // other measure. The verb gates on it separately, and the key is absent
+    // rather than zero on a record that declared no ceiling.
+    ...(ceiling !== undefined && {
+      recordOverLength: record.lines > ceiling ? 1 : 0,
+    }),
+    recordUnverifiable: unverifiable,
+    recordUnchecked: unchecked,
+  }
+}
+
 function contextCounts(record: unknown): Record<string, number> | undefined {
   const root = asObject(record)
   if (root === undefined) return undefined
@@ -117,13 +172,19 @@ function contextCounts(record: unknown): Record<string, number> | undefined {
     bareReferences += bare
   }
 
-  return allOf({
+  const architecture = architectureCounts(root)
+  if (architecture === undefined) return undefined
+
+  const counts = allOf({
     unresolvedCitations: lengthOf(asObject(root.citations)?.unresolved),
     longEntries: lengthOf(root.length),
     missingSections: lengthOf(root.missingSections),
     indexDrift: lengthOf(root.indexDrift),
     bareReferences,
   })
+
+  if (counts === undefined) return undefined
+  return architecture === 'absent' ? counts : { ...counts, ...architecture }
 }
 
 function markdownCounts(record: unknown): Record<string, number> | undefined {

package/src/cli.ts

@@ -28,12 +28,12 @@ import { register as sessions } from '@/commands/sessions'
 import { register as audits } from '@/commands/audits'
 import { register as upgrade } from '@/commands/upgrade'
 import { readInstalled, UNKNOWN_LABEL } from '@/version/installed'
-
-const GREY = '\x1b[0;90m'
-const WHITE = '\x1b[1;37m'
-const NC = '\x1b[0m'
+import { palette } from '@/ui'
 
 function showHelp(): void {
+  // The help text is the one framed surface written to stdout, so it asks
+  // about that stream rather than the stderr every other writer here uses.
+  const { GREY, NC, WHITE } = palette(process.stdout)
   const lines = [
     `${GREY}┌${NC}`,
     `${GREY}├${NC} ${WHITE}Usage:${NC} aitk [command]`,

package/src/commands/claude.ts

@@ -44,16 +44,13 @@ import {
   logStep,
   logWarn,
   outro,
+  palette,
   pipeOutput,
   plural,
   select,
 } from '@/ui'
 import { describeSkew, readSkew, type SkewReport } from '@/version/skew'
 
-const GREEN = '\x1b[0;32m'
-const GREY = '\x1b[0;90m'
-const NC = '\x1b[0m'
-
 interface SeedsListOptions {
   readonly json?: boolean
   readonly names?: boolean
@@ -266,6 +263,7 @@ export function register(program: Command): void {
 }
 
 function succeed(message: string): number {
+  const { GREEN, NC } = palette(process.stderr)
   outro()
   process.stderr.write(`${GREEN}✓ ${message}${NC}\n`)
   return 0
@@ -472,6 +470,7 @@ async function runSeedsList(opts: SeedsListOptions): Promise<number> {
     return 0
   }
 
+  const { GREY, NC } = palette(process.stderr)
   intro('aitk claude')
   logStep('Seed docs')
   for (const listing of listings) {
@@ -531,6 +530,7 @@ async function runSkillsDrift(
     // is the moment a skew warning is worth most, since an old binary is one
     // reason the cache and the CLI disagree in the first place.
     if (skew.state === 'behind') {
+      const { GREY, NC } = palette(process.stderr)
       process.stderr.write(`${GREY}${describeSkew(skew)}${NC}\n`)
     }
   }

package/src/commands/context.ts

@@ -15,6 +15,14 @@ import {
   REQUIRED_SECTIONS,
   type SectionFinding,
 } from '@/context/audit'
+import {
+  type ArchitectureReport,
+  coveredCount,
+  isOverLength,
+  measureArchitecture,
+  RECORD_REL,
+  testableCount,
+} from '@/context/architecture'
 import { auditCitations, type CitationReport } from '@/context/citations'
 import {
   type AuditedFolder,
@@ -65,7 +73,7 @@ export function register(program: Command): void {
   context
     .command('audit')
     .description(
-      'Report required sections, entry length, citations, reference form, catalog tables, provenance, superseded-decision narration, and index drift',
+      'Report required sections, entry length, citations, reference form, catalog tables, provenance, superseded-decision narration, index drift, and the architecture record against its own ceiling',
     )
     .argument('[path]', 'Project root, defaulting to the current directory')
     .helpOption('-h, --help', 'Show this help message')
@@ -88,11 +96,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. --gate widens the gate to the',
-        'other two findings that are facts rather than judgments: a missing',
-        'required section and index drift. Length, reference form, table,',
-        'provenance, and narration findings are judgments and stay advisory',
-        'under both.',
+        '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 no allowance 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. Entry length, reference form, table, provenance, narration,',
+        'and the record claim classification are judgments under both.',
         '',
         'Depth and bullet weight are stated over every markdown file rather',
         'than over a context entry, so `aitk markdown audit` measures them.',
@@ -205,6 +216,12 @@ async function runAudit(
   const drift = gateOnly ? [] : await auditIndexes(folders)
   const sections = gateOnly ? [] : missingSections(root, folders, entries)
   const length = gateOnly ? undefined : lengthFindings(entries)
+  // Absent under `--citations-only` and null when the project carries no
+  // record, for the reason `checkpoints.narration` states about its own two
+  // absences. 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)
 
   if (gateOnly) {
     reportGate(citations)
@@ -219,6 +236,7 @@ async function runAudit(
     reportProvenance(entries, folders)
     reportNarration(entries, folders, narration)
     reportDrift(drift)
+    reportRecord(record)
     outro()
   }
 
@@ -251,6 +269,10 @@ async function runAudit(
         length,
         missingSections: sections,
         indexDrift: drift,
+        // 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),
         checkpoints: {
           lines: LENGTH_CHECKPOINT,
           renderWidth: RENDER_WIDTH,
@@ -277,6 +299,7 @@ async function runAudit(
 
   const gating = isGating({
     unresolvedCitations: citations.unresolved.length,
+    recordOverLength: record !== undefined && isOverLength(record),
     sections,
     drift,
     widened,
@@ -696,6 +719,101 @@ function reportNarration(
   )
 }
 
+/** 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): void {
+  logStep('Architecture record')
+
+  if (report === undefined) {
+    logInfo(
+      `Out of scope. The project carries no ${RECORD_REL}, so there was no record to measure.`,
+    )
+    return
+  }
+
+  const decisions = report.decisions.length
+  const { allowances } = report
+
+  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 (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}\n  ${entry.heading}${checks}`
+      })
+      .join('\n'),
+  )
+}
+
 function reportDrift(drift: readonly FolderDrift[]): void {
   logStep('Index drift')
 

package/src/commands/design.ts

@@ -2,12 +2,7 @@ import { existsSync } from 'node:fs'
 import { resolve } from 'node:path'
 import type { Command } from 'commander'
 import { renderDesignDoc } from '@/design/render'
-
-const GREY = '\x1b[0;90m'
-const WHITE = '\x1b[1;37m'
-const RED = '\x1b[0;31m'
-const GREEN = '\x1b[0;32m'
-const NC = '\x1b[0m'
+import { palette } from '@/ui'
 
 export function register(program: Command): void {
   const design = program
@@ -22,6 +17,7 @@ export function register(program: Command): void {
     .action((opts: { source: string; out: string }) => {
       const sourcePath = resolve(process.cwd(), opts.source)
       const outDir = resolve(process.cwd(), opts.out)
+      const { GREEN, GREY, NC, RED, WHITE } = palette(process.stderr)
       if (!existsSync(sourcePath)) {
         process.stderr.write(
           `${GREY}┌${NC}\n${GREY}│${NC} ${RED}✗${NC} ${opts.source} not found\n${GREY}└${NC}\n`,

package/src/commands/feedback.ts

@@ -4,10 +4,7 @@ import type { Command } from 'commander'
 import { deriveSlug, deriveTitle } from '@/commands/feedback-format'
 import { PROJECT_ROOT } from '@/project-root'
 import { createGithubIssue } from '@/github'
-import { frameError, frameSuccess } from '@/ui'
-
-const YELLOW = '\x1b[0;33m'
-const NC = '\x1b[0m'
+import { frameError, frameSuccess, palette } from '@/ui'
 
 function readStdin(): Promise<string> {
   return new Promise((resolveStream, rejectStream) => {
@@ -88,6 +85,7 @@ export function register(program: Command): void {
           process.exitCode = 1
           return
         }
+        const { NC, YELLOW } = palette(process.stderr)
         process.stderr.write(
           `${YELLOW}! gh unavailable, wrote local scratch instead${NC}\n`,
         )

package/src/commands/gov.ts

@@ -30,12 +30,10 @@ import {
   logStep,
   logWarn,
   outro,
+  palette,
   select,
 } from '@/ui'
 
-const GREEN = '\x1b[0;32m'
-const NC = '\x1b[0m'
-
 const PAYLOAD_REL = join('.claude', '.tmp', 'gov', 'rules.md')
 const RULES_REL = join('.claude', 'rules')
 
@@ -461,6 +459,7 @@ async function runInstall(
     )
   }
 
+  const { GREEN, NC } = palette(process.stderr)
   outro()
   process.stderr.write(`${GREEN}✓ Rules installed${NC}\n`)
   return 0
@@ -510,6 +509,7 @@ async function runBuild(target: string): Promise<number> {
   await writeFile(output, buildRulesPayload(files))
   logAdd(PAYLOAD_REL)
 
+  const { GREEN, NC } = palette(process.stderr)
   outro()
   process.stderr.write(
     `${GREEN}✓ Rules built (${files.length} rules → ${PAYLOAD_REL})${NC}\n`,

package/src/commands/init.ts

@@ -6,11 +6,7 @@ import { type InitFlags, parseSkip, planInit } from '@/init/plan'
 import { runDomains } from '@/init/run'
 import { buildSteps } from '@/init/steps'
 import { resolveTarget } from '@/target'
-import { intro, logInfo, logStep, logWarn, outro, select } from '@/ui'
-
-const GREEN = '\x1b[0;32m'
-const YELLOW = '\x1b[0;33m'
-const NC = '\x1b[0m'
+import { intro, logInfo, logStep, logWarn, outro, palette, select } from '@/ui'
 
 interface InitOptions {
   /** Always present: the option falls back to `DEFAULT_STACK`. */
@@ -107,6 +103,8 @@ async function runInit(
   outro()
   process.stderr.write('\n')
 
+  const { GREEN, NC, YELLOW } = palette(process.stderr)
+
   if (failed.length === 0) {
     process.stderr.write(
       `${GREEN}✓ Project initialized (${plan.total} domains)${NC}\n`,

package/src/commands/slides.ts

@@ -5,12 +5,7 @@ import { LAYOUTS } from '@/slides/layouts'
 import { openDeck } from '@/slides/open'
 import { renderSlidesDoc } from '@/slides/render'
 import type { Variant } from '@/slides/styles'
-import { intro, outro } from '@/ui'
-
-const GREY = '\x1b[0;90m'
-const GREEN = '\x1b[0;32m'
-const RED = '\x1b[0;31m'
-const NC = '\x1b[0m'
+import { intro, outro, palette } from '@/ui'
 
 export function register(program: Command): void {
   const slides = program
@@ -44,6 +39,7 @@ export function register(program: Command): void {
           }
           const variant = parseVariant(opts.variant)
           const mirror = resolveMirror(opts.mirror)
+          const { GREEN, GREY, NC, RED } = palette(process.stderr)
           intro('Render slides')
           const result = await renderSlidesDoc(sourcePath, outDir, {
             variant,
@@ -81,6 +77,7 @@ export function register(program: Command): void {
         process.stdout.write(`${JSON.stringify(LAYOUTS)}\n`)
         return
       }
+      const { GREEN, GREY, NC } = palette(process.stderr)
       intro('Slide layouts')
       for (const layout of LAYOUTS) {
         process.stderr.write(
@@ -121,6 +118,7 @@ function fail(message: string): never {
  */
 function reportFailure(error: unknown): void {
   if (!(error instanceof SlidesError)) throw error
+  const { GREY, NC, RED } = palette(process.stderr)
   process.stderr.write(
     `${GREY}┌${NC}\n${GREY}│${NC} ${RED}✗${NC} ${error.message}\n${GREY}└${NC}\n`,
   )

package/src/commands/snippets.ts

@@ -21,12 +21,10 @@ import {
   logStep,
   logWarn,
   outro,
+  palette,
   select,
 } from '@/ui'
 
-const GREEN = '\x1b[0;32m'
-const NC = '\x1b[0m'
-
 const SNIPPETS_REL = '.claude/snippets'
 
 const PASS_THROUGH_VERBS = ['create'] as const
@@ -180,6 +178,7 @@ async function runInstall(
   }
   await recordStamp(createSnippetsAdapter(PROJECT_ROOT), resolved, new Date())
 
+  const { GREEN, NC } = palette(process.stderr)
   outro()
   process.stderr.write(`${GREEN}✓ Snippets installed${NC}\n`)
   return 0

package/src/commands/standards.ts

@@ -21,13 +21,10 @@ import {
   logStep,
   logWarn,
   outro,
+  palette,
   select,
 } from '@/ui'
 
-const GREEN = '\x1b[0;32m'
-const GREY = '\x1b[0;90m'
-const NC = '\x1b[0m'
-
 interface InstallOptions {
   /** Always present: the option falls back to `ALL_SELECTION`. */
   readonly only: string
@@ -196,6 +193,7 @@ async function runInstall(target: string, selection: string): Promise<number> {
   await recordStamp(createStandardsAdapter(PROJECT_ROOT), resolved, new Date())
 
   outro()
+  const { GREEN, GREY, NC } = palette(process.stderr)
   process.stderr.write(
     `\n${GREEN}✓ Standards installed${NC} ${GREY}(${files.length} files)${NC}\n`,
   )