@natjswenson/press 0.1.0

package/lib/lint.mjs

@@ -0,0 +1,130 @@
+/**
+ * The brand lint — the mechanical half of laws.md.
+ *
+ * Every rule here exists because a real artifact shipped wrong: a résumé that
+ * looked perfect and was unparseable to an ATS, a PDF where the warning glyph
+ * turned into a second loud color, a card that drifted a hex by one digit. Prose
+ * rules an agent reads are necessary but not sufficient; these are the ones a
+ * machine can hold.
+ *
+ * Every rule is two-sided in the tests: a real artifact must pass, and a mutated
+ * copy of that same artifact must fail. A one-sided lint rots silently the day
+ * someone weakens the checker.
+ */
+export const RULES = [
+  'off-palette-hex',
+  'tracking-max',
+  'emoji-presentation',
+  'no-shadow',
+  'no-gradient',
+  'no-radius',
+  'accent-cap',
+];
+
+const HEX_RE = /#[0-9a-fA-F]{3,8}\b/g;
+const TRACKING_RE = /letter-spacing\s*:\s*(-?[\d.]+)\s*em/gi;
+// The negative lookahead sits immediately after the colon: with a `\s*` in
+// front of it the engine backtracks to zero width and steps straight past the
+// guard, so `box-shadow: none` would report as a shadow.
+const SHADOW_RE = /\b(box|text)-shadow\s*:(?!\s*none\b)/gi;
+const GRADIENT_RE = /\b(linear|radial|conic)-gradient\s*\(/gi;
+const RADIUS_RE = /\bborder-radius\s*:(?!\s*0[a-z%]*\s*[;}!])/gi;
+/** U+26A0 not already followed by the text-presentation selector U+FE0E. */
+const BARE_WARN_RE = /⚠(?!︎)/g;
+
+const DISABLE_RE = /press-lint-disable-next-line\s+([a-z-]+(?:\s*,\s*[a-z-]+)*)/;
+
+/**
+ * @param {string} text     file contents
+ * @param {object} tokens   resolved token set
+ * @param {object} options  { file, waivers: string[], accentCap: number|null,
+ *                            rules: string[] }
+ */
+export function lintText(text, tokens, options = {}) {
+  const file = options.file ?? '<input>';
+  const enabled = new Set(options.rules ?? RULES);
+  const waived = new Set(options.waivers ?? []);
+  const palette = new Set(
+    [...tokens.palette, ...(options.extraPalette ?? [])].map((c) => c.toLowerCase()),
+  );
+  const lines = text.split('\n');
+  const findings = [];
+
+  const add = (rule, lineNo, message) => {
+    if (!enabled.has(rule) || waived.has(rule)) return;
+    if (isDisabled(lines, lineNo, rule)) return;
+    findings.push({ rule, file, line: lineNo, message });
+  };
+
+  lines.forEach((line, i) => {
+    const lineNo = i + 1;
+
+    for (const m of line.matchAll(HEX_RE)) {
+      const hex = normalizeHex(m[0]);
+      if (hex && !palette.has(hex)) {
+        add('off-palette-hex', lineNo, `${m[0]} is not a brand token — add it to tokens.json or use an existing one`);
+      }
+    }
+
+    // The tracking ceiling protects *text extraction*, so it applies to
+    // documents a machine will read back — PDFs, HTML pages — and not to
+    // rasterised cards, whose type is pixels by the time anyone sees it. The
+    // card set really does run the eyebrow at .16em and is right to.
+    if (options.textExtractable !== false) {
+      for (const m of line.matchAll(TRACKING_RE)) {
+        const em = Math.abs(Number.parseFloat(m[1]));
+        const max = tokens.limits.max_letter_spacing_em;
+        if (em > max) {
+          add('tracking-max', lineNo, `letter-spacing ${m[1]}em exceeds ${max}em — above this, PDF text extraction silently breaks`);
+        }
+      }
+    }
+
+    for (const _ of line.matchAll(BARE_WARN_RE)) {
+      add('emoji-presentation', lineNo, 'bare U+26A0 renders as a colored emoji — use the text-presentation form from tokens.marks.warn');
+    }
+    for (const _ of line.matchAll(SHADOW_RE)) {
+      add('no-shadow', lineNo, 'shadows are not part of the brand — structure is ink rules and whitespace');
+    }
+    for (const _ of line.matchAll(GRADIENT_RE)) {
+      add('no-gradient', lineNo, 'gradients are not part of the brand — paper is flat');
+    }
+    for (const _ of line.matchAll(RADIUS_RE)) {
+      add('no-radius', lineNo, 'rounded corners are not part of the brand (a circular avatar is the one exception — waive it explicitly)');
+    }
+  });
+
+  const cap = options.accentCap;
+  if (cap !== null && cap !== undefined && enabled.has('accent-cap') && !waived.has('accent-cap')) {
+    const accent = tokens.colors.accent.toLowerCase();
+    const uses = text.toLowerCase().split(accent).length - 1;
+    if (uses > cap) {
+      findings.push({
+        rule: 'accent-cap',
+        file,
+        line: 0,
+        message: `the accent appears ${uses} times, cap is ${cap} — one loud moment per document`,
+      });
+    }
+  }
+
+  return { file, findings, ok: findings.length === 0 };
+}
+
+/** A `press-lint-disable-next-line <rule>` comment on the preceding line. */
+function isDisabled(lines, lineNo, rule) {
+  const prev = lines[lineNo - 2];
+  if (!prev) return false;
+  const m = DISABLE_RE.exec(prev);
+  if (!m) return false;
+  return m[1].split(',').map((r) => r.trim()).includes(rule);
+}
+
+/** #abc -> #aabbcc; #rrggbbaa -> #rrggbb. Returns null for lengths we skip. */
+function normalizeHex(raw) {
+  const body = raw.slice(1).toLowerCase();
+  if (body.length === 3) return `#${body[0]}${body[0]}${body[1]}${body[1]}${body[2]}${body[2]}`;
+  if (body.length === 6) return `#${body}`;
+  if (body.length === 8) return `#${body.slice(0, 6)}`;
+  return null;
+}

