@adia-ai/a2ui-mcp 0.6.4 → 0.6.6

package/server.js

@@ -1,115 +1,56 @@
 #!/usr/bin/env node
-
-/**
- * AdiaUI MCP Server
- *
- * Exposes A2UI generative tools via MCP protocol.
- * Runs as a stdio server for Claude Desktop / Claude Code.
- *
- * Tools:
- *   generate_ui       — Generate A2UI components from intent
- *   validate_schema   — Validate A2UI messages
- *   lookup_component  — Component API lookup
- *   get_component_map — Full catalog
- *   search_patterns   — Composition library search (kept for back-compat; backed by composition-library since §64)
- *   classify_intent   — Domain classification
- *
- * Usage:
- *   node packages/a2ui/mcp/server.js
- */
-
-// ── Load .env for API keys (Node doesn't read .env automatically) ──
-import '../../../scripts/load-env.mjs';
-
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { z } from 'zod';
-
-// ── Import from a2ui ──
-import { generateUI } from '../compose/core/generator.js';
-import { validateSchema } from '../validator/validator.js';
-import { validateMessages as validateCatalogMessages } from '../validator/catalog-validator.js';
+import "../../../scripts/load-env.mjs";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { generateUI } from "../compose/core/generator.js";
 import {
   getCatalog,
-  getComponent,
-  getComponentsByCategory,
-  getTraits,
-  getTraitsByCategory,
   getFullCatalog,
-} from '../retrieval/catalog.js';
-import { serializeEntry } from '../retrieval/component-entry.js';
-import { classifyIntent, getDomain, getAllDomains } from '../retrieval/domain-router.js';
-import { getAntiPatterns, checkAllAntiPatterns } from '../retrieval/anti-patterns.js';
-import { assembleContext } from '../retrieval/context-assembler.js';
-
-// ── Zettel (composition) engine ──
+  getTraits
+} from "../retrieval/catalog.js";
+import { serializeEntry } from "../retrieval/component-entry.js";
+import { classifyIntent, getDomain, getAllDomains } from "../retrieval/domain-router.js";
+import { getAntiPatterns } from "../retrieval/anti-patterns.js";
 import {
   loadAll as loadZettelCorpus,
-  getComposition as getZettelComposition,
-  getAllCompositions as getAllZettelCompositions,
-  getGraph as getZettelGraph,
-  searchAll as searchCompositions,
-} from '../compose/strategies/zettel/composition-library.js';
-import {
-  resolveComposition as resolveZettelComposition,
-  templateToMessages as zettelTemplateToMessages,
-} from '../compose/strategies/zettel/composer.js';
-// 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 composition corpus
+  getAllCompositions as getAllZettelCompositions
+} from "../compose/strategies/zettel/composition-library.js";
 const _zettelBoot = loadZettelCorpus();
 console.error(
-  `[adiaui-mcp] zettel corpus: ${_zettelBoot.compositionCount} compositions`,
+  `[adiaui-mcp] zettel corpus: ${_zettelBoot.compositionCount} compositions`
 );
-
-// ── Gen-UI training-chunk corpus ──
-import {
-  getChunk as getGenUIChunk,
-  getChunkIndex,
-  lookupChunksByPrimary,
-  searchChunks as searchGenUIChunks,
-} from '../corpus/scripts/chunk-library.js';
-
-// ── Inline-tool deps (transpiler / wiring / feedback) ──
-import { transpileHTML } from '../compose/transpiler/transpiler.js';
-import { getWiringCatalog } from '../retrieval/wiring-catalog.js';
-import { FeedbackCollector } from '../retrieval/feedback/feedback.js';
-import { feedbackStore } from '../retrieval/feedback/feedback-store.js';
-
-// ── Tools extracted to tools/ for modularity ──
-import { registerSynthesisTools } from './tools/synthesis.js';
-
+import { getChunkIndex } from "../corpus/scripts/chunk-library.js";
 const _chunkIndex = getChunkIndex();
 if (_chunkIndex) {
+  const idx = _chunkIndex;
+  const byKind = idx["by_kind"] ?? {};
   console.error(
-    `[adiaui-mcp] gen-ui chunks: ${_chunkIndex.unique_names} unique chunks (${_chunkIndex.total_instances} instances; block=${_chunkIndex.by_kind.block || 0}, panel=${_chunkIndex.by_kind.panel || 0}, page=${_chunkIndex.by_kind.page || 0})`,
+    `[adiaui-mcp] gen-ui chunks: ${idx["unique_names"]} unique chunks (${idx["total_instances"]} instances; block=${byKind["block"] ?? 0}, panel=${byKind["panel"] ?? 0}, page=${byKind["page"] ?? 0})`
   );
 } else {
-  console.error('[adiaui-mcp] gen-ui chunks: index not found — run `npm run harvest:chunks`');
+  console.error("[adiaui-mcp] gen-ui chunks: index not found \u2014 run `npm run harvest:chunks`");
 }
