@urbicon-ui/mcp-server 6.1.5 → 6.1.6

package/src/eval/score.ts

@@ -7,12 +7,18 @@
  * tables, so a new run is directly comparable to that +33.8% baseline.
  */
 
-import { lintDesign } from '../design-linter/index.js';
-import { MAX_RUBRIC_SCORE, RUBRIC_CRITERIA } from '../design-rubric/rubric.js';
+import { lintDesign } from '@urbicon-ui/design-engine/linter';
+import { MAX_RUBRIC_SCORE, RUBRIC_CRITERIA } from '@urbicon-ui/design-engine/rubric';
 
 export interface LinterScore {
-  /** 0–100 deterministic design-linter score. */
-  score: number;
+  /**
+   * Stage-1 correctness axis, 0–100 (deterministic defects only). The stable A/B
+   * headline metric: unaffected by the slop-floor heuristics, so it stays directly
+   * comparable to the pre-slop-floor baseline (the +33.8% measurement).
+   */
+  correctness: number;
+  /** Stage-2 slop-floor axis, 0–100 (system-agnostic "looks generic" heuristics). */
+  slop: number;
   errors: number;
   warnings: number;
   infos: number;
@@ -35,7 +41,8 @@ export interface EvalEntry {
 export function scoreImplementation(code: string): LinterScore {
   const r = lintDesign(code);
   return {
-    score: r.score,
+    correctness: r.scores.correctness,
+    slop: r.scores.slop,
     errors: r.counts.error,
     warnings: r.counts.warning,
     infos: r.counts.info
@@ -76,29 +83,38 @@ export function formatAbReport(entries: EvalEntry[], baseline: string, treatment
 
   let md = `# Eval A/B — ${baseline} vs ${treatment}\n\n`;
   md += '## Per-brief\n\n';
-  md += `| Brief | ${baseline} linter | ${treatment} linter | ${baseline} rubric | ${treatment} rubric |\n`;
+  md += `| Brief | ${baseline} correctness | ${treatment} correctness | ${baseline} rubric | ${treatment} rubric |\n`;
   md += '|---|---|---|---|---|\n';
 
   const baseLint: number[] = [];
   const treatLint: number[] = [];
+  const baseSlop: number[] = [];
+  const treatSlop: number[] = [];
   const baseRub: number[] = [];
   const treatRub: number[] = [];
 
   for (const id of briefIds) {
     const b = pick(id, baseline);
     const t = pick(id, treatment);
-    if (b) baseLint.push(b.linter.score);
-    if (t) treatLint.push(t.linter.score);
+    if (b) {
+      baseLint.push(b.linter.correctness);
+      baseSlop.push(b.linter.slop);
+    }
+    if (t) {
+      treatLint.push(t.linter.correctness);
+      treatSlop.push(t.linter.slop);
+    }
     if (b?.rubricTotal !== undefined) baseRub.push(b.rubricTotal);
     if (t?.rubricTotal !== undefined) treatRub.push(t.rubricTotal);
     const rub = (s?: ImplementationScore) =>
       s?.rubricTotal !== undefined ? `${s.rubricTotal}/${MAX_RUBRIC_SCORE}` : '—';
-    md += `| ${id} | ${b?.linter.score ?? '—'} | ${t?.linter.score ?? '—'} | ${rub(b)} | ${rub(t)} |\n`;
+    md += `| ${id} | ${b?.linter.correctness ?? '—'} | ${t?.linter.correctness ?? '—'} | ${rub(b)} | ${rub(t)} |\n`;
   }
 
   md += '\n## Aggregate\n\n';
   md += `| Metric | ${baseline} | ${treatment} | Δ |\n|---|---|---|---|\n`;
-  md += `| Mean linter score | ${mean(baseLint).toFixed(1)} | ${mean(treatLint).toFixed(1)} | ${pct(mean(baseLint), mean(treatLint))} |\n`;
+  md += `| Mean correctness | ${mean(baseLint).toFixed(1)} | ${mean(treatLint).toFixed(1)} | ${pct(mean(baseLint), mean(treatLint))} |\n`;
+  md += `| Mean slop-floor | ${mean(baseSlop).toFixed(1)} | ${mean(treatSlop).toFixed(1)} | ${pct(mean(baseSlop), mean(treatSlop))} |\n`;
   if (baseRub.length && treatRub.length) {
     md += `| Mean rubric /${MAX_RUBRIC_SCORE} | ${mean(baseRub).toFixed(1)} | ${mean(treatRub).toFixed(1)} | ${pct(mean(baseRub), mean(treatRub))} |\n`;
   }

package/src/index.ts

@@ -2,7 +2,6 @@
 
 import { loadCatalog } from './data/catalog-loader.js';
 import { loadPatterns, loadPrinciples } from './data/design-system-loader.js';
-import { loadRecipes } from './data/recipe-loader.js';
 import { loadTemplateSections } from './data/template-loader.js';
 import { createServer } from './server.js';
 import { startHttpTransport } from './transports/http.js';
@@ -11,7 +10,7 @@ import { startStdioTransport } from './transports/stdio.js';
 interface CliArgs {
   transport: 'stdio' | 'http';
   port: number;
-  dataDir?: string;
+  contentDir?: string;
 }
 
 function parseArgs(args: string[]): CliArgs {
@@ -32,8 +31,8 @@ function parseArgs(args: string[]): CliArgs {
     } else if (arg === '--port' && next) {
       result.port = parseInt(next, 10);
       i++;
-    } else if (arg === '--data-dir' && next) {
-      result.dataDir = next;
+    } else if (arg === '--content-dir' && next) {
+      result.contentDir = next;
       i++;
     }
   }
@@ -44,19 +43,13 @@ function parseArgs(args: string[]): CliArgs {
 async function main(): Promise<void> {
   const args = parseArgs(process.argv.slice(2));
 
-  if (args.dataDir) {
-    process.env.DATA_DIR = args.dataDir;
+  if (args.contentDir) {
+    process.env.URBICON_CONTENT_DIR = args.contentDir;
   }
 
-  // Pre-load cached data
+  // Pre-load cached data (recipes travel inside the catalog).
   try {
-    await Promise.all([
-      loadCatalog(),
-      loadTemplateSections(),
-      loadRecipes(),
-      loadPrinciples(),
-      loadPatterns()
-    ]);
+    await Promise.all([loadCatalog(), loadTemplateSections(), loadPrinciples(), loadPatterns()]);
   } catch (err) {
     console.error('Warning: Failed to pre-load some data:', err);
   }

package/src/prompts/design-prompts.test.ts

@@ -1,5 +1,20 @@
 import { describe, expect, it } from 'vitest';
-import { designPagePrompt, redesignPrompt, variantCount } from './design-prompts.js';
+import { loadVerb } from '../data/verb-loader.js';
+import { buildVerbPrompt, variantCount } from './design-prompts.js';
+
+/** The full §8 verb table — every recipe must be present in the bundle. */
+const VERB_NAMES = [
+  'onboard',
+  'adopt',
+  'compose',
+  'redesign',
+  'polish',
+  'critique',
+  'fix',
+  'retheme',
+  'audit',
+  'migrate'
+];
 
 describe('variantCount', () => {
   it('defaults to 3 for missing or non-numeric input', () => {
@@ -13,39 +28,52 @@ describe('variantCount', () => {
   });
 });
 
-describe('designPagePrompt', () => {
-  it('embeds the brief and drives the full loop in order', () => {
-    const p = designPagePrompt('a billing settings page', undefined, '4');
-    expect(p).toContain('a billing settings page');
-    for (const tool of [
-      'get_design_context',
-      'get_design_principles',
-      'validate_design',
-      'get_design_principles(as="rubric")',
-      'sync_design_manifest'
-    ]) {
-      expect(p, tool).toContain(tool);
-    }
-    expect(p).toContain('Generate 4 variants');
+describe('buildVerbPrompt', () => {
+  const body = '1. **Context.** Read the manifest.\n2. **Validate.** Run the linter.';
+
+  it('frames the verb and includes the recipe body', () => {
+    const p = buildVerbPrompt('compose', body, {});
+    expect(p).toContain('**compose** design recipe');
+    expect(p).toContain('Read the manifest');
+  });
+
+  it('embeds the brief as a blockquote when provided', () => {
+    expect(buildVerbPrompt('compose', body, { brief: 'a billing page' })).toContain(
+      '> **a billing page**'
+    );
+  });
+
+  it('inlines provided code in a svelte fence', () => {
+    const p = buildVerbPrompt('redesign', body, { code: '<div>old</div>' });
+    expect(p).toContain('```svelte\n<div>old</div>\n```');
   });
 
-  it('pins a specific pattern when given one', () => {
-    expect(designPagePrompt('x', 'dashboard', undefined)).toContain('get_pattern("dashboard")');
+  it('appends a clamped variant instruction when variants are requested', () => {
+    expect(buildVerbPrompt('compose', body, { variants: '9' })).toContain('explore exactly 5');
+    expect(buildVerbPrompt('compose', body, { variants: '1' })).toContain('explore exactly 2');
   });
-  it('offers pattern discovery when none is given', () => {
-    expect(designPagePrompt('x', undefined, undefined)).toContain('if a composition pattern fits');
+
+  it('degrades to a rebuild hint when the body is empty', () => {
+    expect(buildVerbPrompt('compose', '', {})).toContain('rebuild the design-content bundle');
   });
 });
 
-describe('redesignPrompt', () => {
-  it('is diagnosis-first and preserves behaviour', () => {
-    const p = redesignPrompt('the dashboard feels flat', undefined, undefined);
-    expect(p).toContain('Diagnose');
-    expect(p).toContain('validate_design');
-    expect(p).toContain('two lowest-scoring criteria');
-    expect(p).toContain('read the current implementation');
+describe('loadVerb (against the bundled recipes)', () => {
+  it('loads every verb in the §8 table, non-empty', async () => {
+    for (const name of VERB_NAMES) {
+      const body = await loadVerb(name);
+      expect(body.length, name).toBeGreaterThan(0);
+    }
+  });
+
+  it('a recipe opens by reading the manifest and references the real tool surface', async () => {
+    const compose = await loadVerb('compose');
+    expect(compose).toContain('manifest');
+    expect(compose).toContain('validate_design');
+    expect(compose).toContain('get_design_principles(as="rubric")');
   });
-  it('inlines provided code', () => {
-    expect(redesignPrompt('x', '<div>old</div>', undefined)).toContain('<div>old</div>');
+
+  it('returns the empty string for an unknown verb (read tolerant)', async () => {
+    expect(await loadVerb('does-not-exist')).toBe('');
   });
 });

package/src/prompts/design-prompts.ts

@@ -1,16 +1,19 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
+import { loadVerb } from '../data/verb-loader.js';
 
 /**
- * MCP prompts that ship the *process* — the generate → validate → judge →
- * synthesise loop (docs/DESIGN-MCP.md, Option E). MCP prompts are the
- * client-agnostic way to deliver a workflow: any MCP client (Claude Code,
- * Cursor, …) can invoke them, and they orchestrate the server's own tools
- * (get_design_context, get_pattern, validate_design, get_design_principles).
+ * MCP prompts that ship the *process* — the full design-verb table (DESIGN-MCP-V2
+ * §8). MCP prompts are the client-agnostic way to deliver a workflow: any MCP
+ * client (Claude Code, Cursor, …) can invoke them, and they orchestrate the
+ * server's read-only tools (get_pattern, validate_design, get_design_principles).
  *
- * The creative loop itself runs in the consumer's harness (it needs file access
- * and iteration); these prompts encode the steps so a single-shot generation
- * doesn't regress to the mean.
+ * The recipe BODY is the single source authored under `@urbicon-ui/design`'s
+ * `skill/verbs/*.md` and bundled into `@urbicon-ui/design-content` — the same text
+ * the local skill ships, so a verb is maintained once and served two ways (§9).
+ * Here we only wrap that body with the per-invocation header (brief / current code)
+ * and register it. Manifest state lives in the consumer's repo — read/written with
+ * the agent's own file tools or the `urbicon` CLI, never by this stateless server.
  */
 
 /** Clamp the requested variant count to a sane range. Prompt args arrive as strings. */
@@ -20,108 +23,136 @@ export function variantCount(raw: string | undefined): number {
   return Math.min(5, Math.max(2, n));
 }
 
-function patternStep(pattern: string | undefined): string {
-  return pattern
-    ? `call \`get_pattern("${pattern}")\` and follow its layout, component-selection, and behavioural rules`
-    : 'if a composition pattern fits the brief (settings-page, dashboard, form-page, tab-navigation, onboarding-guide), call `get_pattern("<name>")` to load it';
-}
-
-const FOOTER =
-  'Output the final code, then a one-line rationale for each major design choice. Keep the rationale honest — name the trade-offs.';
-
-export function designPagePrompt(
-  brief: string,
-  pattern: string | undefined,
-  variants: string | undefined
-): string {
-  const n = variantCount(variants);
-  return `You are designing a new page for a project built on Urbicon UI:
-
-> **${brief}**
+type VerbArg = 'brief' | 'code' | 'variants';
 
-Run this loop. Do not skip steps — a single-shot answer regresses to a generic template.
-
-1. **Context.** Call \`get_design_context\` and honour the project's paradigm, theme, density, and recorded decisions (ADRs). Then ${patternStep(pattern)}.
-2. **Ground rules.** Call \`get_design_principles\` for the heuristics and \`get_css_reference\` for the exact token names. Note the paradigm's token profile via \`get_design_principles(topic="theming")\`.
-3. **Generate ${n} variants.** Produce ${n} genuinely different implementations, each taking a distinct compositional approach *within* the paradigm — vary density, hierarchy emphasis, and the one signature moment. Do not let them converge. Use only real semantic tokens (no \`bg-status-*\`, no invented names).
-4. **Validate.** Run \`validate_design\` on every variant. Fix each error and warning. A variant that cannot pass is disqualified.
-5. **Judge.** Call \`get_design_principles(as="rubric")\` and score each surviving variant /40. Prefer a panel: judge correctness, hierarchy, paradigm-fidelity, and distinctiveness as separate lenses rather than one overall gut number.
-6. **Synthesise.** Pick the winner, then graft the best ideas from the runners-up. Run \`validate_design\` once more on the merged result — it must come back clean.
-7. **Record.** If the page follows a pattern, add \`data-design-pattern="<name>"\` to its root element and call \`sync_design_manifest\`. If you deviated from a pattern or principle on purpose, call \`record_design_decision\`.
-
-${FOOTER}`;
+interface VerbSpec {
+  name: string;
+  /** The prompt description shown to MCP clients. */
+  summary: string;
+  /** Which optional inputs this verb takes (drives the schema + the header). */
+  args: VerbArg[];
 }
 
-export function redesignPrompt(
-  brief: string,
-  code: string | undefined,
-  variants: string | undefined
-): string {
-  const n = variantCount(variants);
-  const current = code
-    ? `\n\nCurrent implementation:\n\n\`\`\`svelte\n${code}\n\`\`\``
-    : '\n\nFirst read the current implementation of the page in question.';
-  return `You are redesigning an existing page in a project built on Urbicon UI:
-
-> **${brief}**${current}
-
-Run a diagnosis-first loop:
+/**
+ * The full verb table (§8). Names match the `skill/verbs/<name>.md` recipes one to
+ * one; `args` is the precise subset each verb uses (so `onboard` doesn't advertise
+ * a `code` field it ignores). Order = the router's narrow-to-broad reading order.
+ */
+const VERBS: VerbSpec[] = [
+  {
+    name: 'onboard',
+    summary:
+      'Greenfield start: interview the product intent (audience, voice, references) + intake (paradigm/theme/density), then seed design.manifest.md — the anchor every later verb reads.',
+    args: ['brief']
+  },
+  {
+    name: 'adopt',
+    summary:
+      'Brownfield start: infer the design language from existing code (tokens, patterns, intent), measure the drift, and seed design.manifest.md.',
+    args: ['brief']
+  },
+  {
+    name: 'compose',
+    summary:
+      'Design a new page/component with the full generate → validate → judge → synthesise loop (variant exploration + rubric + linter gate). Keeps generation off the generic mean.',
+    args: ['brief', 'variants']
+  },
+  {
+    name: 'redesign',
+    summary:
+      'Redesign an existing page: diagnose with the linter + rubric, then fix exactly the flagged weaknesses through variant exploration. Preserves behaviour and structure.',
+    args: ['brief', 'code', 'variants']
+  },
+  {
+    name: 'polish',
+    summary:
+      'Tighten a near-final page: small token-level fixes that raise the slop-floor score without restructuring.',
+    args: ['brief', 'code']
+  },
+  {
+    name: 'critique',
+    summary:
+      'Judge a page without changing it: correctness + slop-floor + rubric → a prioritised fix-list, each item tagged with the verb that repairs it.',
+    args: ['brief', 'code']
+  },
+  {
+    name: 'fix',
+    summary:
+      'Repair correctness defects (raw colours, dark:/focus:, hardcoded z-index, hallucinated tokens) — mechanical, behaviour-preserving.',
+    args: ['brief', 'code']
+  },
+  {
+    name: 'retheme',
+    summary:
+      'Rebrand the system: change the token layer once and propagate across every affected file via the manifest usage-index. Gated per file.',
+    args: ['brief']
+  },
+  {
+    name: 'audit',
+    summary:
+      'App-wide consistency sweep: validate the tree, check each pattern cohort, score a sample, and report drift over time. Recommends repairs, performs none.',
+    args: ['brief']
+  },
+  {
+    name: 'migrate',
+    summary:
+      'Roll out a pattern or library change across every site, file by file, gated per file.',
+    args: ['brief']
+  }
+];
+
+const ARG_DESCRIPTIONS: Record<VerbArg, string> = {
+  brief:
+    'What to act on — the brief, the page, or the target. Optional; the agent uses the conversation context when omitted.',
+  code: 'The current page source. Optional — omit to have the agent read it first.',
+  variants: 'How many variants to explore (2–5, default 3).'
+};
+
+/** Per-invocation inputs (all optional); the recipe body carries the channel-agnostic steps. */
+interface VerbArgs {
+  brief?: string;
+  code?: string;
+  variants?: string;
+}
 
-1. **Context.** Call \`get_design_context\` to recover the project's paradigm, theme, and prior decisions.
-2. **Diagnose.** Run \`validate_design\` on the current code, then call \`get_design_principles(as="rubric")\` and score the current page /40. Your revision targets are **every linter finding** plus the **two lowest-scoring criteria** — nothing else.
-3. **Generate ${n} variants** that fix exactly those weaknesses. Preserve the page's behaviour, data flow, and overall structure; change only what the diagnosis flagged. Use only real tokens.
-4. **Validate.** Run \`validate_design\` on each; fix every error and warning.
-5. **Judge.** Re-score each variant with the rubric. A redesign that does not beat the original on its target criteria is not shippable.
-6. **Synthesise.** Merge the best result, then run \`validate_design\` once more.
-7. **Record.** Call \`record_design_decision\` for any deliberate deviation; \`sync_design_manifest\` if pattern usage changed.
+/** Wrap a recipe body with the per-invocation header (verb framing, brief, current code, variant count). */
+export function buildVerbPrompt(name: string, body: string, args: VerbArgs): string {
+  const parts = [
+    `You are running the **${name}** design recipe for a project built on Urbicon UI. Follow it; do not skip steps — a single-shot answer regresses to a generic template.`
+  ];
+  if (args.brief) parts.push(`\n> **${args.brief}**`);
+  if (args.code) parts.push(`\nCurrent implementation:\n\n\`\`\`svelte\n${args.code}\n\`\`\``);
+  parts.push('\n---\n');
+  parts.push(
+    body ||
+      '_Recipe text unavailable — rebuild the design-content bundle with `bun run docs:gen:all`._'
+  );
+  if (args.variants) {
+    parts.push(
+      `\n\nWhere the recipe says "a few variants", explore exactly ${variantCount(args.variants)}.`
+    );
+  }
+  return parts.join('\n');
+}
 
-End with a before/after table of the targeted criteria (old score → new score) and ${FOOTER.toLowerCase()}`;
+function schemaFor(args: VerbArg[]): Record<string, z.ZodString | z.ZodOptional<z.ZodString>> {
+  const shape: Record<string, z.ZodOptional<z.ZodString>> = {};
+  for (const arg of args) shape[arg] = z.string().optional().describe(ARG_DESCRIPTIONS[arg]);
+  return shape;
 }
 
 export function registerDesignPrompts(server: McpServer): void {
-  server.prompt(
-    'design-page',
-    'Design a new page with the full generate → validate → judge → synthesise loop (variant exploration + rubric selection + linter gate). Keeps generation from regressing to a generic template.',
-    {
-      brief: z.string().describe('What to build, e.g. "a billing settings page for a SaaS admin".'),
-      pattern: z
-        .string()
-        .optional()
-        .describe(
-          'Composition pattern to follow (settings-page, dashboard, form-page, …). Optional.'
-        ),
-      variants: z.string().optional().describe('How many variants to explore (2–5, default 3).')
-    },
-    ({ brief, pattern, variants }) => ({
-      messages: [
-        {
-          role: 'user' as const,
-          content: { type: 'text' as const, text: designPagePrompt(brief, pattern, variants) }
-        }
-      ]
-    })
-  );
-
-  server.prompt(
-    'redesign',
-    'Redesign an existing page: diagnose with validate_design + the rubric, then fix exactly the flagged weaknesses through variant exploration. Preserves behaviour and structure.',
-    {
-      brief: z
-        .string()
-        .describe('What to redesign and why, e.g. "the dashboard feels flat and generic".'),
-      code: z
-        .string()
-        .optional()
-        .describe('The current page source. Optional — omit to have the model read it first.'),
-      variants: z.string().optional().describe('How many variants to explore (2–5, default 3).')
-    },
-    ({ brief, code, variants }) => ({
-      messages: [
-        {
-          role: 'user' as const,
-          content: { type: 'text' as const, text: redesignPrompt(brief, code, variants) }
-        }
-      ]
-    })
-  );
+  for (const verb of VERBS) {
+    server.prompt(verb.name, verb.summary, schemaFor(verb.args), async (args: VerbArgs) => {
+      const body = await loadVerb(verb.name);
+      return {
+        messages: [
+          {
+            role: 'user' as const,
+            content: { type: 'text' as const, text: buildVerbPrompt(verb.name, body, args) }
+          }
+        ]
+      };
+    });
+  }
 }

package/src/server.test.ts

@@ -25,10 +25,7 @@ const EXPECTED_TOOLS = [
   'find_icons',
   'get_design_principles',
   'get_pattern',
-  'validate_design',
-  'get_design_context',
-  'record_design_decision',
-  'sync_design_manifest'
+  'validate_design'
 ] as const;
 
 describe('createServer', () => {
@@ -60,10 +57,22 @@ describe('createServer', () => {
     expect(resourceCount).toBeGreaterThan(0);
   });
 
-  it('registers the design-process prompts', () => {
+  it('registers the full design-verb table as prompts', () => {
     const server = createServer() as unknown as McpServerInternals;
     const promptNames = Object.keys(server._registeredPrompts);
-    expect(promptNames).toContain('design-page');
-    expect(promptNames).toContain('redesign');
+    for (const verb of [
+      'onboard',
+      'adopt',
+      'compose',
+      'redesign',
+      'polish',
+      'critique',
+      'fix',
+      'retheme',
+      'audit',
+      'migrate'
+    ]) {
+      expect(promptNames, verb).toContain(verb);
+    }
   });
 });

package/src/server.ts

@@ -7,13 +7,10 @@ import { registerFindIconsTool } from './tools/find-icons.js';
 import { registerGetChecklistTool } from './tools/get-checklist.js';
 import { registerGetComponentTool } from './tools/get-component.js';
 import { registerGetCssReferenceTool } from './tools/get-css-reference.js';
-import { registerGetDesignContextTool } from './tools/get-design-context.js';
 import { registerGetDesignPrinciplesTool } from './tools/get-design-principles.js';
 import { registerGetPatternTool } from './tools/get-pattern.js';
 import { registerGetRecipeTool } from './tools/get-recipe.js';
-import { registerRecordDesignDecisionTool } from './tools/record-design-decision.js';
 import { registerSuggestImplementationTool } from './tools/suggest-implementation.js';
-import { registerSyncDesignManifestTool } from './tools/sync-design-manifest.js';
 import { registerValidateDesignTool } from './tools/validate-design.js';
 
 export function createServer(): McpServer {
@@ -26,7 +23,10 @@ export function createServer(): McpServer {
   registerCatalogResource(server);
   registerGuideResources(server);
 
-  // Tools
+  // Tools — all read-only. Manifest read/write (context · record-decision ·
+  // sync-manifest) lives in the consumer's repo via the `urbicon` CLI or the
+  // agent's own file tools, not on this stateless remote server.
+  // See docs/internal/DESIGN-MCP-V2.md.
   registerFindComponentsTool(server);
   registerGetComponentTool(server);
   registerGetRecipeTool(server);
@@ -37,9 +37,6 @@ export function createServer(): McpServer {
   registerGetDesignPrinciplesTool(server);
   registerGetPatternTool(server);
   registerValidateDesignTool(server);
-  registerGetDesignContextTool(server);
-  registerRecordDesignDecisionTool(server);
-  registerSyncDesignManifestTool(server);
 
   // Prompts — the deliverable design process (Option E)
   registerDesignPrompts(server);

package/src/tools/find-components.ts

@@ -1,8 +1,8 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { matchComponents } from '@urbicon-ui/design-engine/search';
 import { z } from 'zod';
 import { loadCatalog } from '../data/catalog-loader.js';
 import { formatCompactCatalog } from '../utils/format-catalog.js';
-import { matchComponents } from '../utils/search.js';
 
 export function registerFindComponentsTool(server: McpServer): void {
   server.tool(

package/src/tools/get-design-principles.ts

@@ -1,11 +1,11 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { renderRubric } from '@urbicon-ui/design-engine/rubric';
 import { z } from 'zod';
 import {
   extractPrincipleSection,
   loadPrinciples,
   PRINCIPLE_TOPICS
 } from '../data/design-system-loader.js';
-import { renderRubric } from '../design-rubric/rubric.js';
 
 export function registerGetDesignPrinciplesTool(server: McpServer): void {
   server.tool(

package/src/tools/get-recipe.ts

@@ -1,6 +1,6 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
-import { getRecipeById, loadRecipes } from '../data/recipe-loader.js';
+import { loadCatalog } from '../data/catalog-loader.js';
 
 export function registerGetRecipeTool(server: McpServer): void {
   server.tool(
@@ -15,11 +15,13 @@ export function registerGetRecipeTool(server: McpServer): void {
     },
     { readOnlyHint: true },
     async ({ scenario }) => {
-      const recipe = await getRecipeById(scenario);
+      // Recipes (with code + pattern) travel in the catalog — single source of truth,
+      // no separate read of the recipe source tree.
+      const catalog = await loadCatalog();
+      const recipe = catalog.recipes.find((r) => r.id === scenario);
 
       if (!recipe) {
-        const allRecipes = await loadRecipes();
-        const available = allRecipes.map((r) => r.id).join(', ');
+        const available = catalog.recipes.map((r) => r.id).join(', ');
         return {
           content: [
             {

package/src/tools/suggest-implementation.ts

@@ -1,9 +1,8 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { matchComponents } from '@urbicon-ui/design-engine/search';
 import { z } from 'zod';
 import type { ComponentCatalogEntry } from '../data/catalog-loader.js';
 import { loadCatalog } from '../data/catalog-loader.js';
-import { loadRecipes } from '../data/recipe-loader.js';
-import { matchComponents } from '../utils/search.js';
 
 /** Default props and skeleton hints per component type */
 const SKELETON_HINTS: Record<string, { attrs: string; children?: string; selfClosing?: boolean }> =
@@ -104,7 +103,7 @@ export function registerSuggestImplementationTool(server: McpServer): void {
     { readOnlyHint: true, openWorldHint: true },
     async ({ description, components: requestedComponents, style }) => {
       const catalog = await loadCatalog();
-      const recipes = await loadRecipes();
+      const recipes = catalog.recipes;
 
       let matched: ComponentCatalogEntry[];