@natjswenson/press 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,66 @@
+# Changelog
+
+All notable changes to the **press** skill are documented here.
+
+The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and
+this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-07-31
+
+First release. Replaces eight hand-ported copies of the PRESS brand with one
+source of truth and a CI drift gate.
+
+### Added
+
+- **`brand/tokens.json`** — the only place a brand value is written down:
+  colours, the terminal panel palette, font stacks, identity defaults, and the
+  limits the lint enforces.
+- **Four contract documents** the brand is more than colours:
+  `laws.md` (the accent law, structure, the three voices, the tracking ceiling),
+  `components.md` (the shared component vocabulary), `agent-ui.md` (how a run
+  should read in the chat transcript), `voice-core.md` (the copy rules that
+  hold for every artifact).
+- **Marked-region splicing** — press owns a marked block inside an otherwise
+  hand-written file, so a consumer keeps its stylesheet, its poster geometry and
+  its personal footer. The start marker carries a version + content-hash
+  receipt.
+- **Five emitters** — `python-theme` (token dict plus the shared deep-merge
+  loader), `css-vars` (with per-consumer name aliases), `md-palette`,
+  `markdown-block`, `json`.
+- **`press check`** — the drift gate. Fails on drifted bytes, on a region that
+  has gone missing, and on a run that resolved zero targets.
+- **`press lint`** — mechanical brand law: off-palette hexes, the tracking
+  ceiling, emoji-presentation glyphs, shadows, gradients, radii, and an optional
+  accent cap. Waivable per line or per file.
+- **`press emit --init`** — first-time migration, swallowing the hand-written
+  block it takes over rather than leaving a duplicate behind.
+- **`press doctor`** and **`press tokens`**.
+- **Baseline eval** pinned to a real past state: every brand value as it existed
+  in eight files across four repos before press generated any of them, plus
+  byte-exact goldens per target. Two-sided, with anti-vacuity floors.
+
+### Changed
+
+- **Migrated five in-repo consumers** to generated regions — `city-report`,
+  `resume`, `ghostwriter`, `ghostwriter-x`, `devlog`. Every value is unchanged
+  and each skill's own suite stays green (222, 13 files, 352, 432 and 255 tests
+  respectively).
+- **Font stacks widened to the union of every consumer's.** The résumé's
+  print-tuned stacks were the deepest; fallbacks are additive, so the richest
+  chain became the canonical one and every other consumer gained it.
+- **The `.term` rules in both card sets now reference variables** instead of
+  five hardcoded hexes.
+
+### Fixed
+
+- **Three genuinely-shared token groups were undeclared anywhere** and are now
+  in `tokens.json`: `ink_faint` (`#8A8272`), the terminal panel palette
+  (`#141A26`, `#EFE9DC`, `#8A8478`, `#FF8A5C`, `#1E2738` — hardcoded in three
+  files), and two paper steps the site was carrying alone (`#ECE5D6`,
+  `#E4DCCA`).
+- **The tracking ceiling was over-strict.** It exists to protect PDF text
+  extraction, so it binds on documents a machine reads back and not on
+  rasterised cards, whose eyebrow legitimately runs at `.16em`. Scoped rather
+  than waived, and caught by linting the real shipped corpus.
+
+[0.1.0]: https://github.com/natejswenson/claude-skills/releases/tag/press-v0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nate Swenson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,78 @@
+# press
+
+One brand system for everything — design tokens, the visual laws, the
+run-presentation contract, and the universal voice core — generated into every
+consumer, with a CI gate that fails when any of them drifts.
+
+PRESS is the warm-paper editorial brand shared by a morning brief, a city
+profile, a budget report, a résumé, a LinkedIn card, a dev-log cover, and
+natejswenson.com. Before this skill it existed as **eight hand-ported copies
+across four repositories**, with five different names for the same orange and no
+way to notice when one of them moved.
+
+## The idea
+
+`brand/tokens.json` is the only place a brand value is written down. Everything
+else is generated from it into a **marked region** inside an otherwise
+hand-written file:
+
+```python
+# >>> press:tokens v0.1.0 sha256:2b3d… GENERATED by @natjswenson/press, do not edit
+DEFAULT_THEME: dict = { ... }
+def load_theme() -> dict: ...
+# <<< press:tokens
+```
+
+The consumer keeps everything else — its 250-line stylesheet, its poster
+geometry, its personal avatar footer. `press check` re-derives each region and
+fails CI on any difference.
+
+## Usage
+
+```bash
+npx -y @natjswenson/press@latest check --repo .    # is this repo in sync?
+npx -y @natjswenson/press@latest emit --repo .     # make it so
+npx -y @natjswenson/press@latest lint theme.css    # mechanical brand law
+npx -y @natjswenson/press@latest doctor            # the whole registry
+npx -y @natjswenson/press@latest tokens --format css
+```
+
+Always pin `@latest`. A bare `npx @natjswenson/press` silently prefers a stale
+global install over the registry.
+
+## What `check` fails on
+
+| Status | Means |
+|---|---|
+| `drift` | the region exists but its bytes differ |
+| `missing` | the file has no region — the generated block was deleted |
+| `absent` | a declared file is not there |
+| *(empty run)* | **zero targets resolved — the check verified nothing** |
+
+The last two matter most. A checker that verifies nothing reports "all clean",
+which is how a gate turns decorative.
+
+## What it does not own
+
+Layout and composition (the medium's business), chart colour validation (the
+`dataviz` skill), and any voice learned from the user's own writing —
+ghostwriter's learned profile and devlog's release-note shape stay where they
+are and win on conflict. PRESS sets the floor everything shares, not the whole
+of anything.
+
+## Adding a consumer
+
+Declare it in `targets.json`, choose an emitter (`python-theme`, `css-vars`,
+`md-palette`, `markdown-block`, `json`), give it an `init` anchor naming the
+hand-written block the region takes over, then:
+
+```bash
+npx -y @natjswenson/press@latest emit --target <id> --init
+```
+
+Aliases are deliberate: the résumé keeps `--sig`, the site keeps `--fg`. The
+names stay idiomatic to their medium; only the values are shared.
+
+## License
+
+MIT