-
-// ── Server ──
-
+import { registerSynthesisTools } from "./tools/synthesis.js";
+import { registerValidationTools } from "./tools/validation.js";
+import { registerFeedbackTools } from "./tools/feedback.js";
+import { registerCorpusTools } from "./tools/corpus.js";
+import { registerZettelTools } from "./tools/zettel.js";
 const server = new McpServer({
-  name: 'adia-ui',
-  version: '0.1.0',
+  name: "adia-ui",
+  version: "0.1.0"
 });
-
 server.tool(
-  'plan_app_state',
+  "plan_app_state",
   `Analyze a natural language prompt and extract the top-level Generative UI Ontology structures (Intent, Domain, Tasks, Experience).
   
 Use this tool BEFORE generating UI to ensure you have walked the Reasoning Ladder and properly modeled the nouns and verbs of the feature. This bounds hallucination and forces a focus on tasks over raw layouts.`,
   {
-    prompt: z.string().describe('The natural language request (e.g., "Build a dashboard for incoming sales leads")'),
+    prompt: z.string().describe('The natural language request (e.g., "Build a dashboard for incoming sales leads")')
   },
   async ({ prompt }) => {
-    // We utilize the LLM directly here to act as the reasoning gate.
-    // This is a minimal, fast call designed to output structured JSON.
-    const { createAdapter } = await import('../../llm/llm-bridge.js');
+    const { createAdapter } = await import("../../llm/llm-bridge.js");
     const llm = await createAdapter();
-    
     const systemPrompt = `You are the A2UI Ontology Planner.
 Given a user prompt, you must extract the Core App State using the 5-Gate Reasoning Ladder.
 
@@ -132,59 +73,55 @@ Output ONLY a JSON object matching this schema, nothing else:
     "shell": "admin-shell | chat-shell | a2ui-root"
   }
 }`;
-
     try {
       const response = await llm.complete({
-        messages: [{ role: 'user', content: prompt }],
+        messages: [{ role: "user", content: prompt }],
         system: systemPrompt,
         temperature: 0.2
       });
-
-      let jsonMatch = response.text.match(/\{[\s\S]*\}/);
+      const jsonMatch = response.content.match(/\{[\s\S]*\}/);
       if (!jsonMatch) {
-         throw new Error("LLM failed to output valid JSON for the ontology plan.");
+        throw new Error("LLM failed to output valid JSON for the ontology plan.");
       }
-      
       const plan = JSON.parse(jsonMatch[0]);
-
       return {
         content: [
           {
-            type: 'text',
-            text: JSON.stringify(plan, null, 2),
-          },
-        ],
+            type: "text",
+            text: JSON.stringify(plan, null, 2)
+          }
+        ]
       };
     } catch (e) {
+      const err = e instanceof Error ? e : new Error(String(e));
       return {
         content: [
-          { type: 'text', text: `Failed to plan app state: ${e.message}` }
+          { type: "text", text: `Failed to plan app state: ${err.message}` }
         ],
-        isError: true,
-      }
+        isError: true
+      };
     }
   }
 );
