@urbicon-ui/design-engine 6.1.8

package/src/linter/tokens.test.ts

@@ -0,0 +1,111 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from 'vitest';
+import { resolveValidTokenCores, VALID_TOKEN_CORES } from './tokens.js';
+
+/**
+ * Drift guard: the hardcoded {@link VALID_TOKEN_CORES} is the design-engine's
+ * standalone copy of the design tokens. When the blocks CSS source is present
+ * (i.e. running inside the monorepo) we re-derive the token cores from it and
+ * assert the two agree exactly. Any token added to / removed from the CSS that
+ * is not mirrored here will fail this test — keeping the hallucination detector
+ * honest. The design-engine ships without the CSS, so this can only run in-repo.
+ */
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const styleDir = resolve(__dirname, '..', '..', '..', 'blocks', 'src', 'lib', 'style');
+const foundation = resolve(styleDir, 'foundation.css');
+const semantic = resolve(styleDir, 'semantic.css');
+const cssAvailable = existsSync(foundation) && existsSync(semantic);
+
+/** Token cores that intentionally live in CSS but are NOT colour-utility cores. */
+const EXCLUDED_PREFIXES = ['shadow-']; // shadows are used via `shadow-[var(--blocks-shadow-*)]`, not `bg-shadow-*`
+
+function deriveCoresFromCss(): Set<string> {
+  const cores = new Set<string>();
+  for (const file of [foundation, semantic]) {
+    const css = readFileSync(file, 'utf-8');
+    for (const m of css.matchAll(/--color-([a-z0-9-]+)\s*:/g)) {
+      const core = m[1]!;
+      if (EXCLUDED_PREFIXES.some((p) => core.startsWith(p))) continue;
+      cores.add(core);
+    }
+  }
+  return cores;
+}
+
+describe.skipIf(!cssAvailable)('token whitelist drift guard', () => {
+  it('recognises every colour token defined in the CSS (no forgotten additions)', () => {
+    const cssCores = deriveCoresFromCss();
+    const missing = [...cssCores].filter((c) => !VALID_TOKEN_CORES.has(c)).sort();
+    expect(missing, `CSS tokens missing from VALID_TOKEN_CORES: ${missing.join(', ')}`).toEqual([]);
+  });
+
+  it('contains no phantom tokens absent from the CSS (no invented entries)', () => {
+    const cssCores = deriveCoresFromCss();
+    const phantom = [...VALID_TOKEN_CORES].filter((c) => !cssCores.has(c)).sort();
+    expect(
+      phantom,
+      `Entries in VALID_TOKEN_CORES with no matching --color-* in CSS: ${phantom.join(', ')}`
+    ).toEqual([]);
+  });
+
+  it('each EXCLUDED_PREFIX still matches a real CSS token (exclusion not stale)', () => {
+    const css = readFileSync(foundation, 'utf-8') + readFileSync(semantic, 'utf-8');
+    for (const prefix of EXCLUDED_PREFIXES) {
+      expect(
+        css,
+        `EXCLUDED_PREFIX "${prefix}" no longer matches any --color-* token — may be stale`
+      ).toMatch(new RegExp(`--color-${prefix}`));
+    }
+  });
+});
+
+describe('token whitelist shape', () => {
+  it('includes representative tokens from each family', () => {
+    for (const core of [
+      'surface-base',
+      'text-primary',
+      'border-subtle',
+      'primary',
+      'primary-500',
+      'feedback-success-subtle',
+      'interactive-hover',
+      'chart-1'
+    ]) {
+      expect(VALID_TOKEN_CORES.has(core), core).toBe(true);
+    }
+  });
+});
+
+describe('resolveValidTokenCores', () => {
+  it('returns the built-in set by reference when there are no extras (no allocation)', () => {
+    expect(resolveValidTokenCores()).toBe(VALID_TOKEN_CORES);
+    expect(resolveValidTokenCores([])).toBe(VALID_TOKEN_CORES);
+  });
+
+  it('merges extra cores on top of the built-in whitelist', () => {
+    const resolved = resolveValidTokenCores(['surface-brand', 'primary-vivid']);
+    expect(resolved.has('surface-brand')).toBe(true);
+    expect(resolved.has('primary-vivid')).toBe(true);
+    expect(resolved.has('surface-base'), 'built-ins still present').toBe(true);
+  });
+
+  it('normalises input — trims surrounding whitespace and drops blanks', () => {
+    const resolved = resolveValidTokenCores(['  surface-brand  ', '', '   ']);
+    expect(resolved.has('surface-brand')).toBe(true);
+    expect(resolved.has('')).toBe(false);
+  });
+
+  it('treats an all-blank list as no extras (built-in set by reference)', () => {
+    expect(resolveValidTokenCores(['', '  '])).toBe(VALID_TOKEN_CORES);
+  });
+
+  it('never mutates the shared built-in set', () => {
+    const before = VALID_TOKEN_CORES.size;
+    resolveValidTokenCores(['surface-brand']);
+    expect(VALID_TOKEN_CORES.size).toBe(before);
+    expect(VALID_TOKEN_CORES.has('surface-brand')).toBe(false);
+  });
+});