package/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: press
+description: The one brand system for everything produced in Claude — design tokens, the visual laws, the run-presentation contract, and the universal voice core. Use when composing or restyling any artifact (report, résumé, card, cover, PDF, HTML page, chart), when asked about brand colors, fonts, the accent law or "the PRESS look", when adding a new skill that renders anything, or when a brand value needs to change everywhere at once. Also handles "check the brand is in sync", "why do my colors differ", and onboarding a new consumer repo.
+user_invocable: true
+version: 0.1.0
+---
+
+# /press — the brand system
+
+You are running the **press** skill. PRESS is the warm-paper editorial brand
+every artifact shares: a morning brief, a city profile, a budget report, a
+résumé, a LinkedIn card, a dev-log cover, and the site all read as issues of one
+publication.
+
+**Announce at start:** "I'm using the press skill for the brand."
+
+> All commands below run from the directory containing this `SKILL.md` (the
+> skill's install dir, `$SKILL_DIR`). Resolve it once and `cd` there first. When
+> working in another repo, pass `--repo <path>`.
+
+## The one rule
+
+**Never write a brand value into a file by hand.** Not a hex, not a font stack,
+not the monogram. Every consumer gets its values *generated* into a marked
+region, and CI fails if any of them drifts. Copying a value is how this brand
+ended up in eight hand-ported copies with five different names for the same
+orange, which is the problem this skill exists to end.
+
+If a consumer needs a color that doesn't exist yet, add it to
+`brand/tokens.json` and re-emit. Never invent one locally.
+
+## What's here
+
+| File | Is |
+|---|---|
+| `brand/tokens.json` | **The** source of truth: colors, font stacks, identity, limits |
+| `brand/laws.md` | Why there are so few values: the accent law, structure, the three voices, the tracking ceiling |
+| `brand/components.md` | The shared component vocabulary — masthead, standfirst, big stat, ledger, duel, terminal, table |
+| `brand/agent-ui.md` | How a skill's run should read in the chat transcript |
+| `brand/voice-core.md` | The copy rules that hold for every artifact |
+| `targets.json` | Every place the brand is written down |
+
+## Composing something new
+
+1. **Read `brand/laws.md` first, then `brand/components.md`.** They are short.
+   Composing without them produces something that uses the right colors and
+   still looks like a different product.
+2. **Pick the components the content needs**, not a template. PRESS is a brand
+   system, not a template — two artifacts should never share a skeleton just
+   because they share a brand.
+3. **Get the values from the CLI, never from memory:**
+   ```bash
+   node bin/press.js tokens --format css     # a :root block
+   node bin/press.js tokens --format json    # raw values
+   node bin/press.js tokens --format md      # the palette as prose
+   ```
+4. **Lint before showing the user:**
+   ```bash
+   node bin/press.js lint <file…> [--accent-cap 2]
+   ```
+   Findings are mechanical brand violations, not style opinions. Fix them.
+5. **Show the rendered artifact, not a description of it.** Per
+   `brand/agent-ui.md`, a visual claim without the image in the transcript is
+   not a result.
+
+## Checking every consumer is in sync
+
+```bash
+node bin/press.js check                 # this repo
+node bin/press.js check --repo ../budget
+node bin/press.js doctor                # the whole registry, present or not
+```
+
+`check` fails on three things, not one: a region whose bytes drifted, a region
+that has **gone missing** from a file that should have one, and a run that
+resolved **zero** targets. The last two matter most — a checker that verifies
+nothing reports "all clean", which is exactly how a gate turns decorative.
+
+On failure it prints the diff and the exact `press emit` command that fixes it.
+Run that; do not hand-edit the region.
+
+## Changing a brand value
+
+This is the one operation that touches every product, so do it deliberately.
+
+1. Edit `brand/tokens.json`. One value, with a reason.
+2. `node bin/press.js emit --dry-run` and read what would change.
+3. `node bin/press.js emit`, then run the affected skills' own test suites —
+   a token change must not break anyone's baseline.
+4. Re-render one real artifact per affected medium and **look at it**.
+5. For repos outside this one, run `npx -y @natjswenson/press@latest emit
+   --repo <path>` in each. Always pin `@latest`: a bare `npx @natjswenson/press`
+   silently prefers a stale global install over the registry.
+
+Bump the version and add a `CHANGELOG.md` entry in the same change.
+
+## Onboarding a new consumer
+
+1. Add a target to `targets.json`: `id`, `repo`, `path`, `region`, `syntax`
+   (`python` | `css` | `md`), `emitter`, and `params`.
+2. Choose the emitter:
+
+   | Emitter | Produces |
+   |---|---|
+   | `python-theme` | the token dict plus the shared deep-merge loader |
+   | `css-vars` | a custom-property block, with per-consumer aliases |
+   | `md-palette` | the palette as a prose bullet list |
+   | `markdown-block` | one of the brand docs, inlined into a SKILL.md |
+   | `json` | raw values |
+
+3. Add an `init` anchor naming the first and last line of the hand-written block
+   the region takes over, so the duplicate is **swallowed**, not left behind.
+4. `node bin/press.js emit --target <id> --init`
+5. Add a `press check` step to that repo's CI.
+
+**Aliases are deliberate.** The résumé keeps `--sig`, the site keeps `--fg`. The
+names stay idiomatic to their medium; only the values are shared. Renaming
+across three repos would be churn for no gain.
+
+**Never generate a whole file.** The region owns the token block; the consumer
+owns everything else — its 250-line stylesheet, its poster geometry, its
+personal avatar footer. A whole-file sync clobbered exactly that once already.
+
+## Adopting the prose contracts
+
+`brand/agent-ui.md` and `brand/voice-core.md` are spliced **into** a consuming
+SKILL.md as `markdown-block` regions rather than referenced. A consuming skill is
+a separately installed plugin and cannot reliably read this skill's files at
+runtime, so build-time splicing is the only mechanism that actually works.
+
+A medium's own voice layers on top and **wins on conflict** — ghostwriter's
+learned profile and devlog's release-note shape stay where they are. The core is
+what applies when nothing more specific does.
+
+## What press does not decide
+
+Layout and composition (the medium's business), chart color validation (the
+`dataviz` skill), and any voice learned from the user's own writing. PRESS sets
+the floor everything shares, not the whole of anything.

package/bin/press.js

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+/**
+ * press — the brand CLI.
+ *
+ * The agent decides; this does. Every command is deterministic, offline, and
+ * costs nothing, so it is safe to run in CI on every pull request.
+ */
+import { readFileSync, writeFileSync } from 'node:fs';
+import { parseArgs } from 'node:util';
+import { fileURLToPath } from 'node:url';
+import { dirname, join, relative } from 'node:path';
+
+import { loadTokens } from '../lib/tokens.mjs';
+import { emitBody } from '../lib/emit.mjs';
+import { initRegion, spliceRegion, findRegion } from '../lib/region.mjs';
+import { loadTargets, repoRoot, selectTargets, targetPath } from '../lib/targets.mjs';
+import { checkAll, EXPLAIN } from '../lib/check.mjs';
+import { lintText } from '../lib/lint.mjs';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const VERSION = JSON.parse(readFileSync(join(HERE, '..', 'package.json'), 'utf8')).version;
+
+const USAGE = `press v${VERSION} — one brand, generated into every consumer.
+
+  press emit  [--target <id>…] [--repo <path>] [--init] [--dry-run]
+  press check [--target <id>…] [--repo <path>] [--json]
+  press lint  <file…> [--accent-cap <n>] [--raster] [--waive <rule>…]
+  press doctor [--repo <path>]
+  press tokens [--format json|css|md]
+
+Docs: brand/laws.md (why), brand/components.md (what), targets.json (where).`;
+
+const OPTIONS = {
+  target: { type: 'string', multiple: true, default: [] },
+  repo: { type: 'string' },
+  init: { type: 'boolean', default: false },
+  'dry-run': { type: 'boolean', default: false },
+  json: { type: 'boolean', default: false },
+  format: { type: 'string', default: 'json' },
+  'accent-cap': { type: 'string' },
+  raster: { type: 'boolean', default: false },
+  waive: { type: 'string', multiple: true, default: [] },
+  help: { type: 'boolean', default: false },
+};
+
+function main(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    options: OPTIONS,
+    allowPositionals: true,
+  });
+  const command = positionals[0];
+  if (values.help || !command) {
+    process.stdout.write(`${USAGE}\n`);
+    return command ? 0 : 1;
+  }
+
+  const tokens = loadTokens();
+  const root = repoRoot(values.repo ?? process.cwd());
+
+  switch (command) {
+    case 'emit':
+      return cmdEmit({ tokens, root, values });
+    case 'check':
+      return cmdCheck({ tokens, root, values });
+    case 'lint':
+      return cmdLint({ tokens, files: positionals.slice(1), values });
+    case 'doctor':
+      return cmdDoctor({ root, values });
+    case 'tokens':
+      return cmdTokens({ tokens, values });
+    default:
+      process.stderr.write(`press: unknown command "${command}"\n\n${USAGE}\n`);
+      return 1;
+  }
+}
+
+function cmdEmit({ tokens, root, values }) {
+  const targets = selectTargets(loadTargets(), { root, ids: values.target });
+  if (targets.length === 0) return fail('no targets resolved under this repo — nothing to emit');
+
+  const rows = [];
+  for (const target of targets) {
+    const path = targetPath(target, root);
+    const body = emitBody(tokens, target.emitter, target.params ?? {});
+    const before = readFileSync(path, 'utf8');
+    const has = findRegion(before, target.region, target.syntax);
+
+    let after;
+    if (has) {
+      if (values.init) return fail(`${target.id} already has a press:${target.region} region — drop --init`);
+      after = spliceRegion(before, target.region, target.syntax, body, VERSION);
+    } else {
+      if (!values.init) {
+        return fail(`${target.id} has no press:${target.region} region — re-run with --init to create one`);
+      }
+      after = initRegion(before, target.region, target.syntax, body, VERSION, target.init ?? {});
+    }
+
+    const changed = after !== before;
+    if (changed && !values['dry-run']) writeFileSync(path, after, 'utf8');
+    rows.push([
+      target.id,
+      target.emitter,
+      relative(root, path),
+      changed ? (values['dry-run'] ? 'would write' : has ? 'updated' : 'created') : 'unchanged',
+    ]);
+  }
+
+  table(['Target', 'Emitter', 'File', 'Result'], rows);
+  return 0;
+}
+
+function cmdCheck({ tokens, root, values }) {
+  const report = checkAll({
+    tokens,
+    targets: loadTargets(),
+    root,
+    ids: values.target,
+    version: VERSION,
+  });
+
+  if (values.json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    return report.ok ? 0 : 1;
+  }
+
+  // A run that checked nothing is a failure, never a pass.
+  if (report.empty) {
+    return fail('no targets resolved under this repo — check verified nothing');
+  }
+
+  table(
+    ['Target', 'File', 'Status'],
+    report.results.map((r) => [r.target.id, relative(root, r.path), r.status]),
+  );
+
+  if (report.failures.length === 0) return 0;
+
+  for (const f of report.failures) {
+    process.stderr.write(`\n${f.target.id} — ${EXPLAIN[f.status]}\n`);
+    if (f.detail) process.stderr.write(`${f.detail}\n`);
+    if (f.diff) process.stderr.write(`${f.diff}\n`);
+  }
+  const ids = report.failures.map((f) => f.target.id);
+  process.stderr.write(
+    `\nFix: press emit ${ids.map((id) => `--target ${id}`).join(' ')}` +
+      `${report.failures.some((f) => f.status === 'missing') ? ' --init' : ''}\n`,
+  );
+  return 1;
+}
+
+function cmdLint({ tokens, files, values }) {
+  if (files.length === 0) return fail('lint needs at least one file');
+  const accentCap = values['accent-cap'] === undefined ? null : Number(values['accent-cap']);
+  let findings = 0;
+  const rows = [];
+
+  for (const file of files) {
+    const result = lintText(readFileSync(file, 'utf8'), tokens, {
+      file,
+      accentCap,
+      waivers: values.waive,
+      // A card is pixels by the time anyone reads it, so the tracking ceiling
+      // (which protects PDF text extraction) does not bind.
+      textExtractable: !values.raster,
+    });
+    findings += result.findings.length;
+    rows.push([file, String(result.findings.length), result.ok ? 'clean' : 'violations']);
+    for (const f of result.findings) {
+      process.stderr.write(`${f.file}:${f.line || '-'}  ${f.rule}  ${f.message}\n`);
+    }
+  }
+
+  table(['File', 'Findings', 'Status'], rows);
+  return findings === 0 ? 0 : 1;
+}
+
+function cmdDoctor({ root, values }) {
+  const all = loadTargets();
+  const here = new Set(selectTargets(all, { root, ids: [] }).map((t) => t.id));
+  table(
+    ['Target', 'Repo', 'File', 'Present'],
+    all.map((t) => [t.id, t.repo, t.path, here.has(t.id) ? 'yes' : 'no']),
+  );
+  return 0;
+}
+
+function cmdTokens({ tokens, values }) {
+  if (values.format === 'json') {
+    process.stdout.write(`${emitBody(tokens, 'json', {})}\n`);
+  } else if (values.format === 'css') {
+    const vars = [...Object.keys(tokens.colors), 'hair'];
+    process.stdout.write(`${emitBody(tokens, 'css-vars', { vars, align: true, comments: false })}\n`);
+  } else if (values.format === 'md') {
+    process.stdout.write(`${emitBody(tokens, 'md-palette', {})}\n`);
+  } else {
+    return fail(`unknown --format "${values.format}" (json, css, md)`);
+  }
+  return 0;
+}
+
+// --- output ---------------------------------------------------------------
+
+function table(headers, rows) {
+  const widths = headers.map((h, i) =>
+    Math.max(h.length, ...rows.map((r) => String(r[i] ?? '').length)),
+  );
+  const line = (cells) => `| ${cells.map((c, i) => String(c ?? '').padEnd(widths[i])).join(' | ')} |`;
+  process.stdout.write(`${line(headers)}\n`);
+  process.stdout.write(`|${widths.map((w) => '-'.repeat(w + 2)).join('|')}|\n`);
+  for (const row of rows) process.stdout.write(`${line(row)}\n`);
+}
+
+function fail(message) {
+  process.stderr.write(`press: ${message}\n`);
+  return 1;
+}
+
+try {
+  process.exitCode = main(process.argv.slice(2));
+} catch (err) {
+  process.stderr.write(`press: ${err.message}\n`);
+  process.exitCode = 1;
+}