-
 server.tool(
-  'generate_ui',
+  "generate_ui",
   `Generate A2UI components from a natural language description.
 
 Engine selection:
-- "monolithic" (default) — pattern-match + adapt. Searches a corpus of 96+ pre-authored monolithic templates and adapts the best match. Battle-tested; highest F1 on held-out intents.
-- "zettel" — fragment-graph composer. Composes UI from named atomic fragments (labeled-input, card-header-with-description, etc.) with a precomputed backlink graph. Higher reusability; supports composition-iterated refinement on multi-turn edits.
+- "monolithic" (default) \u2014 pattern-match + adapt. Searches a corpus of 96+ pre-authored monolithic templates and adapts the best match. Battle-tested; highest F1 on held-out intents.
+- "zettel" \u2014 fragment-graph composer. Composes UI from named atomic fragments (labeled-input, card-header-with-description, etc.) with a precomputed backlink graph. Higher reusability; supports composition-iterated refinement on multi-turn edits.
 
 Mode selection (monolithic only; zettel uses "instant"):
-- "pro" (default) — LLM-powered generation with pattern adaptation.
-- "thinking" — Full LLM-powered generation with semantic search, decomposition, and streaming.
-- "instant" — fast pattern matching, no LLM.
+- "pro" (default) \u2014 LLM-powered generation with pattern adaptation.
+- "thinking" \u2014 Full LLM-powered generation with semantic search, decomposition, and streaming.
+- "instant" \u2014 fast pattern matching, no LLM.
 
 The generator knows 96+ UI patterns across 5 domains: forms, data, layout, agent, navigation.`,
   {
-    intent: z.string().describe('Description of the UI to generate'),
-    engine: z.enum(['monolithic', 'zettel']).optional().describe('Generation engine. "monolithic" (default) is pattern-match + adapt. "zettel" is fragment-graph composition.'),
-    mode: z.enum(['instant', 'pro', 'thinking']).optional().describe('Generation mode (monolithic). "pro" (default) uses LLM with pattern adaptation. "thinking" uses full LLM generation. "instant" uses fast pattern matching.'),
-    sessionId: z.string().optional().describe('Opaque session identifier for multi-turn iteration (zettel only). When provided, follow-up calls with the same sessionId modify the prior turn\'s canvas instead of regenerating from scratch. Omit for stateless generation.'),
+    intent: z.string().describe("Description of the UI to generate"),
+    engine: z.enum(["monolithic", "zettel"]).optional().describe('Generation engine. "monolithic" (default) is pattern-match + adapt. "zettel" is fragment-graph composition.'),
+    mode: z.enum(["instant", "pro", "thinking"]).optional().describe('Generation mode (monolithic). "pro" (default) uses LLM with pattern adaptation. "thinking" uses full LLM generation. "instant" uses fast pattern matching.'),
+    sessionId: z.string().optional().describe("Opaque session identifier for multi-turn iteration (zettel only). When provided, follow-up calls with the same sessionId modify the prior turn's canvas instead of regenerating from scratch. Omit for stateless generation."),
     context: z.object({
       domain: z.object({
         entities: z.array(z.string()).optional(),
@@ -194,519 +131,145 @@ The generator knows 96+ UI patterns across 5 domains: forms, data, layout, agent
         primary: z.array(z.string()).optional(),
         inspection: z.array(z.string()).optional()
       }).optional()
-    }).optional().describe('Ontology context parsed by plan_app_state. If provided, the generator uses these constraints to bound hallucinations and strictly align components with domain tasks.')
+    }).optional().describe("Ontology context parsed by plan_app_state. If provided, the generator uses these constraints to bound hallucinations and strictly align components with domain tasks.")
   },
   async ({ intent, engine, mode, sessionId, context }) => {
     try {
-      const selectedEngine = engine || 'monolithic';
-      const effectiveMode = selectedEngine === 'zettel' ? 'instant' : (mode || 'pro');
+      const selectedEngine = engine ?? "monolithic";
+      const effectiveMode = selectedEngine === "zettel" ? "instant" : mode ?? "pro";
       const result = await generateUI({
         intent,
         engine: selectedEngine,
         mode: effectiveMode,
         sessionId,
-        context, // Pass the ontology context down to the composer
+        context
+        // Pass the ontology context down to the composer
       });
       return {
         content: [{
-          type: 'text',
+          type: "text",
           text: JSON.stringify({
-            engine: result.engine || selectedEngine,
-            executionId: result.executionId,
-            strategy: result.strategy,
-            messages: result.messages,
-            validation: result.validation,
-            suggestions: result.suggestions,
-            composition: result.composition,
-            fragments_used: result.fragments_used,
-            sessionTurns: result.sessionTurns,
-          }, null, 2),
-        }],
+            engine: result["engine"] ?? selectedEngine,
+            executionId: result["executionId"],
+            strategy: result["strategy"],
+            messages: result["messages"],
+            validation: result["validation"],
+            suggestions: result["suggestions"],
+            composition: result["composition"],
+            fragments_used: result["fragments_used"],
+            sessionTurns: result["sessionTurns"]
+          }, null, 2)
+        }]
       };
     } catch (err) {
-      return { content: [{ type: 'text', text: `Generation error: ${err.message}` }], isError: true };
+      const e = err instanceof Error ? err : new Error(String(err));
+      return { content: [{ type: "text", text: `Generation error: ${e.message}` }], isError: true };
     }
   }
 );