package/src/linter/tokens.ts

@@ -0,0 +1,230 @@
+/**
+ * The authoritative set of Urbicon UI semantic design tokens, expressed as the
+ * "core" of a Tailwind colour utility (the part after `bg-`/`text-`/`border-`/…).
+ *
+ * SOURCE OF TRUTH: `packages/blocks/src/lib/style/{foundation,semantic}.css`
+ * (the `--color-*` custom properties). This list is hand-maintained but guarded
+ * against drift by `tokens.test.ts`, which re-derives the set from the CSS when
+ * run inside the monorepo and fails on any mismatch. The design-engine ships
+ * standalone (no access to the blocks source at runtime), so the data must live
+ * here, not be read from disk.
+ *
+ * Why a whitelist: token hallucination is the single biggest weakness of
+ * design-quality guidance — the model invents plausible names like
+ * `bg-status-danger` or `text-success-fg`
+ * that do not exist. A deterministic whitelist turns that from a guess into a
+ * fact: a utility whose core looks semantic but is absent here is flagged.
+ */
+
+/** Surface background tokens → `bg-surface-*`. */
+const SURFACE_CORES = [
+  'surface-base',
+  'surface-quiet',
+  'surface-subtle',
+  'surface-elevated',
+  'surface-overlay',
+  'surface-interactive',
+  'surface-hover',
+  'surface-active',
+  'surface-disabled',
+  'surface-selected',
+  'surface-inverted'
+] as const;
+
+/** Text colour tokens → `text-text-*` (the `text-` namespace, used after a colour prefix). */
+const TEXT_CORES = [
+  'text-primary',
+  'text-secondary',
+  'text-tertiary',
+  'text-quaternary',
+  'text-disabled',
+  'text-inverted',
+  'text-on-primary',
+  'text-on-dark',
+  'text-on-surface'
+] as const;
+
+/** Border colour tokens → `border-border-*`. */
+const BORDER_CORES = [
+  'border-subtle',
+  'border-default',
+  'border-emphasis',
+  'border-strong',
+  'border-hairline'
+] as const;
+
+/** Intent palettes. Each has a bare token plus the four interaction variants. */
+const INTENT_NAMES = [
+  'primary',
+  'secondary',
+  'success',
+  'warning',
+  'danger',
+  'info',
+  'neutral'
+] as const;
+
+const INTENT_VARIANTS = ['hover', 'active', 'subtle', 'emphasis'] as const;
+
+/** Numbered foundation steps present on every intent scale. */
+const SCALE_STEPS = [
+  '50',
+  '100',
+  '200',
+  '300',
+  '400',
+  '500',
+  '600',
+  '700',
+  '800',
+  '900',
+  '950'
+] as const;
+
+/**
+ * `neutral` carries an extended ramp beyond the standard scale (finer steps for
+ * the surface ladder). Omitting these would make the hallucination rule flag a
+ * real token like `bg-neutral-650` — the drift guard in tokens.test.ts caught
+ * exactly that.
+ */
+const NEUTRAL_EXTRA_STEPS = ['0', '25', '650', '750', '850'] as const;
+
+/** Warm-neutral foundation scale (used by the Organic/Warm paradigm). Scale-only — no semantic variants. */
+const WARM_NEUTRAL_STEPS = SCALE_STEPS;
+
+/** Feedback tokens for status messaging → `bg-feedback-*` / `text-feedback-*`. */
+const FEEDBACK_CORES = [
+  'feedback-info',
+  'feedback-info-subtle',
+  'feedback-success',
+  'feedback-success-subtle',
+  'feedback-warning',
+  'feedback-warning-subtle',
+  'feedback-error',
+  'feedback-error-subtle'
+] as const;
+
+/** Interactive overlay tokens. */
+const INTERACTIVE_CORES = [
+  'interactive-hover',
+  'interactive-active',
+  'interactive-focus',
+  'interactive-disabled'
+] as const;
+
+/** Chart series tokens → `text-chart-1` … `text-chart-6`. */
+const CHART_CORES = ['chart-1', 'chart-2', 'chart-3', 'chart-4', 'chart-5', 'chart-6'] as const;
+
+function buildIntentCores(): string[] {
+  const cores: string[] = [];
+  for (const intent of INTENT_NAMES) {
+    cores.push(intent); // bare, e.g. `bg-primary`
+    for (const variant of INTENT_VARIANTS) cores.push(`${intent}-${variant}`); // `bg-primary-subtle`
+    for (const step of SCALE_STEPS) cores.push(`${intent}-${step}`); // `bg-primary-500`
+  }
+  return cores;
+}
+
+/**
+ * Every valid semantic colour-utility core, as a Set for O(1) membership checks.
+ * `surface-base`, `text-primary`, `primary`, `primary-500`, `feedback-success`, …
+ */
+export const VALID_TOKEN_CORES: ReadonlySet<string> = new Set([
+  ...SURFACE_CORES,
+  ...TEXT_CORES,
+  ...BORDER_CORES,
+  ...buildIntentCores(),
+  ...NEUTRAL_EXTRA_STEPS.map((s) => `neutral-${s}`),
+  ...WARM_NEUTRAL_STEPS.map((s) => `warm-neutral-${s}`),
+  ...FEEDBACK_CORES,
+  ...INTERACTIVE_CORES,
+  ...CHART_CORES
+]);
+
+/**
+ * Normalise raw per-call extra-token input: trim each, drop blanks. These are
+ * token *cores* (e.g. `surface-brand`), matching {@link VALID_TOKEN_CORES} — not
+ * full utilities (`bg-surface-brand`) and not CSS variables. Deliberately tolerant
+ * on read (trim/drop) but it never rewrites a value, so the whitelist contract
+ * stays predictable and a caller's `surface-brand` means exactly that.
+ */
+function normalizeExtraTokens(extra: readonly string[]): string[] {
+  return extra.map((token) => token.trim()).filter((token) => token.length > 0);
+}
+
+/**
+ * The effective valid-core set for one lint run: the built-in
+ * {@link VALID_TOKEN_CORES} plus any project-specific cores passed per call. The
+ * base set is hot and never mutated — so when there are no usable extras this
+ * returns it by reference (no allocation), and otherwise returns a fresh merged
+ * Set. Powers the `extraTokens` "context as parameter" path (see LintOptions).
+ */
+export function resolveValidTokenCores(extra?: readonly string[]): ReadonlySet<string> {
+  if (!extra || extra.length === 0) return VALID_TOKEN_CORES;
+  const normalized = normalizeExtraTokens(extra);
+  if (normalized.length === 0) return VALID_TOKEN_CORES;
+  const merged = new Set(VALID_TOKEN_CORES);
+  for (const core of normalized) merged.add(core);
+  return merged;
+}
+
+/**
+ * Namespaces that mark a utility core as "intended to be semantic". A core that
+ * starts with one of these but is NOT in {@link VALID_TOKEN_CORES} is a
+ * hallucinated token. Kept deliberately narrow so we never flag genuine Tailwind
+ * utilities (`bg-transparent`, `bg-cover`, arbitrary `bg-[#fff]`).
+ */
+export const SEMANTIC_NAMESPACES = [
+  'surface-',
+  'text-',
+  'border-',
+  'feedback-',
+  'interactive-',
+  'chart-'
+] as const;
+
+/** Intent prefixes (`primary-…`, `success-…`) that mark a core as semantic-intent. */
+export const INTENT_PREFIXES: readonly string[] = INTENT_NAMES;
+
+/**
+ * The shadcn/ui (and Radix) token vocabulary. This is the single most common
+ * hallucination source: with no explicit whitelist, models default to the
+ * dominant design-system convention in their training data — `text-foreground`,
+ * `bg-accent`, `text-muted-foreground`, `bg-card`, … — none of which exist in
+ * Urbicon UI. Discovered empirically during design-quality evaluation.
+ * These bare cores slip past the namespace/intent heuristics, so they are
+ * matched explicitly. (Suffix `-foreground` and the `fg`/`fg-` family are caught
+ * by rule in rules.ts.)
+ */
+export const KNOWN_FOREIGN_CORES: ReadonlySet<string> = new Set([
+  'foreground',
+  'background',
+  'muted',
+  'accent',
+  'card',
+  'popover',
+  'input',
+  'destructive',
+  'surface', // bare — the real page surface is `surface-base`
+  'muted-foreground',
+  'accent-foreground',
+  'card-foreground',
+  'popover-foreground',
+  'primary-foreground',
+  'secondary-foreground',
+  'destructive-foreground'
+]);
+
+/**
+ * Cores that are commonly hallucinated and have a known correct replacement.
+ * Drives a precise fix hint instead of a generic "unknown token".
+ */
+export const KNOWN_BAD_NAMESPACES: Record<string, string> = {
+  // `status-*` is the most frequent invention observed. Map to feedback/intents.
+  'status-':
+    'Use a `feedback-*` token (feedback-success, feedback-error, …) or a bare intent (`success`, `danger`).',
+  // `-fg` / `-foreground` suffixes are invented; the system uses `text-on-primary` etc.
+  '-fg': 'Use `text-on-primary` / `text-on-surface` for foreground-on-intent text.'
+};
+
+export { INTENT_NAMES, INTENT_VARIANTS, SCALE_STEPS };