package/lib/region.mjs

@@ -0,0 +1,182 @@
+/**
+ * Marked regions — how press owns part of a file without owning the file.
+ *
+ * A consumer's brand file is mostly hand-written, medium-specific code: a
+ * 250-line stylesheet, a poster's geometry, a résumé's layout. Only the token
+ * block and its loader are shared. So press splices a *marked region* into an
+ * otherwise untouched file rather than generating the file, which is also what
+ * keeps a whole-file sync from clobbering hand-written work (the personal avatar
+ * footer in ghostwriter's diagram.css was lost that way once already).
+ *
+ * The start marker carries a receipt — the press version and a hash of the body
+ * — so a hand-edit inside the region is detectable without re-running the
+ * emitter, and so a diff shows *which* release last wrote it.
+ */
+import { createHash } from 'node:crypto';
+
+/** Comment syntaxes a region can be expressed in. */
+export const SYNTAXES = {
+  python: { prefix: '# ', suffix: '' },
+  css: { prefix: '/* ', suffix: ' */' },
+  md: { prefix: '<!-- ', suffix: ' -->' },
+};
+
+const BANNER = 'GENERATED by @natjswenson/press, do not edit';
+
+export class RegionError extends Error {}
+
+function syntaxOf(name) {
+  const s = SYNTAXES[name];
+  if (!s) {
+    throw new RegionError(
+      `unknown syntax "${name}" (expected one of: ${Object.keys(SYNTAXES).join(', ')})`,
+    );
+  }
+  return s;
+}
+
+const wrap = (syntax, text) => `${syntax.prefix}${text}${syntax.suffix}`;
+
+/**
+ * The inner text of a comment line, or null when the line is not a comment in
+ * this syntax. Trailing whitespace is tolerated; leading is not, because these
+ * markers are always at column 0.
+ */
+function unwrap(syntax, line) {
+  const trimmed = line.replace(/\s+$/, '');
+  if (!trimmed.startsWith(syntax.prefix)) return null;
+  if (syntax.suffix && !trimmed.endsWith(syntax.suffix)) return null;
+  return trimmed.slice(syntax.prefix.length, trimmed.length - syntax.suffix.length);
+}
+
+/** Short, stable content hash of a region body. */
+export function bodyHash(body) {
+  const normalized = body.replace(/\r\n/g, '\n').replace(/\s+$/, '');
+  return createHash('sha256').update(normalized, 'utf8').digest('hex').slice(0, 12);
+}
+
+export function startMarker(syntaxName, region, version, hash) {
+  const syntax = syntaxOf(syntaxName);
+  return wrap(syntax, `>>> press:${region} v${version} sha256:${hash} ${BANNER}`);
+}
+
+export function endMarker(syntaxName, region) {
+  return wrap(syntaxOf(syntaxName), `<<< press:${region}`);
+}
+
+/**
+ * Locate a region. Returns null when the file has no such region — callers
+ * decide whether that is a migration opportunity (`emit --init`) or a failure
+ * (`check`, where a vanished region must go red rather than silently pass).
+ */
+export function findRegion(text, region, syntaxName) {
+  const syntax = syntaxOf(syntaxName);
+  const lines = text.split('\n');
+  const openRe = new RegExp(`^>>> press:${escapeRe(region)}(?:\\s|$)`);
+  const closeRe = new RegExp(`^<<< press:${escapeRe(region)}\\s*$`);
+
+  let start = -1;
+  for (let i = 0; i < lines.length; i += 1) {
+    const inner = unwrap(syntax, lines[i]);
+    if (inner !== null && openRe.test(inner)) {
+      if (start !== -1) {
+        throw new RegionError(
+          `region "${region}" opens twice (lines ${start + 1} and ${i + 1}) — a file may declare it only once`,
+        );
+      }
+      start = i;
+    }
+  }
+  if (start === -1) return null;
+
+  let end = -1;
+  for (let i = start + 1; i < lines.length; i += 1) {
+    const inner = unwrap(syntax, lines[i]);
+    if (inner !== null && closeRe.test(inner)) {
+      end = i;
+      break;
+    }
+  }
+  if (end === -1) {
+    throw new RegionError(
+      `region "${region}" opens at line ${start + 1} but never closes — expected a line reading ${JSON.stringify(endMarker(syntaxName, region))}`,
+    );
+  }
+
+  const openInner = unwrap(syntax, lines[start]);
+  const receipt = /\bv(\S+)\s+sha256:([0-9a-f]+)/.exec(openInner);
+
+  return {
+    startLine: start,
+    endLine: end,
+    body: lines.slice(start + 1, end).join('\n'),
+    version: receipt ? receipt[1] : null,
+    hash: receipt ? receipt[2] : null,
+  };
+}
+
+/** Rebuild the full marked block (start marker, body, end marker). */
+export function renderRegion(region, syntaxName, body, version) {
+  const trimmed = body.replace(/\s+$/, '');
+  return [
+    startMarker(syntaxName, region, version, bodyHash(trimmed)),
+    trimmed,
+    endMarker(syntaxName, region),
+  ].join('\n');
+}
+
+/** Replace an existing region's block in `text`. Throws if there isn't one. */
+export function spliceRegion(text, region, syntaxName, body, version) {
+  const found = findRegion(text, region, syntaxName);
+  if (!found) {
+    throw new RegionError(
+      `${text.length === 0 ? 'empty file' : 'file'} has no press:${region} region — run \`press emit --target <id> --init\` to create one`,
+    );
+  }
+  const lines = text.split('\n');
+  const block = renderRegion(region, syntaxName, body, version).split('\n');
+  lines.splice(found.startLine, found.endLine - found.startLine + 1, ...block);
+  return lines.join('\n');
+}
+
+/**
+ * First-time insertion, for migrating a consumer that still carries a
+ * hand-written copy.
+ *
+ * `anchor.replaceFrom`/`anchor.replaceTo` are regexes naming the first and last
+ * line of the legacy span the region takes over, so the duplicate is swallowed
+ * in the same operation rather than left behind to drift. With no anchor the
+ * block is appended.
+ */
+export function initRegion(text, region, syntaxName, body, version, anchor = {}) {
+  if (findRegion(text, region, syntaxName)) {
+    throw new RegionError(`file already has a press:${region} region — use emit without --init`);
+  }
+  const block = renderRegion(region, syntaxName, body, version);
+  const { replaceFrom, replaceTo } = anchor;
+  if (!replaceFrom) return `${text.replace(/\s+$/, '')}\n\n${block}\n`;
+
+  const lines = text.split('\n');
+  const fromRe = new RegExp(replaceFrom);
+  const from = lines.findIndex((l) => fromRe.test(l));
+  if (from === -1) {
+    throw new RegionError(`anchor replaceFrom /${replaceFrom}/ matched no line`);
+  }
+  const toRe = new RegExp(replaceTo ?? replaceFrom);
+  let to = -1;
+  for (let i = from; i < lines.length; i += 1) {
+    if (toRe.test(lines[i]) && (i > from || !replaceTo)) {
+      to = i;
+      break;
+    }
+  }
+  if (to === -1) {
+    throw new RegionError(`anchor replaceTo /${replaceTo}/ matched no line at or after line ${from + 1}`);
+  }
+  lines.splice(from, to - from + 1, ...block.split('\n'));
+  return lines.join('\n');
+}
+
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/lib/targets.mjs