-
 server.tool(
-  'validate_schema',
-  'Validate A2UI messages against schema rules.',
+  "classify_intent",
+  "Classify intent into a UI domain.",
   {
-    messages: z.string().describe('JSON array of A2UI messages'),
-  },
-  async ({ messages }) => {
-    try {
-      const parsed = JSON.parse(messages);
-      const msgs = Array.isArray(parsed) ? parsed : [parsed];
-      // Two orthogonal checks:
-      //   1. scored — weighted heuristic validator (intent alignment, card model, etc.)
-      //   2. catalog — AJV against v0.9 catalog schema (type-level structural correctness)
-      // Both run; results returned together so callers see structural + quality signal.
-      const scored = validateSchema(msgs);
-      const catalog = await validateCatalogMessages(msgs);
-      const result = { ...scored, catalog };
-      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: 'text', text: `Parse error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  'lookup_component',
-  'Look up a AdiaUI component by type name.',
-  {
-    type: z.string().describe('Component type (e.g., "Card", "Button")'),
-    level: z.enum(['index', 'summary', 'reference']).optional().describe('Detail level (default: reference)'),
-  },
-  async ({ type, level }) => {
-    const entry = await getComponent(type);
-    if (!entry) return { content: [{ type: 'text', text: `Not found: ${type}` }], isError: true };
-    const serialized = serializeEntry(entry, level || 'reference');
-    return { content: [{ type: 'text', text: JSON.stringify(serialized, null, 2) }] };
-  }
-);
-
-server.tool(
-  'get_component_map',
-  'Get the full AdiaUI component catalog.',
-  {},
-  async () => {
-    const catalog = await getCatalog();
-    const summary = [...catalog.entries.values()]
-      .map(e => `${e.type} -> <${e.tag}>: ${e.description?.slice(0, 80) || ''}`)
-      .join('\n');
-    return { content: [{ type: 'text', text: summary }] };
-  }
-);
-
-server.tool(
-  'search_patterns',
-  `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 composition exists, pass it to generate_ui with instant mode. If no composition matches, use generate_ui with thinking mode.
-
-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)'),
-  },
-  async ({ query }) => {
-    const results = searchCompositions(query);
-    return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
-  }
-);
-
-server.tool(
-  'classify_intent',
-  'Classify intent into a UI domain.',
-  {
-    text: z.string().describe('Intent text'),
+    text: z.string().describe("Intent text")
   },
   async ({ text }) => {
-    return { content: [{ type: 'text', text: JSON.stringify(classifyIntent(text), null, 2) }] };
-  }
-);
-
-server.tool(
-  'assemble_context',
-  `Assemble progressive-disclosure context for a given intent and budget tier. Returns domain-relevant components, matching patterns, and anti-patterns.
-
-Tier 0: domain only. Tier 1: components. Tier 2: +patterns. Tier 3: +anti-patterns. Tier 4: full catalog.
-
-Use this when you want to manually compose A2UI output rather than using generate_ui. The returned context gives you the building blocks.`,
-  {
-    intent: z.string().describe('Natural language intent'),
-    tier: z.number().min(0).max(4).optional().describe('Budget tier 0-4 (default: 1)'),
-  },
-  async ({ intent, tier }) => {
-    const result = assembleContext({ intent, tier: tier ?? 1 });
-    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-  }
-);
-
-server.tool(
-  'check_anti_patterns',
-  'Check HTML against all anti-patterns. Returns only violations.',
-  {
-    html: z.string().describe('HTML string to check'),
-  },
-  async ({ html }) => {
-    const violations = checkAllAntiPatterns(html);
-    return { content: [{ type: 'text', text: JSON.stringify(violations, null, 2) }] };
+    return { content: [{ type: "text", text: JSON.stringify(classifyIntent(text), null, 2) }] };
   }
 );
