@adia-ai/a2ui-mcp 0.4.5 → 0.4.7

package/CHANGELOG.md

@@ -11,6 +11,24 @@ zettel strategies.
 
 _No pending changes._
 
+## [0.4.7] - 2026-05-12
+
+### Changed — smoke + test scripts aligned to post-§72 retrieval surface
+
+`scripts/smoke-engine-registry.mjs` retrieval probe set + `scripts/test-a2ui.mjs` (composition-count threshold + spot-checks + intent-gate keyword surface) now exercise the harvested-chunks substrate that survives §72's `corpus/patterns/` + `corpus/compositions/` retirement. Probe for "pricing tiers" dropped (no pricing surface in shipped `/site/`); replaced with "admin dashboard with kpi cards" matching `dashboard-admin-page`. Spot-check names updated to real chunk names (`auth-signin-card-password`, `auth-signup-entry`, `dashboard-admin-page`, `settings-admin-page`). No tool / API change — internal scripts only.
+
+## [0.4.6] - 2026-05-12
+
+### Changed — patterns surface retired (§64 step 5, 2026-05-12)
+
+Companion to `@adia-ai/a2ui-compose@[Unreleased]` + `@adia-ai/a2ui-retrieval@[Unreleased]` retiring the legacy `pattern-library.js` surface in favor of `composition-library` as the canonical retrieval source.
+
+- **`mcp/server.js`** — removed pattern-surface MCP tools that read from the retired `pattern-library` (the surface had been gradually deprecated through §62-§64; this commit cuts the last consumer paths). Tool count net change reflected in `mcp/TOOLS.md`.
+- **`mcp/scripts/eval-fix.mjs`** — retired the pattern-surface fix-up logic (no longer reachable; compositions are the canonical retrieval shape).
+- **`mcp/scripts/test-a2ui.mjs`** — assertions updated to reflect the post-§64 tool inventory.
+
+See root [CHANGELOG.md `[Unreleased]`](../../../CHANGELOG.md) for the cross-cutting §64 arc narrative.
+
 ## [0.4.5] - 2026-05-12
 
 ### Ride-along (no source changes)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adia-ai/a2ui-mcp",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "description": "AdiaUI A2UI MCP server. Exposes the compose engine over MCP with an engine selector for monolithic + zettel strategies.",
   "type": "module",
   "bin": {

package/scripts/smoke-engine-registry.mjs

@@ -44,10 +44,15 @@ console.log(`\n[smoke] shape invariants: ${ok ? 'ok' : 'FAIL'}`);
 // component tree's text content must overlap the intent's keywords.
 // This catches retrieval regressions (wrong-domain top hit) that pure
 // shape-validation gates miss.
+// Probes pick intents that match the post-§65 harvested-chunks
+// substrate (auth flows, dashboard variants, settings, errors).
+// Removed: 'pricing tiers' (no pricing surface in shipped /site/ —
+// retrieval honestly returns synthesis-failed; LLM fallback handles
+// the intent at ~9s vs ~25ms).
 const RETRIEVAL_PROBES = [
   { intent: 'login form with email and password',     engine: 'zettel',       expectKeywords: ['sign in', 'login', 'email', 'password'] },
-  { intent: 'pricing tiers with three plans',          engine: 'zettel',       expectKeywords: ['pricing', 'tier', 'plan', 'starter', 'pro', 'enterprise', '$'] },
   { intent: 'sign up form for a new account',          engine: 'zettel',       expectKeywords: ['sign up', 'register', 'create account', 'email'] },
+  { intent: 'admin dashboard with kpi cards',          engine: 'zettel',       expectKeywords: ['dashboard', 'kpi', 'metric', 'revenue', 'users', 'orders', 'conversion'] },
 ];
 
 function extractText(messages) {

package/scripts/test-a2ui.mjs

@@ -72,20 +72,23 @@ try {
   bad('LLM adapter', e.message);
 }
 
-// ── Test 2: Pattern library ─────────────────────────────────────────
+// ── Test 2: Composition library (post-§65 chunks-only substrate) ───
 
-console.log('\n2. Pattern library');
+console.log('\n2. Composition library');
 
 const { searchBlocks, listPatterns, lookupDomain } = await import('../../compose/core/reference.js');
 
-const allPatterns = listPatterns();
-const withTemplates = allPatterns.filter(p => p.template && Array.isArray(p.template));
-const domains = [...new Set(allPatterns.map(p => p.domain).filter(Boolean))];
+const allCompositions = listPatterns();
+const withTemplates = allCompositions.filter(p => p.template && Array.isArray(p.template));
+const domains = [...new Set(allCompositions.map(p => p.domain).filter(Boolean))];
 
-if (allPatterns.length >= 70) {
-  ok('Pattern count', `${allPatterns.length} total (${withTemplates.length} with templates)`);
+// Post-§65: retrieval surface is the harvested-chunks substrate
+// (~28-32 annotated chunks at the time of v0.4.7). Threshold sized
+// for that floor; grows naturally as more source HTML gets annotated.
+if (allCompositions.length >= 20) {
+  ok('Composition count', `${allCompositions.length} total (${withTemplates.length} with templates)`);
 } else {
-  bad('Pattern count', `only ${allPatterns.length} (expected 70+)`);
+  bad('Composition count', `only ${allCompositions.length} (expected 20+)`);
 }
 
 if (domains.length >= 3) {
@@ -94,14 +97,17 @@ if (domains.length >= 3) {
   bad('Domains', `only ${domains.length}: ${domains.join(', ')}`);
 }
 
-// Spot-check known patterns
-const spotChecks = ['login-form', 'dashboard', 'data-table-view', 'user-profile'];
-const foundAll = spotChecks.every(name => allPatterns.some(p => p.name === name));
+// Spot-check chunk names that exist in the harvested substrate. These
+// are real chunk names from /apps/user-flow/, /apps/saas/, etc. —
+// post-§65 the test asserts on actual product surfaces, not on
+// curated composition JSON that's no longer the canonical source.
+const spotChecks = ['auth-signin-card-password', 'auth-signup-entry', 'dashboard-admin-page', 'settings-admin-page'];
+const foundAll = spotChecks.every(name => allCompositions.some(p => p.name === name));
 if (foundAll) {
-  ok('Known patterns', spotChecks.join(', '));
+  ok('Known chunks', spotChecks.join(', '));
 } else {
-  const missing = spotChecks.filter(name => !allPatterns.some(p => p.name === name));
-  bad('Known patterns', `missing: ${missing.join(', ')}`);
+  const missing = spotChecks.filter(name => !allCompositions.some(p => p.name === name));
+  bad('Known chunks', `missing: ${missing.join(', ')}`);
 }
 
 // ── Test 3: Instant mode gate ───────────────────────────────────────
@@ -118,14 +124,20 @@ function testGate(intent) {
   const intentWords = intent.toLowerCase().split(/\s+/).filter(w => w.length > 2 && !GATE_STOPS.has(w));
   const nameWords = best.name.toLowerCase().split(/[-_\s]+/);
   const matchTags = (best.tags || []).map(t => t.toLowerCase());
+  // Post-§65: harvested chunks carry semantic intent in `keywords` more
+  // than in `tags` (which became {complexity, layout} slots). Include
+  // keywords in the gate so `login → auth-signin-card-password` strong-hits
+  // off the chunk's `keywords: ["login", ...]` field.
+  const matchKeywords = (best.keywords || []).map(k => k.toLowerCase());
   const matchDomain = (best.domain || '').toLowerCase();
 
   const hasStrongHit = intentWords.some(w => {
     if (w.length < 3) return false;
-    if (nameWords.includes(w) || matchTags.includes(w)) return true;
+    if (nameWords.includes(w) || matchTags.includes(w) || matchKeywords.includes(w)) return true;
     if (w.length >= 4) {
       return nameWords.some(n => n.length >= 3 && (w.startsWith(n) || n.startsWith(w))) ||
-             matchTags.some(t => t.length >= 3 && (w.startsWith(t) || t.startsWith(w)));
+             matchTags.some(t => t.length >= 3 && (w.startsWith(t) || t.startsWith(w))) ||
+             matchKeywords.some(k => k.length >= 3 && (w.startsWith(k) || k.startsWith(w)));
     }
     return false;
   });
@@ -133,19 +145,26 @@ function testGate(intent) {
   const hasWeakHit = !hasStrongHit && intentWords.some(w => {
     return nameWords.some(n => n.length >= 3 && (n.includes(w) || w.includes(n))) ||
            matchTags.some(t => t.length >= 3 && (t.includes(w) || w.includes(t))) ||
+           matchKeywords.some(k => k.length >= 3 && (k.includes(w) || w.includes(k))) ||
            matchDomain.includes(w);
   });
 
   return { gate: hasStrongHit ? 'STRONG' : hasWeakHit ? 'WEAK' : 'REJECTED', pattern: best.name };
 }
 
-// Should STRONG match
+// Should STRONG match — restricted to intents covered by the
+// harvested-chunks substrate (auth, dashboard, settings, error pages).
+// Intents previously tested ("pricing table", "chat interface",
+// "todo list", etc.) dropped because §65 retired the curated
+// composition surface — LLM fallback handles those now.
+// Intents need ≥2 content-token hits OR a direct name-token match —
+// short 1-content-word intents (e.g. just "login form") get gated out
+// by composition-library's anti-spurious-match logic. Use intents that
+// land naturally — they're what real users type anyway.
 const strongTests = [
-  ['login form', 'login-form'],
-  ['nav bar', null],         // any match is fine
-  ['dashboard stats', null],
-  ['pricing table', null],
-  ['chat interface', null],
+  ['login with email and password', null],   // → auth-signin-card-password (3 keyword hits)
+  ['admin dashboard kpi', null],              // → dashboard-admin-page
+  ['workspace admin settings', null],         // → settings-admin-page
 ];
 for (const [intent, expected] of strongTests) {
   const { gate, pattern } = testGate(intent);
@@ -158,10 +177,9 @@ for (const [intent, expected] of strongTests) {
 
 // Should NOT be REJECTED (STRONG or WEAK both acceptable)
 const passTests = [
-  'show me a table',
-  'create a todo list',
-  'user profile card',
+  'sign up for an account',
   'settings page',
+  '404 not found error',
 ];
 for (const intent of passTests) {
   const { gate, pattern } = testGate(intent);
@@ -237,17 +255,21 @@ if (!THINKING) {
 }
 
 // ── Test 6: Training corpus surfaces ────────────────────────────────
-// (The legacy exemplar extract → ingest path was retired 2026-04-28 in
-// mcp 0.0.5. The chunk corpus is the training surface now.)
+// Post-§65: `compositions/` retired alongside the hand-authored
+// pattern library. The harvested-chunks substrate is the sole
+// retrieval surface; everything else falls through to LLM.
+// (Legacy exemplar extract → ingest path retired 2026-04-28 mcp 0.0.5.)
 
 console.log('\n6. Training corpus surfaces');
 
-// 6a. Hand-authored pattern library — should be ≥ 100 entries.
+// 6a. Composition library (harvested chunks via composition-library).
+// Threshold sized for the post-§65 floor (~28 annotated chunks at
+// v0.4.7); grows as more source HTML gets annotated.
 const patterns = listPatterns();
-if (patterns.length >= 100) {
-  ok('Pattern library', `${patterns.length} hand-authored patterns`);
+if (patterns.length >= 20) {
+  ok('Composition library', `${patterns.length} compositions (harvested-chunks substrate)`);
 } else {
-  bad('Pattern library', `only ${patterns.length} (expected ≥ 100)`);
+  bad('Composition library', `only ${patterns.length} (expected ≥ 20)`);
 }
 
 // 6b. Gen-UI chunk corpus — should be ≥ 500 unique chunks across

package/server.js

@@ -11,7 +11,7 @@
  *   validate_schema   — Validate A2UI messages
  *   lookup_component  — Component API lookup
  *   get_component_map — Full catalog
- *   search_patterns   — Pattern library search
+ *   search_patterns   — Composition library search (kept for back-compat; backed by composition-library since §64)
  *   classify_intent   — Domain classification
  *
  * Usage:
@@ -39,7 +39,6 @@ import {
 } from '../retrieval/catalog.js';
 import { serializeEntry } from '../retrieval/component-entry.js';
 import { classifyIntent, getDomain, getAllDomains } from '../retrieval/domain-router.js';
-import { getPattern, searchPatterns, getAllPatterns } from '../retrieval/pattern-library.js';
 import { getAntiPatterns, checkAllAntiPatterns } from '../retrieval/anti-patterns.js';
 import { assembleContext } from '../retrieval/context-assembler.js';
 
@@ -49,6 +48,7 @@ import {
   getComposition as getZettelComposition,
   getAllCompositions as getAllZettelCompositions,
   getGraph as getZettelGraph,
+  searchAll as searchCompositions,
 } from '../compose/strategies/zettel/composition-library.js';
 import {
   resolveComposition as resolveZettelComposition,
@@ -57,7 +57,7 @@ import {
 // Zettel bootstrap is still needed for get_fragment/resolve_composition tools;
 // the generate_ui tool now dispatches through the unified registry in gen-ui.
 
-// Bootstrap zettel corpus alongside the monolithic pattern library
+// Bootstrap zettel composition corpus
 const _zettelBoot = loadZettelCorpus();
 console.error(
   `[adiaui-mcp] zettel corpus: ${_zettelBoot.compositionCount} compositions`,
@@ -71,10 +71,9 @@ import {
   searchChunks as searchGenUIChunks,
 } from '../corpus/scripts/chunk-library.js';
 
-// ── Inline-tool deps (transpiler / wiring / patterns / feedback) ──
+// ── Inline-tool deps (transpiler / wiring / feedback) ──
 import { transpileHTML } from '../compose/transpiler/transpiler.js';
 import { getWiringCatalog } from '../retrieval/wiring-catalog.js';
-import { registerPattern } from '../retrieval/pattern-library.js';
 import { FeedbackCollector } from '../retrieval/feedback/feedback.js';
 import { feedbackStore } from '../retrieval/feedback/feedback-store.js';
 
@@ -203,31 +202,16 @@ server.tool(
 
 server.tool(
   'search_patterns',
-  `Search the pattern library for reusable UI templates. Returns matching patterns with full A2UI component trees that can be used directly or adapted.
+  `Search the composition library for reusable UI templates. Returns matching compositions with full A2UI component trees that can be used directly or adapted.
 
-Use this to find a starting point before generating from scratch. If a good pattern exists, pass it to generate_ui with instant mode. If no pattern matches, use generate_ui with thinking mode.
+Use this to find a starting point before generating from scratch. If a good composition exists, pass it to generate_ui with instant mode. If no composition matches, use generate_ui with thinking mode.
 
-Keyword search by default. Set semantic=true for LLM-powered conceptual matching. Set remix=true to compose a new pattern by combining existing ones.`,
+Keyword search (§64 v0.4.6 migration: now backed by composition-library; the historical "pattern" library is retired).`,
   {
     query: z.string().describe('Search query (natural language)'),
-    semantic: z.boolean().optional().describe('Use LLM for conceptual matching (default: false)'),
-    remix: z.boolean().optional().describe('Compose a new pattern by remixing existing ones (default: false)'),
   },
-  async ({ query, semantic, remix }) => {
-    if (semantic || remix) {
-      const { semanticSearchPatterns } = await import('../a2ui/intelligence/pattern-library.js');
-      const { createAdapter } = await import('../a2ui/llm-bridge.js');
-      try {
-        const adapter = await createAdapter();
-        const results = await semanticSearchPatterns(query, { llmAdapter: adapter, remix });
-        return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
-      } catch (err) {
-        // Fall back to keyword search on LLM failure
-        const results = searchPatterns(query);
-        return { content: [{ type: 'text', text: JSON.stringify({ matches: results, note: 'Semantic search unavailable, using keyword fallback' }, null, 2) }] };
-      }
-    }
-    const results = searchPatterns(query);
+  async ({ query }) => {
+    const results = searchCompositions(query);
     return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
   }
 );
@@ -313,33 +297,10 @@ server.tool(
   }
 );
 
-// ── Pattern & Feedback Tools ──
+// ── Feedback Tools ──
 
 const feedbackCollector = new FeedbackCollector();
 
-server.tool(
-  'import_pattern',
-  'Import a saved pattern JSON into the runtime pattern library.',
-  {
-    pattern: z.string().describe('JSON string of pattern object { name, description, domain, components, template }'),
-  },
-  async ({ pattern }) => {
-    try {
-      const parsed = JSON.parse(pattern);
-      if (!parsed.name || !parsed.template || !Array.isArray(parsed.template)) {
-        return { content: [{ type: 'text', text: 'Invalid: must have name and template array' }], isError: true };
-      }
-      const success = registerPattern(parsed);
-      if (!success) {
-        return { content: [{ type: 'text', text: `Pattern "${parsed.name}" already exists` }], isError: true };
-      }
-      return { content: [{ type: 'text', text: JSON.stringify({ imported: parsed.name, components: parsed.components?.length || 0 }) }] };
-    } catch (err) {
-      return { content: [{ type: 'text', text: `Parse error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
 server.tool(
   'submit_feedback',
   'Submit structured feedback for a generation execution. Used by the evolution engine to learn from each generation.',
@@ -447,13 +408,13 @@ server.resource(
 );
 
 server.resource(
-  'patterns',
-  'a2ui://catalog/patterns',
+  'compositions',
+  'a2ui://catalog/compositions',
   async (uri) => ({
     contents: [{
       uri: uri.href,
       mimeType: 'application/json',
-      text: JSON.stringify(getAllPatterns(), null, 2),
+      text: JSON.stringify(getAllZettelCompositions(), null, 2),
     }],
   })
 );
@@ -663,9 +624,8 @@ async function main() {
 
   await server.connect(transport);
   const catalog = await getCatalog();
-  const patterns = getAllPatterns();
   const traits = getTraits();
-  console.error(`AdiaUI MCP Server running (${catalog.totalTypes} components, ${patterns.length} patterns, ${traits.length} traits, ${_zettelBoot.compositionCount} compositions)`);
+  console.error(`AdiaUI MCP Server running (${catalog.totalTypes} components, ${traits.length} traits, ${_zettelBoot.compositionCount} compositions)`);
 }
 
 main().catch(console.error);

package/scripts/eval-fix.mjs

@@ -1,446 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * eval-fix.mjs — Recursive improvement loop for A2UI generation quality.
- *
- * Runs evals, diagnoses failures, traces root causes upstream, and applies fixes.
- *
- * The loop:
- *   1. Run eval suite → collect scores + failures
- *   2. For each failure, diagnose: pattern issue? template issue? training gap? validator bug?
- *   3. Generate a fix plan (which file, what change)
- *   4. Apply fixes (patch pattern JSON, update training manifest, etc.)
- *   5. Re-run evals to verify the fix worked
- *   6. Repeat until all pass or max iterations reached
- *
- * Diagnosis categories (in priority order):
- *   ANTI_PATTERN → pattern template has bare Text (no variant), unslotted header children,
- *                  or buttons without text. Fix: patch the pattern JSON.
- *   INTENT_MISS  → generated output missing required components. Fix: check if the
- *                  matched pattern has those components; if not, update the pattern or
- *                  add the component to the template.
- *   CARD_MODEL   → Card children don't follow Header/Section/Footer structure.
- *                  Fix: restructure the pattern template.
- *   STRUCTURAL   → validation score below threshold. Fix: usually a template syntax
- *                  issue (missing root, dangling children, duplicate IDs).
- *   COVERAGE     → uses forbidden component types. Fix: swap components in template.
- *
- * Usage:
- *   node packages/a2ui/mcp/scripts/eval-fix.mjs              # diagnose + report (dry run)
- *   node packages/a2ui/mcp/scripts/eval-fix.mjs --apply      # diagnose + apply fixes + re-verify
- *   node packages/a2ui/mcp/scripts/eval-fix.mjs --max-iter=3 # limit fix iterations (default: 3)
- *   node packages/a2ui/mcp/scripts/eval-fix.mjs --verbose    # show detailed diagnosis
- */
-
-import '../../../../scripts/load-env.mjs';
-import { readFile, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const REPO_ROOT = join(__dirname, '..', '..', '..', '..');
-const EVALS_PATH = join(REPO_ROOT, '.claude', 'skills', 'adia-ui-kit', 'evals', 'evals.json');
-const PATTERNS_DIR = join(REPO_ROOT, 'packages', 'web-components', 'catalog', 'patterns');
-
-const args = new Set(process.argv.slice(2));
-const APPLY = args.has('--apply');
-const VERBOSE = args.has('--verbose');
-const TICKETS = args.has('--tickets');
-const MAX_ITER = parseInt([...args].find(a => a.startsWith('--max-iter='))?.split('=')[1] || '3');
-
-// ── Load modules ──
-
-const { generateUI } = await import('../../compose/core/generator.js');
-const { validateSchema } = await import('../../validator/validator.js');
-const { getPattern, searchPatterns } = await import('../../retrieval/pattern-library.js');
-const { createTicket, formatTicket, formatTicketList } = await import('../../../../.tickets/tickets.js');
-
-// ── Scoring (same as test-evals.mjs) ──
-
-function scoreAntiPatterns(components) {
-  const violations = [];
-  for (const c of components) {
-    if (c.component === 'Text' && !c.variant) {
-      violations.push({ id: c.id, issue: 'text-no-variant', message: `Text "${c.id}" has no variant attribute` });
-    }
-    const parent = components.find(p => p.children?.includes(c.id));
-    if (parent?.component === 'Header' && !c.slot && c.component === 'Text') {
-      violations.push({ id: c.id, issue: 'header-child-no-slot', message: `Text "${c.id}" in Header without slot attribute` });
-    }
-    if (c.component === 'Button' && !c.text && !c.icon) {
-      violations.push({ id: c.id, issue: 'button-no-label', message: `Button "${c.id}" has no text or icon` });
-    }
-    // Text used for clickable actions (should be Button)
-    if (c.component === 'Text' && c.textContent) {
-      const actionWords = /\b(view|contact|learn more|retry|download|sign|log ?in|log ?out|submit|cancel|delete|remove|edit|save|close|open|click|tap|go to|visit)\b/i;
-      if (actionWords.test(c.textContent) && !c.slot) {
-        violations.push({ id: c.id, issue: 'text-as-action', message: `Text "${c.id}" looks like an action ("${c.textContent.slice(0, 30)}") — should be a Button` });
-      }
-    }
-  }
-  return violations;
-}
-
-function scoreIntent(components, evalCase) {
-  const required = evalCase.required_components || [];
-  const present = new Set(components.map(c => c.component));
-  const missing = required.filter(r => !present.has(r));
-  return { required, present: [...present], missing };
-}
-
-function scoreCardModel(components) {
-  const issues = [];
-  const cards = components.filter(c => c.component === 'Card');
-  for (const card of cards) {
-    const childIds = card.children || [];
-    const children = childIds.map(id => components.find(c => c.id === id)).filter(Boolean);
-    const types = children.map(c => c.component);
-    if (!types.includes('Header') && !types.includes('Section')) {
-      issues.push({ cardId: card.id, issue: 'no-header-or-section', children: types });
-    }
-  }
-  return issues;
-}
-
-// ── Diagnosis ──
-
-function diagnose(evalCase, result) {
-  const components = result.messages?.[0]?.components || [];
-  // Find matched pattern by running the same search the generator uses
-  const searchResults = searchPatterns(evalCase.prompt);
-  const matched = searchResults[0]?.name || null;
-  const findings = [];
-
-  // 1. Anti-pattern violations
-  const antiViolations = scoreAntiPatterns(components);
-  if (antiViolations.length > 0) {
-    findings.push({
-      category: 'ANTI_PATTERN',
-      severity: 'high',
-      matched_pattern: matched,
-      violations: antiViolations,
-      fix: matched
-        ? `Patch pattern "${matched}": add variant to Text nodes, add slot to Header children`
-        : 'No pattern matched — anti-patterns come from fallback generation',
-    });
-  }
-
-  // 2. Intent alignment
-  const intent = scoreIntent(components, evalCase);
-  if (intent.missing.length > 0) {
-    findings.push({
-      category: 'INTENT_MISS',
-      severity: 'medium',
-      matched_pattern: matched,
-      missing_components: intent.missing,
-      present_components: intent.present,
-      fix: matched
-        ? `Pattern "${matched}" is missing: ${intent.missing.join(', ')}. Add these components to the pattern template.`
-        : `No pattern matched. Consider creating a pattern for intent: "${evalCase.prompt.slice(0, 60)}"`,
-    });
-  }
-
-  // 3. Card model
-  const cardIssues = scoreCardModel(components);
-  if (cardIssues.length > 0) {
-    findings.push({
-      category: 'CARD_MODEL',
-      severity: 'medium',
-      matched_pattern: matched,
-      issues: cardIssues,
-      fix: matched
-        ? `Pattern "${matched}" has Card nodes without Header/Section children`
-        : 'Card model violation in generated output',
-    });
-  }
-
-  // 4. Structural
-  const validation = validateSchema(result.messages);
-  const failedChecks = (validation.checks || []).filter(c => !c.passed);
-  if (failedChecks.length > 0) {
-    findings.push({
-      category: 'STRUCTURAL',
-      severity: failedChecks.some(c => c.hardFail) ? 'critical' : 'low',
-      matched_pattern: matched,
-      failed_checks: failedChecks.map(c => ({ name: c.name, message: c.message })),
-      fix: matched
-        ? `Pattern "${matched}" fails validation: ${failedChecks.map(c => c.name).join(', ')}`
-        : 'Structural issues in generated output',
-    });
-  }
-
-  return { evalId: evalCase.id, prompt: evalCase.prompt, matched_pattern: matched, findings };
-}
-
-// ── Fix application ──
-
-async function applyFix(diagnosis) {
-  const fixes = [];
-
-  for (const finding of diagnosis.findings) {
-    const patternName = finding.matched_pattern;
-    if (!patternName) continue; // Can't fix if no pattern matched
-
-    // Find the pattern JSON file
-    const pattern = getPattern(patternName);
-    if (!pattern) continue;
-
-    const domain = pattern.domain || 'layout';
-    const filePath = join(PATTERNS_DIR, domain, `${patternName}.json`);
-
-    let patternJson;
-    try {
-      patternJson = JSON.parse(await readFile(filePath, 'utf8'));
-    } catch {
-      console.log(`  ⚠ Cannot read ${filePath} — skipping fix`);
-      continue;
-    }
-
-    let modified = false;
-
-    if (finding.category === 'ANTI_PATTERN') {
-      for (const v of finding.violations) {
-        const node = patternJson.template.find(c => c.id === v.id);
-        if (!node) continue;
-
-        if (v.issue === 'text-no-variant' && node.component === 'Text') {
-          node.variant = node.variant || 'body';
-          modified = true;
-          fixes.push(`  + Added variant="body" to ${node.id} in ${patternName}`);
-        }
-        if (v.issue === 'header-child-no-slot' && node.component === 'Text') {
-          // First text child = heading, second = description
-          const headerNode = patternJson.template.find(c => c.children?.includes(node.id) && c.component === 'Header');
-          if (headerNode) {
-            const childTexts = headerNode.children
-              .map(id => patternJson.template.find(c => c.id === id))
-              .filter(c => c?.component === 'Text');
-            const idx = childTexts.indexOf(node);
-            node.slot = idx === 0 ? 'heading' : 'description';
-            modified = true;
-            fixes.push(`  + Added slot="${node.slot}" to ${node.id} in ${patternName}`);
-          }
-        }
-        if (v.issue === 'button-no-label' && node.component === 'Button') {
-          node.text = node.text || 'Action';
-          modified = true;
-          fixes.push(`  + Added text="Action" to ${node.id} in ${patternName}`);
-        }
-      }
-    }
-
-    if (finding.category === 'INTENT_MISS' && finding.missing_components.length > 0) {
-      const template = patternJson.template;
-      const root = template.find(c => c.id === 'root');
-
-      for (const comp of finding.missing_components) {
-        // Auto-fix: add Footer with Button if pattern is missing both
-        if (comp === 'Footer' && finding.missing_components.includes('Button')) {
-          if (root && !template.some(c => c.component === 'Footer')) {
-            const ftrId = 'ftr';
-            const btnId = 'action-btn';
-            template.push({ id: ftrId, component: 'Footer', children: [btnId] });
-            template.push({ id: btnId, component: 'Button', text: 'Save', variant: 'primary', slot: 'action' });
-            if (root.children && !root.children.includes(ftrId)) {
-              root.children.push(ftrId);
-            }
-            // Also add to components list
-            if (!patternJson.components.includes('Footer')) patternJson.components.push('Footer');
-            if (!patternJson.components.includes('Button')) patternJson.components.push('Button');
-            modified = true;
-            fixes.push(`  + Added Footer with Button to ${patternName}`);
-          }
-          continue; // Skip individual Button fix since Footer handled it
-        }
-
-        // Auto-fix: add Button to Footer if Footer exists but Button doesn't
-        if (comp === 'Button' && !finding.missing_components.includes('Footer')) {
-          const footer = template.find(c => c.component === 'Footer');
-          if (footer) {
-            const btnId = 'save-btn';
-            template.push({ id: btnId, component: 'Button', text: 'Save', variant: 'primary', slot: 'action' });
-            if (footer.children) footer.children.push(btnId);
-            else footer.children = [btnId];
-            if (!patternJson.components.includes('Button')) patternJson.components.push('Button');
-            modified = true;
-            fixes.push(`  + Added Button to existing Footer in ${patternName}`);
-          } else {
-            // No footer — add one
-            const ftrId = 'ftr';
-            const btnId = 'save-btn';
-            template.push({ id: ftrId, component: 'Footer', children: [btnId] });
-            template.push({ id: btnId, component: 'Button', text: 'Save', variant: 'primary', slot: 'action' });
-            if (root?.children) root.children.push(ftrId);
-            if (!patternJson.components.includes('Footer')) patternJson.components.push('Footer');
-            if (!patternJson.components.includes('Button')) patternJson.components.push('Button');
-            modified = true;
-            fixes.push(`  + Added Footer + Button to ${patternName}`);
-          }
-          continue;
-        }
-
-        // Auto-fix: wrap root in Column if Column is missing
-        if (comp === 'Column' && root && root.component !== 'Column') {
-          // If root is Card, check if Section children could be wrapped
-          const section = template.find(c => c.component === 'Section' && root.children?.includes(c.id));
-          if (section && section.children?.length > 0) {
-            // Wrap section children in a Column
-            const colId = 'col-wrap';
-            const originalChildren = [...section.children];
-            template.push({ id: colId, component: 'Column', children: originalChildren, gap: '4' });
-            section.children = [colId];
-            if (!patternJson.components.includes('Column')) patternJson.components.push('Column');
-            modified = true;
-            fixes.push(`  + Wrapped Section children in Column for ${patternName}`);
-          } else {
-            fixes.push(`  ⚠ Pattern "${patternName}" needs ${comp} — manual review required`);
-          }
-          continue;
-        }
-
-        fixes.push(`  ⚠ Pattern "${patternName}" needs ${comp} — manual review required`);
-      }
-    }
-
-    if (modified) {
-      patternJson.version = (patternJson.version || 1) + 1;
-      await writeFile(filePath, JSON.stringify(patternJson, null, 2) + '\n');
-      fixes.push(`  ✓ Wrote ${filePath}`);
-    }
-  }
-
-  return fixes;
-}
-
-// ── Main loop ──
-
-async function runEvalLoop() {
-  const evalsData = JSON.parse(await readFile(EVALS_PATH, 'utf8'));
-  const evalCases = evalsData.evals;
-
-  for (let iter = 0; iter < MAX_ITER; iter++) {
-    console.log(`\n${'═'.repeat(60)}`);
-    console.log(`  Iteration ${iter + 1}/${MAX_ITER}`);
-    console.log('═'.repeat(60));
-
-    // Run all evals
-    const diagnoses = [];
-    let allClean = true;
-
-    for (const evalCase of evalCases) {
-      const result = await generateUI({ intent: evalCase.prompt, mode: evalCase.mode || 'instant' });
-      const diag = diagnose(evalCase, result);
-
-      if (diag.findings.length > 0) {
-        allClean = false;
-        diagnoses.push(diag);
-
-        const validation = validateSchema(result.messages);
-        console.log(`\n  ✗ #${evalCase.id} [${validation.score}] ${evalCase.prompt.slice(0, 55)}...`);
-        if (diag.matched_pattern) console.log(`    Matched: ${diag.matched_pattern}`);
-        for (const f of diag.findings) {
-          console.log(`    ${f.category} (${f.severity}): ${f.fix}`);
-          if (VERBOSE && f.violations) {
-            for (const v of f.violations) console.log(`      - ${v.message}`);
-          }
-          if (VERBOSE && f.missing_components) {
-            console.log(`      Missing: ${f.missing_components.join(', ')}`);
-          }
-        }
-      } else {
-        const validation = validateSchema(result.messages);
-        console.log(`  ✓ #${evalCase.id} [${validation.score}] ${evalCase.prompt.slice(0, 55)}...`);
-      }
-    }
-
-    if (allClean) {
-      console.log('\n  ✓ All evals clean — no issues found.');
-      break;
-    }
-
-    if (!APPLY && !TICKETS) {
-      console.log(`\n  ${diagnoses.length} eval(s) with issues. Run with --apply to fix or --tickets to create tickets.`);
-      break;
-    }
-
-    // Create tickets for all findings (when --tickets flag is set, or for unfixable issues during --apply)
-    if (TICKETS) {
-      console.log('\n── Creating tickets ──');
-      for (const diag of diagnoses) {
-        for (const f of diag.findings) {
-          const ticket = await createTicket({
-            type: f.category === 'INTENT_MISS' ? 'improvement' : 'bug',
-            title: `Eval #${diag.evalId}: ${f.category} in ${f.matched_pattern || 'generated output'}`,
-            source: 'eval-fix',
-            severity: f.severity,
-            category: f.category === 'ANTI_PATTERN' || f.category === 'INTENT_MISS' ? 'pattern'
-              : f.category === 'CARD_MODEL' ? 'pattern'
-              : f.category === 'STRUCTURAL' ? 'validator' : 'generator',
-            target: f.matched_pattern ? `patterns/${getPattern(f.matched_pattern)?.domain || 'layout'}/${f.matched_pattern}.json` : null,
-            description: f.fix,
-            evidence: {
-              evalId: diag.evalId,
-              prompt: diag.prompt.slice(0, 100),
-              matched_pattern: f.matched_pattern,
-              ...(f.violations ? { violations: f.violations.map(v => v.message) } : {}),
-              ...(f.missing_components ? { missing_components: f.missing_components } : {}),
-              ...(f.issues ? { card_issues: f.issues } : {}),
-              ...(f.failed_checks ? { failed_checks: f.failed_checks.map(c => c.name) } : {}),
-            },
-            suggested_fix: f.fix,
-          });
-          console.log(`  📋 ${ticket.id}`);
-          console.log(`     ${ticket.title}`);
-        }
-      }
-      if (!APPLY) break;
-    }
-
-    if (!APPLY) break;
-
-    // Apply fixes
-    console.log('\n── Applying fixes ──');
-    let totalFixes = 0;
-    for (const diag of diagnoses) {
-      const fixes = await applyFix(diag);
-      for (const f of fixes) {
-        console.log(f);
-        totalFixes++;
-      }
-    }
-
-    if (totalFixes === 0) {
-      console.log('  No auto-fixable issues found. Remaining issues need manual review.');
-      break;
-    }
-
-    console.log(`\n  Applied ${totalFixes} fixes. Re-running evals...`);
-
-    // Reload pattern library to pick up changes
-    const { loadCorpus } = await import('../../retrieval/pattern-library.js');
-    // Force reload by resetting the loaded state
-    // (The pattern files were rewritten, but the in-memory Map still has old data)
-    // We need to re-import fresh — but ESM caching prevents that.
-    // Instead, directly re-read the patched files and update the Map.
-    for (const diag of diagnoses) {
-      if (!diag.matched_pattern) continue;
-      const pattern = getPattern(diag.matched_pattern);
-      if (!pattern) continue;
-      const domain = pattern.domain || 'layout';
-      const filePath = join(PATTERNS_DIR, domain, `${diag.matched_pattern}.json`);
-      try {
-        const fresh = JSON.parse(await readFile(filePath, 'utf8'));
-        // Normalize tags
-        if (fresh.tags && !Array.isArray(fresh.tags)) {
-          fresh.tagsMeta = fresh.tags;
-          fresh.tags = fresh.keywords || [];
-        }
-        // Update in-memory
-        const { registerPattern } = await import('../../retrieval/pattern-library.js');
-        registerPattern(fresh, { replace: true });
-      } catch {}
-    }
-  }
-}
-
-runEvalLoop().catch(console.error);