@@ -0,0 +1,67 @@
+/**
+ * The consumer registry.
+ *
+ * A target is one region in one file in one repo. Declaring a consumer here is
+ * what makes it press's business; anything not declared is invisible to
+ * `check`, which is why `doctor` exists to show the whole registry rather than
+ * only what resolved locally.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+export const TARGETS_PATH = join(HERE, '..', 'targets.json');
+
+export class TargetError extends Error {}
+
+export function loadTargets(path = TARGETS_PATH) {
+  const raw = JSON.parse(readFileSync(path, 'utf8'));
+  const targets = raw.targets ?? [];
+  const seen = new Set();
+  for (const t of targets) {
+    for (const key of ['id', 'repo', 'path', 'region', 'emitter', 'syntax']) {
+      if (!t[key]) throw new TargetError(`target ${t.id ?? '<unnamed>'} is missing "${key}"`);
+    }
+    if (seen.has(t.id)) throw new TargetError(`duplicate target id "${t.id}"`);
+    seen.add(t.id);
+  }
+  return targets;
+}
+
+/** Nearest ancestor containing a .git, or the path itself. */
+export function repoRoot(start = process.cwd()) {
+  let dir = resolve(start);
+  for (;;) {
+    if (existsSync(join(dir, '.git'))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return resolve(start);
+    dir = parent;
+  }
+}
+
+export const targetPath = (target, root) =>
+  isAbsolute(target.path) ? target.path : join(root, target.path);
+
+/**
+ * Which targets this invocation is responsible for.
+ *
+ * Selection is by *file presence* under the repo root, so the same registry
+ * works unchanged whether it runs inside claude-skills, budget, or the site.
+ * An explicit `--target` always selects, present or not, so a typo'd path
+ * reports as missing rather than silently selecting nothing.
+ */
+export function selectTargets(targets, { root, ids }) {
+  if (ids?.length) {
+    return ids.map((id) => {
+      const found = targets.find((t) => t.id === id);
+      if (!found) {
+        throw new TargetError(
+          `no target "${id}" — known targets: ${targets.map((t) => t.id).join(', ')}`,
+        );
+      }
+      return found;
+    });
+  }
+  return targets.filter((t) => existsSync(targetPath(t, root)));
+}

package/lib/tokens.mjs

@@ -0,0 +1,86 @@
+/**
+ * Loading and resolving the token set.
+ *
+ * Nothing else in the codebase may hard-code a brand value. If a consumer needs
+ * a color that isn't here, the answer is to add it here — that is the entire
+ * point of the skill, and the terminal-panel quartet spent three files
+ * undeclared before it was.
+ */
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+export const BRAND_DIR = join(HERE, '..', 'brand');
+export const TOKENS_PATH = join(BRAND_DIR, 'tokens.json');
+
+let cached = null;
+
+export function loadTokens(path = TOKENS_PATH) {
+  if (path === TOKENS_PATH && cached) return cached;
+  const raw = JSON.parse(readFileSync(path, 'utf8'));
+  const resolved = resolve(raw);
+  if (path === TOKENS_PATH) cached = resolved;
+  return resolved;
+}
+
+/**
+ * Flatten the file into one lookup of `name -> value`, computing the derived
+ * values so that `hair` and `fill_steps` provably come from `ink` rather than
+ * being a second place a color is written down.
+ */
+/** `$comment` keys are documentation for a human reading tokens.json; they must
+ *  never reach an emitter's output. */
+const clean = (group) => {
+  const out = { ...(group ?? {}) };
+  delete out.$comment;
+  return out;
+};
+
+function resolve(raw) {
+  const colors = clean(raw.colors);
+  const terminal = clean(raw.terminal);
+
+  const hairAlpha = raw.derived?.hair_alpha ?? 0.18;
+  const [r, g, b] = hexToRgb(colors.ink);
+  const hair = `rgba(${r}, ${g}, ${b}, ${hairAlpha})`;
+
+  const fillSteps = (raw.derived?.fill_steps ?? []).map((name) => {
+    const value = colors[name];
+    if (!value) throw new Error(`derived.fill_steps names unknown color "${name}"`);
+    return value;
+  });
+
+  return {
+    name: raw.name,
+    schema: raw.schema,
+    colors,
+    terminal,
+    notes: clean(raw.color_notes),
+    fonts: clean(raw.fonts),
+    identity: clean(raw.identity),
+    marks: clean(raw.marks),
+    limits: clean(raw.limits),
+    derived: { hair, hairAlpha, fillSteps },
+    /** Every literal color the brand permits, for the off-palette lint. */
+    palette: [...Object.values(colors), ...Object.values(terminal)],
+  };
+}
+
+export function hexToRgb(hex) {
+  const m = /^#([0-9a-f]{6})$/i.exec(hex);
+  if (!m) throw new Error(`not a 6-digit hex color: ${hex}`);
+  const n = parseInt(m[1], 16);
+  return [(n >> 16) & 255, (n >> 8) & 255, n & 255];
+}
+
+/** Look up a token by its flat name, including the derived ones. */
+export function tokenValue(tokens, name) {
+  if (name === 'hair') return tokens.derived.hair;
+  if (name in tokens.colors) return tokens.colors[name];
+  if (name in tokens.terminal) return tokens.terminal[name];
+  if (name in tokens.fonts) return tokens.fonts[name];
+  if (name in tokens.identity) return tokens.identity[name];
+  if (name in tokens.marks) return tokens.marks[name];
+  throw new Error(`unknown token "${name}"`);
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@natjswenson/press",
+  "version": "0.1.0",
+  "description": "One brand system — tokens, laws, run presentation and voice core — generated into every consumer with a CI drift gate",
+  "license": "MIT",
+  "author": "Nate Swenson",
+  "homepage": "https://github.com/natejswenson/claude-skills",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/natejswenson/claude-skills.git"
+  },
+  "bugs": {
+    "url": "https://github.com/natejswenson/claude-skills/issues"
+  },
+  "keywords": [
+    "press",
+    "claude-code",
+    "claude-skill",
+    "design-system",
+    "design-tokens",
+    "branding"
+  ],
+  "type": "module",
+  "bin": {
+    "press": "bin/press.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "brand/",
+    "targets.json",
+    "skill-invariants.json",
+    "SKILL.md",
+    "CHANGELOG.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node --test \"tests/**/*.test.mjs\"",
+    "audit": "npm audit --audit-level=moderate",
+    "prepack": "cp ../../README.md ../../LICENSE ../../CHANGELOG.md .",
+    "postpack": "rm -f README.md LICENSE CHANGELOG.md"
+  }
+}