package/brand/agent-ui.md

@@ -0,0 +1,33 @@
+## Presentation — how a run should look
+
+This skill is watched, not just run. Everything below assumes the user is
+reading the conversation, so **the transcript is part of the product.**
+
+**Keep the machinery invisible.** The user should see a short status line and a
+table, not a scroll of raw command output. Concretely:
+
+- **Never print file contents into the conversation.** Not a fetched page, not a
+  source file, not a script's own source. Scripts hand each other *paths*; when
+  you need a file's text in context, use the `Read` tool rather than `cat`,
+  `sed`, `head`, or a `--show` flag. Anything the user already has open
+  somewhere is a wall of text in chat.
+- **One script call, not a pipeline.** Every step should be a single command that
+  returns everything you need. If you find yourself chaining `sed`/`grep`/
+  `python3 -` to reshape output, the script should have given it to you — say so
+  rather than working around it.
+- **Report in tables, with named columns.** Ad-hoc prose summaries are why runs
+  read inconsistently. Every stage that produces more than one fact reports a
+  table with a fixed column set, declared in this skill's own steps below.
+  Omit noise: don't list unchanged fields, don't repeat inputs back, don't show
+  paths the user can't act on.
+- **Show, don't describe.** When a run produces something visual, `Read` the
+  rendered image so the user sees it, instead of writing a paragraph about it.
+- **Never claim a visual result without the artifact.** "It looks better" with no
+  PNG in the transcript is not a result.
+
+**The exception — narrate the slow parts.** Anything that takes more than a
+couple of seconds gets one short lowercase line as it starts (`fetching the
+posting…`, `rendering press + ats-plain…`) so the user sees progress rather than
+dead air. One line each, not a table.
+
+**Announce the skill once, at the start**, in one sentence, and never again.