package/src/linter/types.ts

@@ -0,0 +1,119 @@
+/**
+ * Types for the Urbicon UI design linter.
+ *
+ * The linter turns the prose Anti-Patterns and Design-Quality guidance (served
+ * today by `get_design_principles`, `suggest_implementation`,
+ * `get_implementation_checklist`) into executable checks. Deterministic rules
+ * produce `error`/`warning` findings; distribution heuristics produce `info`
+ * findings. See the design-loop context in docs/DESIGN-MCP.md.
+ */
+
+/** How serious a finding is. Drives the score deduction and the report grouping. */
+export type Severity = 'error' | 'warning' | 'info';
+
+/**
+ * Whether a finding comes from a deterministic rule (regex/string match — a fact
+ * about the code) or a statistical heuristic (a distribution judgement that can
+ * have false positives). Surfaced in the report so consumers can weight them.
+ */
+export type FindingKind = 'deterministic' | 'heuristic';
+
+/** A single linter finding, anchored to a location when one exists. */
+export interface Finding {
+  /** Stable rule identifier, e.g. `raw-tailwind-color`. Used for tests and suppression. */
+  ruleId: string;
+  severity: Severity;
+  kind: FindingKind;
+  /** Human-readable description of what is wrong. */
+  message: string;
+  /** Concrete fix hint — what to do instead. */
+  fix: string;
+  /** 1-based line number, when the finding is anchored to one. */
+  line?: number;
+  /** The offending snippet (e.g. the class token), when applicable. */
+  match?: string;
+}
+
+/**
+ * Per-run context threaded into every {@link Rule.check}. Holds values that
+ * depend on the call options rather than the source under lint — today only the
+ * effective token whitelist (the built-in cores merged with any
+ * {@link LintOptions.extraTokens}). This is the seam future per-call rule inputs
+ * (e.g. project-tuned thresholds) hang off, so rules never reach for module-global
+ * state that a caller cannot influence.
+ */
+export interface LintContext {
+  /**
+   * The valid semantic token cores for this run: the built-in whitelist plus any
+   * project-specific cores supplied via {@link LintOptions.extraTokens}.
+   */
+  validTokenCores: ReadonlySet<string>;
+}
+
+/** A deterministic rule: scans the source and emits findings. */
+export interface Rule {
+  id: string;
+  severity: Severity;
+  /** One-line description of what the rule enforces, shown in `validate_design` rule listings. */
+  description: string;
+  /**
+   * Run the rule over the already-prepared source lines.
+   * @param lines source split by `\n`, with comments masked (see linter.ts)
+   * @param raw the original source (for rules that need cross-line context)
+   * @param ctx per-run context (e.g. the effective token whitelist). Always supplied
+   *   by {@link lintDesign}; optional so a rule stays callable standalone, in which
+   *   case it falls back to its own built-in defaults.
+   */
+  check(lines: string[], raw: string, ctx?: LintContext): Finding[];
+}
+
+/**
+ * Two-axis design score (DESIGN-MCP-V2 §6: "two tracks, never mixed"). Each axis
+ * is an independent 0–100 so a correctness defect never hides behind a clean slop
+ * axis, and a generic-looking page never passes just because its tokens are valid.
+ */
+export interface LintScores {
+  /**
+   * Stage 1 — "is it correct Urbicon?". Deducts the deterministic-rule findings
+   * (the `error`/`warning` defects: raw colours, `dark:`/`focus:`, hardcoded
+   * z-index, broken dynamic classes, hallucinated tokens). Counted per occurrence —
+   * every defect is its own fix.
+   */
+  correctness: number;
+  /**
+   * Stage 2 — "does it look generic?". Deducts the system-agnostic slop-floor
+   * heuristics (the `heuristic`-kind findings). Each heuristic is one holistic
+   * judgement about the page, so it costs a flat weight once, regardless of how
+   * many times the pattern repeats.
+   */
+  slop: number;
+}
+
+/** Aggregate result of linting one code unit. */
+export interface LintReport {
+  findings: Finding[];
+  /** Two-axis 0–100 score; 100/100 = no findings on that axis. See {@link LintScores}. */
+  scores: LintScores;
+  counts: { error: number; warning: number; info: number };
+  /** Optional label (e.g. filename) echoed back in the report. */
+  filename?: string;
+}
+
+/** Options for a lint run. */
+export interface LintOptions {
+  filename?: string;
+  /** Skip the distribution heuristics (the `info`-level checks). Default: false. */
+  skipHeuristics?: boolean;
+  /**
+   * Project-specific semantic token cores to treat as valid for this run, merged
+   * into the built-in whitelist so the `token-hallucination` rule does not flag
+   * them (the "context as parameter" trick — lets a consumer on a customised or
+   * newer token set avoid false positives without the engine reading their CSS).
+   *
+   * A "core" is the part after the utility prefix, matching {@link VALID_TOKEN_CORES}:
+   * pass `surface-brand` (for `bg-surface-brand`), not `bg-surface-brand` and not the
+   * `--color-surface-brand` CSS variable. Only affects cores that already look
+   * semantic; raw-palette and `dark:`/`focus:` gates are unaffected.
+   */
+  extraTokens?: readonly string[];
+}

