@urbicon-ui/mcp-server 6.1.5 → 6.1.6

package/README.md

@@ -62,23 +62,20 @@ For Cursor: see [Cursor's MCP docs](https://docs.cursor.com/context/model-contex
 
 ## Tools
 
-Most tools are read-only (`readOnlyHint: true`). The two manifest-writing tools (`record_design_decision`, `sync_design_manifest`) write `design.manifest.md` in the project root. Queries are Zod-validated.
-
-| Tool                           | Purpose                                                                                                                                                                                                                                                                |
-| ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `find_components`              | Fuzzy search across component names, tags, and descriptions. Filterable by package (`blocks`, `table`, `auth`).                                                                                                                                                        |
-| `get_component`                | Full per-component documentation: props, variants, slots, examples, source link. Optional `section` argument for streamed chunks (overview / examples / variants / api / slots).                                                                                       |
-| `get_recipe`                   | Full production-ready recipe (login-form, dashboard, settings-page, etc.) with component tree, code, and notes.                                                                                                                                                        |
-| `suggest_implementation`       | Takes a natural-language goal and returns a component-tree suggestion, relevant recipes, Style-Patterns guide, and the implementation checklist.                                                                                                                       |
-| `get_implementation_checklist` | Design-Quality checklist (visual weight, intent semantics, spacing, radius, data-driven styling, dominance, identity) — embedded directly so the LLM can self-verify.                                                                                                  |
-| `get_css_reference`            | Full token reference — surface, text, border, intent, feedback tokens, radii, z-index. Includes an explicit "do not invent tokens" guardrail.                                                                                                                          |
-| `find_icons`                   | Browse the 156-icon catalog by keyword, category, or name.                                                                                                                                                                                                             |
-| `get_design_principles`        | Design heuristics (Layer 5): visual hierarchy, interaction, component selection, layout, accessibility, theming (paradigms, change decision tree). Call first when generating UI. `as="rubric"` returns the 8-criterion 1–5 scoring rubric for judging a generated UI. |
-| `get_pattern`                  | Composition patterns (Layer 4) for page archetypes — settings-page, dashboard, form-page, tab-navigation, onboarding-guide.                                                                                                                                            |
-| `validate_design`              | Lint generated markup against the design rules — raw colours, `dark:`/`focus:` misuse, hardcoded z-index, broken dynamic classes, hallucinated tokens, plus distribution heuristics. Returns a 0–100 score and per-finding fixes for a generate → validate → fix loop. |
-| `get_design_context`           | Read the project's `design.manifest.md`: chosen paradigm/theme/density, which pages use which composition patterns, and recorded design decisions (ADRs). Call at the start of a UI task to stay consistent with prior decisions.                                      |
-| `record_design_decision`       | Append a design decision (ADR) to the manifest — record a deliberate deviation from a pattern or principle so future sessions honour it. Writes `design.manifest.md`.                                                                                                  |
-| `sync_design_manifest`         | Scan the project source for `data-design-pattern` markers and regenerate the manifest's Pattern Usages index — makes a pattern change tractable (grep the markers → migrate every listed file).                                                                        |
+All tools are read-only (`readOnlyHint: true`) — this server never touches the consumer's filesystem. Queries are Zod-validated. (Manifest read/write moved to the `urbicon` CLI in [`@urbicon-ui/design`](../design/); a stateless remote server cannot reach a consumer's repo.)
+
+| Tool                           | Purpose                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `find_components`              | Fuzzy search across component names, tags, and descriptions. Filterable by package (`blocks`, `table`, `auth`).                                                                                                                                                                                                                                                                                                                                    |
+| `get_component`                | Full per-component documentation: props, variants, slots, examples, source link. Optional `section` argument for streamed chunks (overview / examples / variants / api / slots).                                                                                                                                                                                                                                                                   |
+| `get_recipe`                   | Full production-ready recipe (login-form, dashboard, settings-page, etc.) with component tree, code, and notes.                                                                                                                                                                                                                                                                                                                                    |
+| `suggest_implementation`       | Takes a natural-language goal and returns a component-tree suggestion, relevant recipes, Style-Patterns guide, and the implementation checklist.                                                                                                                                                                                                                                                                                                   |
+| `get_implementation_checklist` | Design-Quality checklist (visual weight, intent semantics, spacing, radius, data-driven styling, dominance, identity) — embedded directly so the LLM can self-verify.                                                                                                                                                                                                                                                                              |
+| `get_css_reference`            | Full token reference — surface, text, border, intent, feedback tokens, radii, z-index. Includes an explicit "do not invent tokens" guardrail.                                                                                                                                                                                                                                                                                                      |
+| `find_icons`                   | Browse the 315-icon catalog by keyword, category, or name.                                                                                                                                                                                                                                                                                                                                                                                         |
+| `get_design_principles`        | Design heuristics (Layer 5): visual hierarchy, interaction, component selection, layout, accessibility, theming (paradigms, change decision tree). Call first when generating UI. `as="rubric"` returns the 8-criterion 1–5 scoring rubric for judging a generated UI.                                                                                                                                                                             |
+| `get_pattern`                  | Composition patterns (Layer 4) for page archetypes — settings-page, dashboard, form-page, tab-navigation, onboarding-guide.                                                                                                                                                                                                                                                                                                                        |
+| `validate_design`              | Lint generated markup on two axes — **correctness** (raw colours, `dark:`/`focus:` misuse, hardcoded z-index, broken dynamic classes, hallucinated tokens, foreign-library component APIs, unlabelled icon buttons; the blocking gate) and the **slop-floor** (20 system-agnostic "looks generic" heuristics: generic fonts, animated dimensions, grey-on-colour, touch targets, …; advisory). Returns a correctness score + a slop-floor score and per-finding fixes for a generate → validate → fix loop. |
 
 ## Resources
 