package/brand/components.md

@@ -0,0 +1,64 @@
+# The shared component vocabulary
+
+Every PRESS medium composes from the same named parts. The *geometry* differs by
+medium — a masthead is 8px of rule and a 62px stamp on a 1200×1500 poster card,
+and 8px of rule with a 0.8rem stamp on a letter page — but the **name, the
+anatomy, and the job** are fixed. That is what makes a card and a report
+recognisably the same publication.
+
+Class names below are the contract. A medium may add classes; it may not rename
+these or change what they mean.
+
+## Frame — present on every document
+
+| Part | Class | Anatomy | Job |
+|---|---|---|---|
+| **Masthead** | `.mast` / `header.masthead` | heavy top rule (8px ink) · `.stamp` (rotated -4°, accent border + initials) · `.eyebrow` (tracked-caps mono issue line) · `.byline` (right-aligned, dim, mono) | says whose publication this is, and which issue |
+| **Headline** | `h1` | display sans 900, tracking `-0.03em`, line-height ~1.0 | the one claim |
+| **Standfirst** | `.stand` / `p.standfirst` | serif italic, dim, ≤3 lines | the setup |
+| **Colophon** | `.colophon` / `footer.provenance` | 2px ink rule above · mono, dim · optional circular avatar | what this was for, where the numbers came from |
+
+The headline carries **at most one** accent-colored pivot phrase (`.sig`). That
+is usually where the document's single accent moment is spent.
+
+## Body — pick what the content needs, never all of them
+
+| Part | Class | Proves | Budget |
+|---|---|---|---|
+| **Big stat** | `.bigstat > .fig` (+ `.unit`, `.kicker`) | a number-led claim | `.fig` ≤6 chars |
+| **Stat strip** | `.stat-strip > .stat` (`.value .label .bench`) | 3–6 headline figures at a glance | ruled above and below, no tiles |
+| **Facts strip** | `.facts > .fact` (`.flabel .fval .fcap`) | 2–4 quick specs | `.fval` ≤14 chars |
+| **Ledger** | `.ledger > .lrow` (`.lno .lbody .lt .le`) | a method, 3–4 steps | `.lt` ≤38 · `.le` ≤60 |
+| **Tiles** | `.tiles > .tile` (`.tno .tt .te`) | exactly 4 compact steps | `.tt` ≤22/line |
+| **Duel** | `.duel > .side.lose/.win` (`.verdict .who .how`) | a decision between two | 2 sides, `.how` ≤40 |
+| **Bars** | `.bars > .brow` (`.blabel .btrack > .bfill .bval`) | a comparison of magnitudes | 3–4 rows, every bar labelled |
+| **Pull quote** | `.pull > .q` (+ `.qrule`) | the thesis | ≤2 lines |
+| **Terminal** | `.term > .tl` (+ `.prompt`, `.dim`, `.hot`) | that it is real | see below |
+| **Data table** | `table.data` | the full numbers | mono, ink rules, never zebra |
+| **Section** | `section.report-section` + `h3.block-title` | an editorial division | 2px ink rule above |
+| **Marginal** | `.marginal` (`.ast`) | the gotcha, as a footnote | ≤2 lines |
+| **Caption** | `p.caption` | what a chart is showing | serif italic, dim |
+
+**The hero earns roughly half the surface.** Whichever part proves the point gets
+the space; the supporting parts stay small. Two to three body parts per card,
+more only in a long-form report where sections do the pacing.
+
+## The terminal is a transcription, not scenery
+
+When a terminal appears, it is real captured output, condensed by **cutting whole
+rows** — never by smoothing real output into summary prose. A 5-column table cut
+to 3 rows still reads real; the same data rewritten as a sentence reads like
+marketing. Missing values print `—`, the way a real CLI does; never invent one.
+Monospace alignment is binary — every row pads to one shared character width.
+
+## Charts
+
+Charts obey `laws.md` §5: the ink ramp encodes magnitude only, every mark is
+directly labelled, and any two-series chart carries a legend. Colour choices
+beyond that belong to the `dataviz` skill, not to PRESS.
+
+## Unavailable data
+
+`p.unavailable` — mono, dim, a 2px dim rule on the left. A section with no data
+says so in place. It is never silently dropped, because a missing section and a
+section that doesn't exist look identical to the reader.