package/src/manifest/history.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from 'vitest';
+import { parseHistory, serializeHistoryEntry } from './history.js';
+import type { ValidationHistoryEntry } from './types.js';
+
+const entry = (over: Partial<ValidationHistoryEntry> = {}): ValidationHistoryEntry => ({
+  date: '2026-06-21T10:00:00.000Z',
+  files: 3,
+  errors: 0,
+  warnings: 1,
+  infos: 2,
+  correctness: 95,
+  slop: 60,
+  ...over
+});
+
+describe('history serialize ⇆ parse', () => {
+  it('round-trips one entry through an ndjson line', () => {
+    const e = entry();
+    const parsed = parseHistory(serializeHistoryEntry(e));
+    expect(parsed).toEqual([e]);
+  });
+
+  it('serialises to a single line (no embedded newline)', () => {
+    expect(serializeHistoryEntry(entry())).not.toContain('\n');
+  });
+
+  it('parses multiple lines newest-last, preserving order', () => {
+    const a = entry({ date: '2026-06-19T00:00:00.000Z', slop: 40 });
+    const b = entry({ date: '2026-06-20T00:00:00.000Z', slop: 50 });
+    const blob = `${serializeHistoryEntry(a)}\n${serializeHistoryEntry(b)}\n`;
+    expect(parseHistory(blob).map((e) => e.slop)).toEqual([40, 50]);
+  });
+});
+
+describe('history parse tolerance', () => {
+  it('skips blank lines and a malformed/truncated tail without throwing', () => {
+    const good = serializeHistoryEntry(entry());
+    const blob = `\n${good}\n{"date":"2026-06-21T11:00:00Z","corre`; // half-written CI tail
+    const parsed = parseHistory(blob);
+    expect(parsed).toHaveLength(1);
+    expect(parsed[0]!.correctness).toBe(95);
+  });
+
+  it('rejects JSON that lacks the entry shape', () => {
+    expect(parseHistory('{"foo":1}\n[1,2,3]\n"a string"\nnull')).toEqual([]);
+  });
+
+  it('skips an entry whose numeric fields are malformed (not rendered as NaN)', () => {
+    const bad = JSON.stringify({
+      date: '2026-06-21T00:00:00.000Z',
+      files: 'NaN',
+      errors: 0,
+      warnings: 0,
+      infos: 0,
+      correctness: 100,
+      slop: 50
+    });
+    expect(parseHistory(bad)).toEqual([]);
+  });
+
+  it('returns [] for an empty blob', () => {
+    expect(parseHistory('')).toEqual([]);
+    expect(parseHistory('   \n\n')).toEqual([]);
+  });
+});