@@ -92,49 +89,55 @@ Most tools are read-only (`readOnlyHint: true`). The two manifest-writing tools
 
 ## Prompts
 
-Client-agnostic workflows (Option E of the design loop) — invoke them from any MCP client to run the full generate → validate → judge → synthesise process rather than a single-shot generation.
-
-| Prompt        | Arguments                        | Purpose                                                                                                                                                          |
-| ------------- | -------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `design-page` | `brief`, `pattern?`, `variants?` | Design a new page: load context + pattern, explore N variants within the paradigm, gate each on `validate_design`, score with the rubric, synthesise the winner. |
-| `redesign`    | `brief`, `code?`, `variants?`    | Redesign an existing page: diagnose with `validate_design` + the rubric, then fix exactly the flagged weaknesses while preserving behaviour.                     |
+The full design-verb table (DESIGN-MCP-V2 §8) — client-agnostic workflows you invoke from any MCP client to run a multi-step recipe over the four design planes rather than a single-shot generation. Each recipe is the same text the local `@urbicon-ui/design` skill ships (single source, bundled via `@urbicon-ui/design-content`): it opens by reading the project's `design.manifest.md`, does the work through the read-only tools above, and closes by writing the decision back.
+
+| Prompt     | Arguments                      | Purpose                                                                                    |
+| ---------- | ------------------------------ | ------------------------------------------------------------------------------------------ |
+| `onboard`  | `brief?`                       | Greenfield: interview product intent + intake, seed the manifest.                          |
+| `adopt`    | `brief?`                       | Brownfield: infer the design language from code, measure drift, seed the manifest.         |
+| `compose`  | `brief?`, `variants?`          | New page via generate → validate → judge → synthesise (variants + rubric + linter gate).   |
+| `redesign` | `brief?`, `code?`, `variants?` | Diagnose with linter + rubric, fix exactly the flagged weaknesses, preserve behaviour.     |
+| `polish`   | `brief?`, `code?`              | Small token-level fixes that raise the slop-floor score without restructuring.             |
+| `critique` | `brief?`, `code?`              | Judge without changing: correctness + slop + rubric → a prioritised, verb-tagged fix-list. |
+| `fix`      | `brief?`, `code?`              | Repair correctness defects (raw colours, `dark:`/`focus:`, z-index, hallucinated tokens).  |
+| `retheme`  | `brief?`                       | Rebrand: change the token layer once, propagate across every affected file.                |
+| `audit`    | `brief?`                       | App-wide sweep: validate the tree, check pattern cohorts, report drift over time.          |
+| `migrate`  | `brief?`                       | Roll out a pattern/library change across every site, gated per file.                       |
 
 ## CLI Options
 
 ```
-urbicon-mcp [--transport <stdio|http>] [--port <n>] [--data-dir <path>]
+urbicon-mcp [--transport <stdio|http>] [--port <n>] [--content-dir <path>]
 ```
 