-
 server.tool(
-  'get_traits',
-  'Get the trait catalog, optionally filtered by category.',
+  "run_eval",
+  "Run the offline eval harness against the held-out intent set. Returns aggregate scores and per-intent results.",
   {
-    category: z.string().optional().describe('Trait category filter (e.g., "input-interaction", "motion-positioning")'),
-  },
-  async ({ category }) => {
-    const traits = category ? getTraitsByCategory(category) : getTraits();
-    return { content: [{ type: 'text', text: JSON.stringify(traits, null, 2) }] };
-  }
-);
-
-// ── Transpiler & Wiring Tools ──
-
-server.tool(
-  'convert_html',
-  'Convert HTML markup to A2UI flat adjacency component messages. Maps HTML tags to AdiaUI components, infers layout from styles, enforces Card content model.',
-  {
-    html: z.string().describe('HTML markup to convert'),
-    mode: z.enum(['instant', 'reasoning']).optional().describe('instant = rules only, reasoning = LLM for complex layouts'),
-  },
-  async ({ html, mode }) => {
-    try {
-      const result = await transpileHTML(html, { mode: mode || 'instant' });
-      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: 'text', text: `Transpile error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  'get_wiring_catalog',
-  'Get the AdiaUI wiring catalog: available controllers, action handlers, refresh strategies, value sources, and association types.',
-  {},
-  async () => {
-    const catalog = getWiringCatalog();
-    return { content: [{ type: 'text', text: JSON.stringify(catalog, null, 2) }] };
-  }
-);
-
-// ── Feedback Tools ──
-
-const feedbackCollector = new FeedbackCollector();
-
-server.tool(
-  'submit_feedback',
-  'Submit structured feedback for a generation execution. Used by the evolution engine to learn from each generation.',
-  {
-    executionId: z.string().describe('Execution ID from generate_ui'),
-    rating: z.number().min(1).max(5).describe('Overall quality 1-5'),
-    intent: z.string().optional(),
-    domain: z.string().optional(),
-    intentAlignment: z.number().min(1).max(5).optional(),
-    visualQuality: z.number().min(1).max(5).optional(),
-    componentChoice: z.number().min(1).max(5).optional(),
-    userEdited: z.boolean().optional(),
-    editSummary: z.string().optional(),
-    notes: z.string().optional(),
-    shouldBePattern: z.boolean().optional(),
-    suggestedName: z.string().optional(),
-  },
-  async (args) => {
-    feedbackCollector.collectFeedback(args.executionId, {
-      rating: args.rating,
-      intentAlignment: args.intentAlignment,
-      visualQuality: args.visualQuality,
-      componentChoice: args.componentChoice,
-      userEdited: args.userEdited,
-      editSummary: args.editSummary,
-      notes: args.notes,
-    });
-    if (args.shouldBePattern != null) {
-      feedbackCollector.collectPatternFeedback(args.executionId, {
-        shouldBePattern: args.shouldBePattern,
-        suggestedName: args.suggestedName,
-      });
-    }
-    return { content: [{ type: 'text', text: JSON.stringify({ recorded: true, executionId: args.executionId, totalEntries: feedbackCollector.size }) }] };
-  }
-);
-
-// ── Quality metrics tool ──
-
-server.tool(
-  'get_quality_metrics',
-  'Get aggregated quality metrics from the feedback store: avg score, thumb-up rate, per-domain breakdown, training gaps.',
-  {},
-  async () => {
-    const metrics = await feedbackStore.getQualityMetrics();
-    return { content: [{ type: 'text', text: JSON.stringify(metrics, null, 2) }] };
-  }
-);
-
-server.tool(
-  'get_training_gaps',
-  'Get training gap signals from LLM self-critique: missing patterns, weak domain keywords, component gaps.',
-  {},
-  async () => {
-    const gaps = await feedbackStore.getGapSummary();
-    return { content: [{ type: 'text', text: JSON.stringify(gaps, null, 2) }] };
-  }
-);
-
-server.tool(
-  'run_eval',
-  'Run the offline eval harness against the held-out intent set. Returns aggregate scores and per-intent results.',
-  {
-    domain: z.string().optional().describe('Filter by domain (forms, data, layout, agent, navigation)'),
-    limit: z.number().optional().describe('Max intents to evaluate'),
+    domain: z.string().optional().describe("Filter by domain (forms, data, layout, agent, navigation)"),
+    limit: z.number().optional().describe("Max intents to evaluate")
   },
   async ({ domain, limit }) => {
     try {
-      const { runHarness } = await import('../a2ui/evals/harness.mjs');
+      const { runHarness } = await import("../a2ui/evals/harness.mjs");
       const summary = await runHarness({
-        generate: (args) => generateUI({ intent: args.intent, mode: 'instant' }),
+        generate: (args) => generateUI({ intent: args["intent"], mode: "instant" }),
         domain,
         limit,
-        mode: 'instant',
+        mode: "instant"
       });
-      return { content: [{ type: 'text', text: JSON.stringify(summary, null, 2) }] };
+      return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
     } catch (err) {
-      return { content: [{ type: 'text', text: `Eval error: ${err.message}` }], isError: true };
+      const e = err instanceof Error ? err : new Error(String(err));
+      return { content: [{ type: "text", text: `Eval error: ${e.message}` }], isError: true };
     }
   }
 );
-
-// ── Resources ──
-
 server.resource(
-  'catalog',
-  'a2ui://catalog/manifest',
+  "catalog",
+  "a2ui://catalog/manifest",
   async (uri) => {
     const catalog = await getFullCatalog();
     const serializable = {
       version: catalog.version,
       totalTypes: catalog.totalTypes,
       totalTraits: catalog.totalTraits,
-      components: [...catalog.entries.values()].map(e => serializeEntry(e, 'summary')),
-      traits: catalog.traits,
+      components: [...catalog.entries.values()].map((e) => serializeEntry(e, "summary")),
+      traits: catalog.traits
     };
     return {
       contents: [{
         uri: uri.href,
-        mimeType: 'application/json',
-        text: JSON.stringify(serializable, null, 2),
-      }],
+        mimeType: "application/json",
+        text: JSON.stringify(serializable, null, 2)
+      }]
     };
   }
 );
-
 server.resource(
-  'compositions',
-  'a2ui://catalog/compositions',
+  "compositions",
+  "a2ui://catalog/compositions",
   async (uri) => ({
     contents: [{
       uri: uri.href,
-      mimeType: 'application/json',
-      text: JSON.stringify(getAllZettelCompositions(), null, 2),
-    }],
+      mimeType: "application/json",
+      text: JSON.stringify(getAllZettelCompositions(), null, 2)
+    }]
   })
 );
-
 server.resource(
-  'anti-patterns',
-  'a2ui://catalog/anti-patterns',
+  "anti-patterns",
+  "a2ui://catalog/anti-patterns",
   async (uri) => ({
     contents: [{
       uri: uri.href,
-      mimeType: 'application/json',
-      text: JSON.stringify(getAntiPatterns(), null, 2),
-    }],
+      mimeType: "application/json",
+      text: JSON.stringify(getAntiPatterns(), null, 2)
+    }]
   })
 );
-
 server.resource(
-  'domains',
-  'a2ui://catalog/domains',
+  "domains",
+  "a2ui://catalog/domains",
   async (uri) => {
-    const domains = getAllDomains().map(name => ({
+    const domains = getAllDomains().map((name) => ({
       name,
-      ...getDomain(name),
+      ...getDomain(name)
     }));
     return {
       contents: [{
         uri: uri.href,
-        mimeType: 'application/json',
-        text: JSON.stringify(domains, null, 2),
-      }],
+        mimeType: "application/json",
+        text: JSON.stringify(domains, null, 2)
+      }]
     };
   }
 );
-
-// ── Zettel composition-inspection tools ────────────────────────────────
-// (Fragment-inspection tools retired in §37; fragments no longer exist as
-// a separate corpus class. Compositions are now flat A2UI templates.)
-
-server.tool(
-  'get_composition',
-  'Fetch a composition by name. Returns the flat A2UI template (compositions are pre-inlined; no $fragment refs). Zettel-only.',
-  { name: z.string() },
-  async ({ name }) => {
-    const c = getZettelComposition(name);
-    if (!c) return { content: [{ type: 'text', text: `Composition not found: ${name}` }], isError: true };
-    return { content: [{ type: 'text', text: JSON.stringify(c, null, 2) }] };
-  },
-);
-
-server.tool(
-  'resolve_composition',
-  'Return the flat A2UI template + updateComponents messages for a composition. Zettel-only. (Pre-inlined since §37 — `resolve` is now a defensive copy + strip pass.)',
-  { name: z.string() },
-  async ({ name }) => {
-    const c = getZettelComposition(name);
-    if (!c) return { content: [{ type: 'text', text: `Composition not found: ${name}` }], isError: true };
-    const template = resolveZettelComposition(c);
-    const messages = zettelTemplateToMessages(template);
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({ template, messages }, null, 2),
-      }],
-    };
-  },
-);
-
-server.tool(
-  'get_graph',
-  'Return the composition catalog. Zettel-only. (Backlinks to fragments retired in §37; only composition nodes remain.)',
-  {},
-  async () => ({ content: [{ type: 'text', text: JSON.stringify(getZettelGraph(), null, 2) }] }),
-);
-
-server.tool(
-  'zettel_stats',
-  'Zettel corpus stats — composition count + average node count. (Fragment stats retired in §37.)',
-  {},
-  async () => {
-    const comps = getAllZettelCompositions();
-    const totalNodes = comps.reduce((s, c) => s + (c.template?.length || 0), 0);
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({
-          compositions: comps.length,
-          avg_nodes_per_composition: comps.length ? Math.round(totalNodes / comps.length) : 0,
-          total_nodes: totalNodes,
-        }, null, 2),
-      }],
-    };
-  },
-);
-
-// ── Gen-UI training-chunk tools ──────────────────────────────────────
-// Spec: docs/specs/genui-chunk-marker.md (Draft v0.1.0).
-// Plan: docs/plans/training-pipeline-chunk-harvest-2026-04-27.md.
-
-server.tool(
-  'search_chunks',
-  `Search the gen-UI training-chunk corpus by keyword.
-
-The chunk corpus comes from \`packages/a2ui/corpus/chunks/\` — JSON records
-extracted from every \`[data-chunk]\` element in site/pages/* and the corpus
-exemplars. There are three kinds:
-  - block (default): atomic UI fragment (KPI grid, sign-in form, table)
-  - panel: tab-panel fragment of a page (e.g. dashboard-overview-panel)
-  - page: full-page composition (e.g. dashboard-admin-page)
-
-Returns ranked candidates with chunk name, kind, primary tag, and a relevance
-score. Use \`get_chunk\` to fetch the full record (HTML + slot bindings + nested
-chunks) for a specific name.`,
-  {
-    query: z.string().describe('Keyword query — chunk name fragment, intent words, primary-tag name'),
-    kind: z.enum(['block', 'panel', 'page']).optional().describe('Filter by chunk kind'),
-    limit: z.number().int().min(1).max(50).default(20).describe('Max results'),
-  },
-  async ({ query, kind, limit }) => {
-    const results = searchGenUIChunks(query, { kind, limit });
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({ query, kind: kind || 'any', count: results.length, results }, null, 2),
-      }],
-    };
-  },
-);
-
-server.tool(
-  'get_chunk',
-  `Fetch the full record for a single gen-UI training chunk by name.
-
-Returns the chunk's bounding HTML, slot annotations, nested chunk names, and
-metadata (primary tag, kind, source page). For chunks that appear on multiple
-pages (reusable slot chunks like \`auth-card-header\`, \`reg-step-header\`),
-returns an \`instances\` array — one entry per page where the chunk appears.
-
-The HTML is suitable for direct rendering / inclusion in an A2UI message
-construction prompt.`,
-  {
-    name: z.string().describe('The chunk name, e.g. "dashboard-kpi-grid", "auth-signin-card-email", "code-language"'),
-  },
-  async ({ name }) => {
-    const rec = getGenUIChunk(name);
-    if (!rec) {
-      return {
-        isError: true,
-        content: [{ type: 'text', text: JSON.stringify({ error: 'chunk not found', name }, null, 2) }],
-      };
-    }
-    return { content: [{ type: 'text', text: JSON.stringify(rec, null, 2) }] };
-  },
-);
-
-server.tool(
-  'lookup_chunk',
-  `List every chunk whose primary element is \`<component_name>\`.
-
-Useful for "show me every page that opens with a \`<card-ui raw>\`" or "every
-chunk built around a \`<grid-ui>\` root." Returns chunk names + kinds + sources.
-
-Pair with \`get_chunk\` to fetch full records for any of the returned names.`,
-  {
-    component_name: z.string().describe('Component tag name, e.g. "card-ui", "grid-ui", "drawer-ui"'),
-  },
-  async ({ component_name }) => {
-    const recs = lookupChunksByPrimary(component_name);
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({
-          component: component_name,
-          count: recs.length,
-          chunks: recs.map((r) => ({
-            name: r.name,
-            kind: r.kind,
-            page: r.page || r.instances?.[0]?.page,
-            slots: (r.slots || r.instances?.[0]?.slots || []).map((s) => s.name),
-            nested: r.nested || r.instances?.[0]?.nested || [],
-          })),
-        }, null, 2),
-      }],
-    };
-  },
-);
-
-// ── Chunk-aware composition + multi-turn refinement ──────────────────
-// `compose_from_chunks`, `refine_composition`, `get_state`, `report_issue`
-// share the LLM bridge + state-cache + issue-reporter + chunk-refiner
-// stack. Extracted to tools/synthesis.js.
-//
-// Spec: docs/specs/genui-multiturn-architecture.md (Phase A) +
-// docs/specs/genui-chunk-marker.md.
-
+registerValidationTools(server);
+registerFeedbackTools(server);
+registerCorpusTools(server);
+registerZettelTools(server);
 registerSynthesisTools(server);
-
-
-// ── Start ──
-
 async function main() {
   const transport = new StdioServerTransport();
-
-  // (Auto-ingest of exemplar-derived patterns retired 2026-04-28 in
-  // mcp 0.0.5. The chunk corpus + chunk-aware synthesizer are the
-  // training surface now; the legacy extract → ingest path that pulled
-  // 70 patterns from prose exemplars on every server boot is gone.)
-
   await server.connect(transport);
   const catalog = await getCatalog();
   const traits = getTraits();
   console.error(`AdiaUI MCP Server running (${catalog.totalTypes} components, ${traits.length} traits, ${_zettelBoot.compositionCount} compositions)`);
 }
-
 main().catch(console.error);