package/src/manifest/history.ts

@@ -0,0 +1,57 @@
+/**
+ * The validation-history sidecar: an append-only ndjson log of `urbicon validate
+ * --record` runs, so design drift is measurable over time (DESIGN-MCP-V2 §7).
+ *
+ * Pure string ⇆ object conversion only — the file I/O (resolving the sidecar path,
+ * appending a line) lives in the CLI's `manifest-io`, mirroring the rest of the
+ * manifest module: the engine is dependency-free string logic, the CLI owns the
+ * filesystem. ndjson is parsed tolerantly (a malformed or truncated line is
+ * skipped, never thrown) — a half-written tail from an interrupted CI run must not
+ * make the whole history unreadable.
+ */
+
+import type { ValidationHistoryEntry } from './types.js';
+
+/** Serialise one entry to a single ndjson line (no trailing newline — the writer adds it). */
+export function serializeHistoryEntry(entry: ValidationHistoryEntry): string {
+  return JSON.stringify(entry);
+}
+
+/**
+ * True when a parsed value has the full shape of a history entry. Strict on the
+ * numeric fields (not just date/correctness/slop) so a hand-corrupted line —
+ * `files: "NaN"` — is skipped rather than rendered verbatim into the drift summary;
+ * the sidecar is machine-written, so a real entry always carries every field.
+ */
+function isEntry(value: unknown): value is ValidationHistoryEntry {
+  if (typeof value !== 'object' || value === null) return false;
+  const e = value as Record<string, unknown>;
+  return (
+    typeof e.date === 'string' &&
+    typeof e.files === 'number' &&
+    typeof e.errors === 'number' &&
+    typeof e.warnings === 'number' &&
+    typeof e.infos === 'number' &&
+    typeof e.correctness === 'number' &&
+    typeof e.slop === 'number'
+  );
+}
+
+/**
+ * Parse an ndjson history blob into entries, newest last (file order preserved).
+ * Blank and malformed lines are skipped so a corrupt tail never throws.
+ */
+export function parseHistory(ndjson: string): ValidationHistoryEntry[] {
+  const entries: ValidationHistoryEntry[] = [];
+  for (const line of ndjson.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed: unknown = JSON.parse(trimmed);
+      if (isEntry(parsed)) entries.push(parsed);
+    } catch {
+      // malformed/partial line — read tolerant, skip it
+    }
+  }
+  return entries;
+}

package/src/manifest/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Public API of the design-manifest module — the persistent design-intent layer
+ * (docs/DESIGN-MCP.md, Option C). Consumed by the `urbicon` CLI
+ * (context / record-decision / sync-manifest) in `@urbicon-ui/design`.
+ */
+
+export { parseHistory, serializeHistoryEntry } from './history.js';
+export {
+  appendDecision,
+  createManifestTemplate,
+  DECISIONS_HEADING,
+  emptyManifest,
+  formatContext,
+  parseFrontmatter,
+  parseManifest,
+  renderDecision,
+  USAGES_HEADING,
+  upsertUsagesSection
+} from './manifest.js';
+export { scanMarkers } from './scan.js';
+export type {
+  DesignDecision,
+  DesignManifest,
+  PatternUsage,
+  ProductIntent,
+  ValidationHistoryEntry
+} from './types.js';