package/skill-invariants.json

@@ -0,0 +1,73 @@
+{
+  "comment": "Prose guardrails in SKILL.md that must survive edits, plus the baseline eval declaration. Each prose pattern is a case-insensitive regex tested against the full SKILL.md text by tests/skill-contract.test.mjs. If you intentionally change one, update it here in the same commit and say why in the PR.",
+  "prose": [
+    {
+      "id": "never-write-a-value-by-hand",
+      "pattern": "Never write a brand value into a file by hand",
+      "rationale": "The entire skill exists because copying values by hand produced eight divergent copies. Losing this line reopens exactly the failure mode press was built to close."
+    },
+    {
+      "id": "add-to-tokens-never-invent-locally",
+      "pattern": "add it to `brand/tokens\\.json` and re-emit\\. Never invent one locally",
+      "rationale": "Three genuinely-shared tokens (ink_faint, the terminal quartet, two paper steps) were found undeclared during the first migration precisely because consumers invented values locally. The escape hatch has to point back to tokens.json."
+    },
+    {
+      "id": "check-fails-on-three-things",
+      "pattern": "gone missing.{0,400}resolved \\*\\*zero\\*\\* targets",
+      "rationale": "A gate that only detects byte drift silently passes when a region is deleted or when nothing resolved. Those two are the ways this check turns decorative, so they must stay named in the contract."
+    },
+    {
+      "id": "never-generate-a-whole-file",
+      "pattern": "Never generate a whole file",
+      "rationale": "Whole-file generation clobbered ghostwriter's personal avatar footer once already. Region splicing is the load-bearing design decision, not a style preference."
+    },
+    {
+      "id": "prose-contracts-spliced-not-referenced",
+      "pattern": "spliced \\*\\*into\\*\\* a consuming SKILL\\.md",
+      "rationale": "A consuming skill is a separately installed plugin and cannot read this skill's files at runtime. If this degrades into 'reference the press docs', the agent-UI and voice contracts silently stop applying."
+    },
+    {
+      "id": "medium-voice-wins-on-conflict",
+      "pattern": "wins on conflict",
+      "rationale": "ghostwriter's learned voice and devlog's release-note shape are personal, per-medium, and higher-signal than the universal floor. Without this precedence rule, folding voice into press would degrade both."
+    },
+    {
+      "id": "npx-must-pin-latest",
+      "pattern": "Always pin `@latest`",
+      "rationale": "A bare npx invocation silently prefers a stale global install over the registry. This exact failure cost this repo a release with shipflow; the same trap applies verbatim to press."
+    },
+    {
+      "id": "look-at-the-artifact",
+      "pattern": "Re-render one real artifact per affected medium and \\*\\*look at it\\*\\*",
+      "rationale": "A token change is the one edit that touches every product at once, and no test asserts taste. The visual confirmation step is the only thing standing between a one-character edit and shipping it everywhere."
+    }
+  ],
+  "baseline": [
+    {
+      "id": "pre-migration-value-snapshot",
+      "kind": "golden",
+      "test": "tests/baseline.test.mjs",
+      "fixtures": ["tests/fixtures/pre-migration-values.json"],
+      "update_command": "node tests/fixtures/update-pre-migration.mjs",
+      "rationale": "A frozen snapshot of every brand value as it actually existed in eight files across four repos (claude-skills, budget, local-fitness, natejswenson.io) before press generated any of them. This is the migration's no-op proof: whatever press emits must still carry those values, so a future token edit that silently changes a colour a shipped product depends on goes red instead of quietly re-rendering every artifact wrong. Pinned to a real past state, never synthesised. The paired negative assertion (deleting the accent from the known set must be detected) keeps the check from passing while the comparison rots, and a min_sources floor of 7 stops the fixture from shrinking to nothing and still reporting clean."
+    },
+    {
+      "id": "emitted-region-goldens",
+      "kind": "golden",
+      "test": "tests/baseline.test.mjs",
+      "corpus_glob": "tests/fixtures/golden/*.txt",
+      "min_corpus": 8,
+      "update_command": "node tests/fixtures/update-pre-migration.mjs",
+      "rationale": "Byte-exact expected output for every registered target's region. Byte-exactness is correct here for the same reason it is for shipflow's rendered workflow: the region IS the contract, and one changed character is a change to a shipped artifact's appearance. min_corpus 8 is the anti-vacuity floor -- a glob that quietly matched nothing would otherwise report every target as passing. The paired negative assertion bends one token and requires the comparison to notice."
+    },
+    {
+      "id": "shipped-stylesheets-lint-clean",
+      "kind": "corpus",
+      "test": "tests/lint.test.mjs",
+      "corpus_glob": "../../../*/skills/*/assets/**/press.css",
+      "min_corpus": 1,
+      "update_command": "node bin/press.js lint <file> --raster",
+      "rationale": "The brand lint is run against the stylesheets this repo actually ships, so a rule strict enough to reject work already published fails here rather than in a release. This caught a real over-strict rule on its first run: the 0.10em tracking ceiling exists to protect PDF text extraction, and the ghostwriter card set legitimately runs its eyebrow at .16em because a rasterised card's text is never extracted -- the rule was scoped to extractable documents instead of the corpus being waived. Every rule is two-sided: the real corpus passes and a targeted mutation of it fails."
+    }
+  ]
+}