-| Flag          | Default       | Purpose                                                      |
-| ------------- | ------------- | ------------------------------------------------------------ |
-| `--transport` | `stdio`       | Transport mode                                               |
-| `--port`      | `3001`        | HTTP port (ignored for stdio)                                |
-| `--data-dir`  | auto-discover | Override the path to the generated catalog/templates/recipes |
+| Flag            | Default       | Purpose                                                        |
+| --------------- | ------------- | -------------------------------------------------------------- |
+| `--transport`   | `stdio`       | Transport mode                                                 |
+| `--port`        | `3001`        | HTTP port (ignored for stdio)                                  |
+| `--content-dir` | auto-discover | Override the design-content bundle dir (`URBICON_CONTENT_DIR`) |
 
 ## Architecture
 
 ```
 src/
-├── index.ts                 CLI entry + arg parsing, pre-loads catalog/templates/recipes
+├── index.ts                 CLI entry + arg parsing, pre-loads catalog/templates/principles
 ├── server.ts                MCP server construction (registers resources + tools)
 ├── transports/
 │   ├── stdio.ts             Stdio transport
 │   └── http.ts              Streamable HTTP transport (per-session)
-├── tools/                   13 tools, each self-contained
-├── design-linter/           validate_design engine: rules, token whitelist, heuristics (pure, unit-tested)
-├── design-manifest/         design.manifest.md parse/scan/edit for the design-context tools
+├── tools/                   10 tools, each self-contained
+│                            (validate_design calls @urbicon-ui/design-engine)
 ├── resources/               Catalog + guide resources
-├── data/                    Loaders with in-process caching
-│   ├── catalog-loader.ts    component-catalog.json
-│   ├── template-loader.ts   llms.txt sections
-│   ├── recipe-loader.ts     Recipes
+├── data/                    Loaders with in-process caching (read the design-content bundle)
+│   ├── catalog-loader.ts    component-catalog.json (components + recipes)
+│   ├── template-loader.ts   guide template sections
 │   ├── design-system-loader.ts  principles.md + patterns/*.md
-│   ├── component-loader.ts
-│   └── icon-loader.ts
-└── utils/                   search, format-catalog, paths
+│   ├── component-loader.ts  per-component llm.txt
+│   └── icon-loader.ts       icons.json
+└── utils/                   search, format-catalog
 ```
 
-The server reads its data from artifacts produced by [`@urbicon-ui/docs-gen`](../docs-gen/) (`component-catalog.json`, per-component `llms.txt`, recipes). That means JSDoc in a component's `index.ts` is the **single source of truth**: one edit propagates to the docs site, `llms-full.txt`, and every MCP tool.
+The server reads its data from the version-pinned [`@urbicon-ui/design-content`](../design-content/) bundle (built by [`@urbicon-ui/docs-gen`](../docs-gen/): `component-catalog.json` with recipes, per-component `llm.txt`, design-system, guide template, `icons.json`). That means JSDoc in a component's `index.ts` is the **single source of truth**: one edit propagates to the docs site, `llms-full.txt`, and every MCP tool.
 
 ## Development
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@urbicon-ui/mcp-server",
-  "version": "6.1.5",
+  "version": "6.1.6",
   "description": "Model Context Protocol server exposing the Urbicon UI component catalog, recipes and design intelligence to LLM agents",
   "license": "MIT",
   "repository": {
@@ -32,6 +32,8 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "@urbicon-ui/design-content": "6.1.6",
+    "@urbicon-ui/design-engine": "6.1.6",
     "zod": "^4.3.6"
   },
   "devDependencies": {

package/src/data/catalog-loader.test.ts

@@ -1,6 +1,6 @@
 import { existsSync } from 'node:fs';
+import { getCatalogPath } from '@urbicon-ui/design-content';
 import { describe, expect, it } from 'vitest';
-import { getCatalogPath } from '../utils/paths.js';
 import { getCachedCatalog, loadCatalog } from './catalog-loader.js';
 
 // Integration test: exercises the real catalog JSON produced by docs-gen.

package/src/data/catalog-loader.ts

@@ -1,42 +1,17 @@
 import { watch } from 'node:fs';
 import { readFile } from 'node:fs/promises';
-import { getCatalogPath } from '../utils/paths.js';
-
-export interface ComponentCatalogEntry {
-  name: string;
-  slug: string;
-  package: string;
-  group: 'primitives' | 'components' | 'core' | 'auth';
-  description: string;
-  tags: string[];
-  import: string;
-  llmTxtPath: string;
-  variants: { name: string; values: string[]; default?: string }[];
-  keyProps: string[];
-  keyPropTypes: Record<string, string>;
-  slots: string[];
-  hasExamples: boolean;
-  relatedComponents: string[];
-}
-
-export interface RecipeEntry {
-  id: string;
-  title: string;
-  description: string;
-  components: string[];
-  code: string;
-  features: string[];
-  /** Layer-4 composition pattern this recipe is an instance of (e.g. "dashboard"). Cross-links to `get_pattern`. */
-  pattern?: string;
-}
-
-export interface ComponentCatalog {
-  generated: string;
-  version: string;
-  components: ComponentCatalogEntry[];
-  recipes: RecipeEntry[];
-  tags: string[];
-}
+import { getCatalogPath } from '@urbicon-ui/design-content';
+import type {
+  ComponentCatalog,
+  ComponentCatalogEntry,
+  RecipeEntry
+} from '@urbicon-ui/design-engine/search';
+
+// The catalog schema lives in the engine now (DESIGN-MCP-V2 §5) so the `urbicon`
+// CLI's find/get-component and this server share one authoritative type. Imported
+// above for the loader below; re-exported here for the server's many local
+// importers (tools, resources, format-catalog) that still source it from here.
+export type { ComponentCatalog, ComponentCatalogEntry, RecipeEntry };
 
 let cachedCatalog: ComponentCatalog | null = null;
 let watcherInitialized = false;

package/src/data/component-loader.ts

@@ -1,5 +1,5 @@
 import { readFile } from 'node:fs/promises';
-import { getComponentLlmPath } from '../utils/paths.js';
+import { getComponentLlmPath } from '@urbicon-ui/design-content';
 
 const SEARCH_GROUPS = [
   'blocks/primitives',
@@ -27,42 +27,7 @@ export async function loadComponentLlmTxt(slug: string): Promise<string | null>
   return null;
 }
 
-export type LlmTxtSection = 'overview' | 'examples' | 'variants' | 'api' | 'slots';
-
-const SECTION_HEADING_MAP: Record<string, LlmTxtSection> = {
-  examples: 'examples',
-  variants: 'variants',
-  api: 'api',
-  'slots (slotclasses keys)': 'slots'
-};
-
-export function extractSection(content: string, section: LlmTxtSection): string | null {
-  if (section === 'overview') {
-    const firstH3 = content.indexOf('\n### ');
-    if (firstH3 === -1) return content.trim();
-    return content.slice(0, firstH3).trim();
-  }
-
-  const lines = content.split('\n');
-  let capturing = false;
-  const result: string[] = [];
-
-  for (const line of lines) {
-    if (line.startsWith('### ')) {
-      const heading = line.slice(4).trim().toLowerCase();
-      const mapped = SECTION_HEADING_MAP[heading];
-      if (mapped === section) {
-        capturing = true;
-        result.push(line);
-        continue;
-      } else if (capturing) {
-        break;
-      }
-    }
-    if (capturing) {
-      result.push(line);
-    }
-  }
-
-  return result.length > 0 ? result.join('\n').trim() : null;
-}
+// The section parser lives in the engine now (DESIGN-MCP-V2 §5) so this server and
+// the `urbicon` CLI extract llm.txt sections identically. Re-exported here for the
+// server's local importers (get-component, get-recipe, …).
+export { extractSection, type LlmTxtSection } from '@urbicon-ui/design-engine/search';

package/src/data/design-system-loader.test.ts

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
+import { getDesignSystemDir } from '@urbicon-ui/design-content';
 import { describe, expect, it } from 'vitest';
-import { getDesignSystemDir } from '../utils/paths.js';
 import {
   extractPrincipleSection,
   getPatternByName,

package/src/data/design-system-loader.ts

@@ -1,6 +1,6 @@
 import { readdir, readFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
-import { getDesignSystemDir } from '../utils/paths.js';
+import { getDesignSystemDir } from '@urbicon-ui/design-content';
 
 export interface PatternEntry {
   name: string;

package/src/data/icon-loader.test.ts

@@ -1,85 +1,30 @@
+import { existsSync } from 'node:fs';
+import { getIconsPath } from '@urbicon-ui/design-content';
 import { describe, expect, it } from 'vitest';
-import { parseComponentNames, parseIconMetadata } from './icon-loader.js';
-
-const FIXTURE = `
-// Simulated icon.context.ts content
-import type { Component } from 'svelte';
-import HomeIcon from './HomeIcon.svelte';
-import SearchIcon from './SearchIcon.svelte';
-
-export const DEFAULT_ICONS = {
-  home: HomeIcon,
-  search: SearchIcon,
-  arrowRight: ArrowRightIcon
-};
-
-export const ICON_METADATA = {
-  home: { label: 'Home', categories: ['navigation'], keywords: ['house', 'start'] },
-  search: { label: 'Search', categories: ['navigation', 'ui'], keywords: ['find', 'lookup'] },
-  arrowRight: { label: 'Arrow Right', categories: ['navigation'], keywords: [] }
-};
-`;
-
-describe('parseComponentNames', () => {
-  it('builds a name → ComponentName map from DEFAULT_ICONS', () => {
-    const map = parseComponentNames(FIXTURE);
-    expect(map.get('home')).toBe('HomeIcon');
-    expect(map.get('search')).toBe('SearchIcon');
-    expect(map.get('arrowRight')).toBe('ArrowRightIcon');
-  });
-
-  it('returns an empty map when the DEFAULT_ICONS block is missing', () => {
-    const map = parseComponentNames('const NOT_IT = {};');
-    expect(map.size).toBe(0);
-  });
-});
-
-describe('parseIconMetadata', () => {
-  it('extracts label, categories, and keywords per entry', () => {
-    const entries = parseIconMetadata(FIXTURE);
-    expect(entries).toHaveLength(3);
-
-    const home = entries.find((e) => e.name === 'home');
-    expect(home).toMatchObject({
-      name: 'home',
-      componentName: 'HomeIcon',
-      label: 'Home',
-      categories: ['navigation'],
-      keywords: ['house', 'start']
-    });
-  });
-
-  it('uses the DEFAULT_ICONS mapping for componentName when available', () => {
-    const entries = parseIconMetadata(FIXTURE);
-    const search = entries.find((e) => e.name === 'search');
-    expect(search?.componentName).toBe('SearchIcon');
-  });
-
-  it('falls back to a capitalised name + "Icon" suffix when no mapping exists', () => {
-    const withoutMapping = `
-      export const ICON_METADATA = {
-        custom: { label: 'Custom', categories: ['x'], keywords: ['y'] }
-      };
-    `;
-    const entries = parseIconMetadata(withoutMapping);
-    expect(entries[0]?.componentName).toBe('CustomIcon');
-  });
-
-  it('returns an empty array when ICON_METADATA block is missing', () => {
-    expect(parseIconMetadata('// nothing to see')).toEqual([]);
+import { loadIcons } from './icon-loader.js';
+
+// Integration test: exercises the real icons.json from the content bundle. The
+// registry-parsing logic itself is unit-tested in docs-gen (icons.test.ts); here we
+// only assert the loader reads + shapes the bundled JSON. Skipped on a fresh checkout
+// before the bundle has been generated.
+const iconsAvailable = existsSync(getIconsPath());
+
+describe.skipIf(!iconsAvailable)('icon-loader integration', () => {
+  it('loads icons with the expected shape', async () => {
+    const icons = await loadIcons();
+    expect(icons.length).toBeGreaterThan(0);
+    for (const icon of icons) {
+      expect(icon.name).toBeTruthy();
+      expect(icon.componentName).toMatch(/Icon$/);
+      expect(typeof icon.label).toBe('string');
+      expect(Array.isArray(icon.categories)).toBe(true);
+      expect(Array.isArray(icon.keywords)).toBe(true);
+    }
   });
 
-  it('handles empty categories and keywords arrays gracefully', () => {
-    const fixture = `
-      export const ICON_METADATA = {
-        minimal: { label: 'Minimal', categories: [], keywords: [] }
-      };
-    `;
-    const entries = parseIconMetadata(fixture);
-    expect(entries[0]).toMatchObject({
-      name: 'minimal',
-      categories: [],
-      keywords: []
-    });
+  it('caches between invocations', async () => {
+    const first = await loadIcons();
+    const second = await loadIcons();
+    expect(second).toBe(first);
   });
 });

package/src/data/icon-loader.ts

@@ -1,9 +1,5 @@
 import { readFile } from 'node:fs/promises';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const packageRoot = resolve(__dirname, '..', '..');
+import { getIconsPath } from '@urbicon-ui/design-content';
 
 export interface IconEntry {
   name: string;
@@ -15,73 +11,17 @@ export interface IconEntry {
 
 let cachedIcons: IconEntry[] | null = null;
 
-function getIconRegistryPath(): string {
-  // DEFAULT_ICONS + ICON_METADATA live in icon-registry.ts since the icon module
-  // split (icon.context.ts now holds only the override context + resolveIcon).
-  return resolve(packageRoot, '..', 'blocks', 'src', 'lib', 'icons', 'icon-registry.ts');
-}
-
-/** Parse DEFAULT_ICONS to get the real name → ComponentName mapping */
-export function parseComponentNames(content: string): Map<string, string> {
-  const map = new Map<string, string>();
-  const start = content.indexOf('DEFAULT_ICONS');
-  if (start === -1) return map;
-
-  const end = content.indexOf('};', start);
-  if (end === -1) return map;
-
-  const block = content.slice(start, end);
-  const regex = /(\w+):\s*(\w+Icon)/g;
-  for (const match of block.matchAll(regex)) {
-    map.set(match[1]!, match[2]!);
-  }
-  return map;
-}
-
-export function parseIconMetadata(content: string): IconEntry[] {
-  const componentNames = parseComponentNames(content);
-  const entries: IconEntry[] = [];
-
-  const metadataStart = content.indexOf('ICON_METADATA');
-  if (metadataStart === -1) return [];
-
-  const entryRegex =
-    /(\w+):\s*\{\s*label:\s*'([^']*)',\s*categories:\s*\[([^\]]*)\],\s*keywords:\s*\[([^\]]*)\]\s*\}/g;
-  const block = content.slice(metadataStart);
-
-  for (const match of block.matchAll(entryRegex)) {
-    const name = match[1]!;
-    const label = match[2]!;
-    const categories = match[3]!
-      .split(',')
-      .map((s) => s.trim().replace(/^'|'$/g, ''))
-      .filter((s) => s.length > 0);
-    const keywords = match[4]!
-      .split(',')
-      .map((s) => s.trim().replace(/^'|'$/g, ''))
-      .filter((s) => s.length > 0);
-
-    const componentName =
-      componentNames.get(name) ?? `${name.charAt(0).toUpperCase() + name.slice(1)}Icon`;
-
-    entries.push({
-      name,
-      componentName,
-      label,
-      categories,
-      keywords
-    });
-  }
-
-  return entries;
-}
-
+/**
+ * Load the bundled icon metadata (`icons.json`, emitted by docs-gen from the blocks
+ * icon registry). Read-tolerant: an absent bundle yields an empty set so `find_icons`
+ * degrades gracefully instead of crashing the server.
+ */
 export async function loadIcons(): Promise<IconEntry[]> {
   if (cachedIcons) return cachedIcons;
 
   try {
-    const content = await readFile(getIconRegistryPath(), 'utf-8');
-    cachedIcons = parseIconMetadata(content);
+    const raw = await readFile(getIconsPath(), 'utf-8');
+    cachedIcons = JSON.parse(raw) as IconEntry[];
   } catch {
     cachedIcons = [];
   }

package/src/data/template-loader.ts

@@ -1,5 +1,5 @@
 import { readFile } from 'node:fs/promises';
-import { getTemplatePath } from '../utils/paths.js';
+import { getTemplatePath } from '@urbicon-ui/design-content';
 
 export interface TemplateSections {
   'api-grammar': string;

package/src/data/verb-loader.ts

@@ -0,0 +1,29 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { getVerbsDir } from '@urbicon-ui/design-content';
+
+/**
+ * Loads design-verb recipes from the version-pinned content bundle
+ * (`@urbicon-ui/design-content/content/verbs/`). The recipes are the single source
+ * the local skill ships and these remote prompts serve — same text, two channels
+ * (DESIGN-MCP-V2 §8). Cached per process; read tolerant (a missing file yields the
+ * empty string, so one absent recipe never breaks server construction — the prompt
+ * wrapper degrades to a rebuild hint instead).
+ */
+
+const cache = new Map<string, string>();
+
+/** Load one verb recipe body by name (e.g. `compose`), trimmed. `''` when absent. */
+export async function loadVerb(name: string): Promise<string> {
+  const cached = cache.get(name);
+  if (cached !== undefined) return cached;
+
+  let body = '';
+  try {
+    body = (await readFile(resolve(getVerbsDir(), `${name}.md`), 'utf-8')).trim();
+  } catch {
+    body = '';
+  }
+  cache.set(name, body);
+  return body;
+}

package/src/eval/eval.test.ts

@@ -1,5 +1,5 @@
+import { RUBRIC_CRITERIA } from '@urbicon-ui/design-engine/rubric';
 import { describe, expect, it } from 'vitest';
-import { RUBRIC_CRITERIA } from '../design-rubric/rubric.js';
 import { EVAL_BRIEFS, getBriefById } from './briefs.js';
 import type { EvalEntry } from './score.js';
 import { aggregateRubric, formatAbReport, scoreImplementation } from './score.js';
@@ -28,14 +28,15 @@ describe('eval briefs', () => {
 });
 
 describe('scoreImplementation', () => {
-  it('scores clean code 100 with no findings', () => {
+  it('scores clean code 100/100 with no findings', () => {
     const s = scoreImplementation('<div class="bg-surface-base text-text-primary">ok</div>');
-    expect(s.score).toBe(100);
+    expect(s.correctness).toBe(100);
+    expect(s.slop).toBe(100);
     expect(s.errors).toBe(0);
   });
-  it('penalises hallucinated tokens and raw colours', () => {
+  it('penalises hallucinated tokens and raw colours on the correctness axis', () => {
     const s = scoreImplementation('<div class="bg-blue-500 text-status-bad">x</div>');
-    expect(s.score).toBeLessThan(100);
+    expect(s.correctness).toBeLessThan(100);
     expect(s.errors + s.warnings).toBeGreaterThan(0);
   });
 });
@@ -61,12 +62,12 @@ describe('formatAbReport edge cases', () => {
       {
         briefId: 'x',
         condition: 'baseline',
-        score: { linter: { score: 100, errors: 0, warnings: 0, infos: 0 } }
+        score: { linter: { correctness: 100, slop: 100, errors: 0, warnings: 0, infos: 0 } }
       },
       {
         briefId: 'x',
         condition: 'design-mcp',
-        score: { linter: { score: 100, errors: 0, warnings: 0, infos: 0 } }
+        score: { linter: { correctness: 100, slop: 100, errors: 0, warnings: 0, infos: 0 } }
       }
     ];
     const report = formatAbReport(entries, 'baseline', 'design-mcp');
@@ -79,12 +80,18 @@ describe('formatAbReport', () => {
     {
       briefId: 'a',
       condition: 'baseline',
-      score: { linter: { score: 70, errors: 1, warnings: 2, infos: 0 }, rubricTotal: 22 }
+      score: {
+        linter: { correctness: 70, slop: 80, errors: 1, warnings: 2, infos: 0 },
+        rubricTotal: 22
+      }
     },
     {
       briefId: 'a',
       condition: 'design-mcp',
-      score: { linter: { score: 95, errors: 0, warnings: 0, infos: 1 }, rubricTotal: 31 }
+      score: {
+        linter: { correctness: 95, slop: 90, errors: 0, warnings: 0, infos: 1 },
+        rubricTotal: 31
+      }
     }
   ];
   const report = formatAbReport(entries, 'baseline', 'design-mcp');