@decantr/mcp-server 1.0.0-beta.1 → 1.0.0-beta.10

package/dist/chunk-A5IEC7O2.js

@@ -0,0 +1,1939 @@
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools.ts
+import { existsSync, readFileSync } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2, dirname as dirname2 } from "path";
+import { validateEssence, evaluateGuard, isV3 as isV32 } from "@decantr/essence-spec";
+import { resolvePatternPreset } from "@decantr/registry";
+
+// src/helpers.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join, dirname } from "path";
+import { RegistryAPIClient } from "@decantr/registry";
+import { isV3, migrateV2ToV3 } from "@decantr/essence-spec";
+var MAX_INPUT_LENGTH = 1e3;
+function validateStringArg(args, field) {
+  const val = args[field];
+  if (!val || typeof val !== "string") {
+    return `Required parameter "${field}" must be a non-empty string.`;
+  }
+  if (val.length > MAX_INPUT_LENGTH) {
+    return `Parameter "${field}" exceeds maximum length of ${MAX_INPUT_LENGTH} characters.`;
+  }
+  return null;
+}
+function fuzzyScore(query, text) {
+  const q = query.toLowerCase();
+  const t = text.toLowerCase();
+  if (t === q) return 100;
+  if (t.startsWith(q)) return 90;
+  if (t.includes(q)) return 80;
+  let qi = 0;
+  for (let ti = 0; ti < t.length && qi < q.length; ti++) {
+    if (t[ti] === q[qi]) qi++;
+  }
+  return qi === q.length ? 60 : 0;
+}
+var _apiClient = null;
+function getAPIClient() {
+  if (!_apiClient) {
+    _apiClient = new RegistryAPIClient({
+      baseUrl: process.env.DECANTR_API_URL || void 0,
+      apiKey: process.env.DECANTR_API_KEY || void 0
+    });
+  }
+  return _apiClient;
+}
+async function readEssenceFile(essencePath) {
+  const resolvedPath = essencePath || join(process.cwd(), "decantr.essence.json");
+  const raw = await readFile(resolvedPath, "utf-8");
+  const essence = JSON.parse(raw);
+  return { essence, raw, path: resolvedPath };
+}
+async function writeEssenceFile(essencePath, essence) {
+  const dir = dirname(essencePath);
+  await mkdir(dir, { recursive: true });
+  await writeFile(essencePath, JSON.stringify(essence, null, 2) + "\n", "utf-8");
+}
+async function mutateEssenceFile(essencePath, mutate) {
+  const { essence, path } = await readEssenceFile(essencePath);
+  const v3 = isV3(essence) ? structuredClone(essence) : migrateV2ToV3(essence);
+  const updated = mutate(v3);
+  await writeEssenceFile(path, updated);
+  return { essence: updated, path };
+}
+async function readDriftLog(projectRoot) {
+  const root = projectRoot || process.cwd();
+  const logPath = join(root, ".decantr", "drift-log.json");
+  try {
+    const raw = await readFile(logPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+async function writeDriftLog(entries, projectRoot) {
+  const root = projectRoot || process.cwd();
+  const logPath = join(root, ".decantr", "drift-log.json");
+  await mkdir(dirname(logPath), { recursive: true });
+  await writeFile(logPath, JSON.stringify(entries, null, 2) + "\n", "utf-8");
+  return logPath;
+}
+
+// src/component-manifest.ts
+var COMPONENT_MANIFEST = {
+  // ─── Original Components ───────────────────────────────────────
+  Button: {
+    name: "Button",
+    category: "original",
+    description: "Primary action button with variants, sizes, loading state, and icon support.",
+    props: [
+      { name: "variant", type: "'default' | 'primary' | 'secondary' | 'tertiary' | 'destructive' | 'success' | 'warning' | 'outline' | 'ghost' | 'link'", required: false, default: "'default'", description: "Visual style variant." },
+      { name: "size", type: "'xs' | 'sm' | 'default' | 'lg' | 'icon' | 'icon-xs' | 'icon-sm' | 'icon-lg'", required: false, default: "'default'", description: "Button size." },
+      { name: "disabled", type: "boolean | (() => boolean)", required: false, description: "Disable the button. Accepts a signal for reactive state." },
+      { name: "loading", type: "boolean | (() => boolean)", required: false, description: "Show loading spinner overlay and disable the button." },
+      { name: "block", type: "boolean", required: false, description: "Full-width button (display: block)." },
+      { name: "rounded", type: "boolean", required: false, description: "Fully rounded pill shape." },
+      { name: "iconLeft", type: "string | Node", required: false, description: "Leading icon. String = icon name, Node = custom element." },
+      { name: "iconRight", type: "string | Node", required: false, description: "Trailing icon. String = icon name, Node = custom element." },
+      { name: "onclick", type: "(e: MouseEvent) => void", required: false, description: "Click handler." },
+      { name: "type", type: "'button' | 'submit' | 'reset'", required: false, default: "'button'", description: "HTML button type attribute." },
+      { name: "class", type: "string", required: false, description: "Additional CSS class." }
+    ],
+    usage: `import { Button } from '@decantr/ui';
+
+// Basic
+Button({ variant: 'primary' }, 'Save')
+
+// With icons
+Button({ variant: 'outline', iconLeft: 'plus' }, 'Add Item')
+
+// Loading state (reactive)
+const [loading, setLoading] = createSignal(false);
+Button({ variant: 'primary', loading, onclick: () => setLoading(true) }, 'Submit')
+
+// Button group
+Button.Group({},
+  Button({ variant: 'outline' }, 'Left'),
+  Button({ variant: 'outline' }, 'Center'),
+  Button({ variant: 'outline' }, 'Right'),
+)`,
+    subComponents: ["Button.Group"],
+    relatedComponents: ["Spinner", "Dropdown"]
+  },
+  Card: {
+    name: "Card",
+    category: "original",
+    description: "Container with optional title, header, footer, cover image, actions, and loading skeleton.",
+    props: [
+      { name: "title", type: "string | Node", required: false, description: "Card title \u2014 auto-creates a Card.Header." },
+      { name: "extra", type: "Node | Function", required: false, description: "Top-right header content (e.g., action link)." },
+      { name: "hoverable", type: "boolean", required: false, description: "Add hover elevation effect." },
+      { name: "bordered", type: "boolean", required: false, default: "true", description: "Show border. Set false for borderless." },
+      { name: "loading", type: "boolean | (() => boolean)", required: false, description: "Show skeleton loading placeholder." },
+      { name: "size", type: "'default' | 'sm'", required: false, default: "'default'", description: "Card size variant." },
+      { name: "type", type: "'inner'", required: false, description: "Inner card variant for nesting." },
+      { name: "cover", type: "Node", required: false, description: "Cover image shorthand \u2014 wraps in Card.Cover." },
+      { name: "actions", type: "Node[]", required: false, description: "Bottom action bar items \u2014 wraps in Card.Actions." },
+      { name: "class", type: "string", required: false, description: "Additional CSS class." }
+    ],
+    usage: `import { Card } from '@decantr/ui';
+
+// Simple card
+Card({ title: 'My Card' }, 'Card content here.')
+
+// With shorthand props
+Card({
+  title: 'Product',
+  extra: Button({ variant: 'link' }, 'Edit'),
+  cover: h('img', { src: '/photo.jpg', alt: 'Product' }),
+  actions: [Button({}, 'Buy'), Button({ variant: 'ghost' }, 'Share')],
+}, 'Description text.')
+
+// Compound (explicit sections)
+Card({ hoverable: true },
+  Card.Header({}, 'Custom Header'),
+  Card.Body({}, 'Body content'),
+  Card.Meta({ avatar: Avatar({ src: '/me.jpg' }), title: 'Name', description: 'Role' }),
+  Card.Footer({}, 'Footer'),
+)`,
+    subComponents: ["Card.Header", "Card.Body", "Card.Footer", "Card.Cover", "Card.Meta", "Card.Grid", "Card.Actions"],
+    relatedComponents: ["Skeleton", "Avatar"]
+  },
+  Modal: {
+    name: "Modal",
+    category: "original",
+    description: "Dialog overlay with focus trap, backdrop click-to-close, and animated open/close transitions.",
+    props: [
+      { name: "title", type: "string", required: false, description: "Modal title \u2014 auto-creates header with close button." },
+      { name: "footer", type: "Node | Node[]", required: false, description: "Footer content (e.g., action buttons)." },
+      { name: "visible", type: "() => boolean", required: true, description: "Signal getter controlling visibility. MUST be a signal function." },
+      { name: "onClose", type: "() => void", required: false, description: "Called when modal is closed (via close button, backdrop, or Escape)." },
+      { name: "width", type: "string", required: false, default: "'480px'", description: "CSS width of the modal panel." },
+      { name: "class", type: "string", required: false, description: "Additional CSS class." }
+    ],
+    usage: `import { Modal, Button } from '@decantr/ui';
+import { createSignal } from '@decantr/ui/state';
+
+const [open, setOpen] = createSignal(false);
+
+Button({ onclick: () => setOpen(true) }, 'Open Modal')
+
+Modal({
+  title: 'Confirm Action',
+  visible: open,
+  onClose: () => setOpen(false),
+  footer: [
+    Button({ variant: 'ghost', onclick: () => setOpen(false) }, 'Cancel'),
+    Button({ variant: 'primary', onclick: handleConfirm }, 'Confirm'),
+  ],
+}, 'Are you sure you want to proceed?')`,
+    subComponents: ["Modal.Header", "Modal.Body", "Modal.Footer"],
+    relatedComponents: ["Drawer", "AlertDialog", "Button"]
+  },
+  Tabs: {
+    name: "Tabs",
+    category: "original",
+    description: "Tabbed interface with roving tabindex keyboard navigation and sliding indicator.",
+    props: [
+      { name: "tabs", type: "Array<{ id: string, label: string, content?: () => Node, disabled?: boolean, closable?: boolean }>", required: true, description: "Tab definitions. content is a render function called lazily." },
+      { name: "active", type: "string | (() => string)", required: false, description: "Active tab ID. Use a signal for controlled mode." },
+      { name: "onchange", type: "(tabId: string) => void", required: false, description: "Called when active tab changes." },
+      { name: "onclose", type: "(tabId: string) => void", required: false, description: "Called when a closable tab is closed." },
+      { name: "orientation", type: "'horizontal' | 'vertical'", required: false, default: "'horizontal'", description: "Tab list orientation." },
+      { name: "size", type: "'sm' | 'lg'", required: false, description: "Tab size." },
+      { name: "disabled", type: "boolean | (() => boolean)", required: false, description: "Disable all tabs." },
+      { name: "destroyInactive", type: "boolean", required: false, default: "true", description: "When false, all panels stay in DOM (hidden). When true, only active panel is rendered." },
+      { name: "class", type: "string", required: false, description: "Additional CSS class." }
+    ],
+    usage: `import { Tabs } from '@decantr/ui';
+
+Tabs({
+  tabs: [
+    { id: 'overview', label: 'Overview', content: () => h('div', {}, 'Overview content') },
+    { id: 'details', label: 'Details', content: () => h('div', {}, 'Details content') },
+    { id: 'settings', label: 'Settings', content: () => h('div', {}, 'Settings content') },
+  ],
+  active: 'overview',
+  onchange: (id) => console.log('Tab changed:', id),
+})`,
+    relatedComponents: ["Accordion", "Segmented"]
+  },
+  Table: {
+    name: "Table",
+    category: "original",
+    description: "Simple static data table. For sorting, pagination, and selection, use DataTable instead.",
+    props: [
+      { name: "columns", type: "Array<{ key: string, label: string, width?: string, render?: (value, row) => Node | string }>", required: true, description: "Column definitions." },
+      { name: "data", type: "Object[]", required: true, description: "Row data array." },
+      { name: "striped", type: "boolean", required: false, description: "Striped row backgrounds." },
+      { name: "hoverable", type: "boolean", required: false, description: "Row hover highlight." },
+      { name: "compact", type: "boolean", required: false, description: "Compact row padding." },
+      { name: "class", type: "string", required: false, description: "Additional CSS class." }
+    ],
+    usage: `import { Table } from '@decantr/ui';
+
+Table({
+  columns: [
+    { key: 'name', label: 'Name' },
+    { key: 'email', label: 'Email' },
+    { key: 'role', label: 'Role', render: (val) => Badge({ variant: 'info' }, val) },
+  ],
+  data: [
+    { name: 'Alice', email: 'alice@example.com', role: 'Admin' },
+    { name: 'Bob', email: 'bob@example.com', role: 'User' },
+  ],
+  striped: true,
+  hoverable: true,
+})`,
+    relatedComponents: ["DataTable", "Pagination"]
+  },
+  Input: {
+    name: "Input",
+    category: "original",
+    description: "Text input with prefix/suffix slots, validation states, reactive value, and built-in form field wrapping.",
+    props: [
+      { name: "type", type: "string", required: false, default: "'text'", description: "HTML input type (text, password, email, etc.)." },
+      { name: "placeholder", type: "string", required: false, description: "Placeholder text." },
+      { name: "value", type: "string | (() => string)", required: false, description: "Input value. Use a signal for two-way binding." },
+      { name: "disabled", type: "boolean | (() => boolean)", required: false, description: "Disable the input." },
+      { name: "readonly", type: "boolean | (() => boolean)", required: false, description: "Make input read-only." },
+      { name: "prefix", type: "string | Node", required: false, description: 'Leading content inside the input (e.g., icon, "$").' },
+      { name: "suffix", type: "string | Node", required: false, description: "Trailing content inside the input (e.g., icon, unit)." },
+      { name: "error", type: "boolean | string | (() => boolean | string)", required: false, description: "Error state. String shows as message." },
+      { name: "success", type: "boolean | string | (() => boolean | string)", required: false, description: "Success state." },
+      { name: "loading", type: "boolean | (() => boolean)", required: false, description: "Loading indicator." },
+      { name: "variant", type: "'outlined' | 'filled' | 'ghost'", required: false, default: "'outlined'", description: "Visual style variant." },
+      { name: "size", type: "'xs' | 'sm' | 'lg'", required: false, description: "Input size." },
+      { name: "label", type: "string", required: false, description: "Form field label. When set, auto-wraps in a form field." },
+      { name: "help", type: "string", required: false, description: "Help text below the input." },
+      { name: "required", type: "boolean", required: false, description: "Mark as required (adds aria-required)." },
+      { name: "oninput", type: "(e: Event) => void", required: false, description: "Fires on every keystroke." },
+      { name: "onchange", type: "(value: string) => void", required: false, description: "Fires on blur/commit." },
+      { name: "ref", type: "(el: HTMLInputElement) => void", required: false, description: "Callback with the raw input element." },
+      { name: "class", type: "string", required: false, description: "Additional CSS class." }
+    ],
+    usage: `import { Input } from '@decantr/ui';
+import { createSignal } from '@decantr/ui/state';
+
+// Simple
+Input({ placeholder: 'Enter your name' })
+
+// With label and validation
+const [email, setEmail] = createSignal('');
+Input({
+  type: 'email',
+  label: 'Email Address',
+  placeholder: 'you@example.com',
+  value: email,
+  oninput: (e) => setEmail(e.target.value),
+  error: () => email() && !email().includes('@') ? 'Invalid email' : false,
+  help: 'We will never share your email.',
+  required: true,
+})
+
+// With prefix/suffix
+Input({ prefix: '$', suffix: '.00', placeholder: '0' })`,
+    relatedComponents: ["Textarea", "Select", "InputNumber", "InputGroup", "Form"]
+  },
+  Textarea: {
+    name: "Textarea",
+    category: "original",
+    description: "Multi-line text input with resizing, validation states, and form field wrapping.",
+    props: [
+      { name: "placeholder", type: "string", required: false, description: "Placeholder text." },
+      { name: "value", type: "string | (() => string)", required: false, description: "Textarea value. Signal for reactive binding." },
+      { name: "disabled", type: "boolean | (() => boolean)", required: false, description: "Disable the textarea." },
+      { name: "readonly", type: "boolean | (() => boolean)", required: false, description: "Make read-only." },
+      { name: "error", type: "boolean | string | (() => boolean | string)", required: false, description: "Error state." },
+      { name: "success", type: "boolean | string | (() => boolean | string)", required: false, description: "Success state." },
+      { name: "variant", type: "'outlined' | 'filled' | 'ghost'", required: false, default: "'outlined'", description: "Visual style." },
+      { name: "size", type: "'xs' | 'sm' | 'lg'", required: false, description: "Textarea size." },
+      { name: "rows", type: "number", required: false, default: "3", description: "Visible rows." },
+      { name: "resize", type: "'none' | 'vertical' | 'horizontal' | 'both'", required: false, default: "'vertical'", description: "Resize behavior." },
+      { name: "label", type: "string", required: false, description: "Form field label." },
+      { name: "help", type: "string", required: false, description: "Help text below." },
+      { name: "required", type: "boolean", required: false, description: "Mark as required." },
+      { name: "oninput", type: "(e: Event) => void", required: false, description: "Input handler." },
+      { name: "ref", type: "(el: HTMLTextAreaElement) => void", required: false, description: "Callback with the raw textarea element." },
+      { name: "class", type: "string", required: false, description: "Additional CSS class." }
+    ],
+    usage: `import { Textarea } from '@decantr/ui';
+
+Textarea({
+  label: 'Description',
+  placeholder: 'Tell us about your project...',
+  rows: 5,
+  help: 'Markdown supported.',
+})`,
+    relatedComponents: ["Input", "Form"]
+  },
+  Select: {
+    name: "Select",
+    category: "original",
+    description: "Custom dropdown select with keyboard navigation, search, and form field support.",
+    props: [
+      { name: "options", type: "Array<{ value: string, label: string, disabled?: boolean }>", required: true, description: "Option list." },
+      { name: "value", type: "string | (() => string)", required: false, description: "Selected value. Signal for controlled mode." },
+      { name: "placeholder", type: "string", required: false, description: "Placeholder text when no value selected." },
+      { name: "disabled", type: "boolean | (() => boolean)", required: false, description: "Disable the select." },
+      { name: "error", type: "boolean | string | (() => boolean | string)", required: false, description: "Error state." },
+      { name: "success", type: "boolean | string | (() => boolean | string)", required: false, description: "Success state." },
+      { name: "variant", type: "'outlined' | 'filled' | 'ghost'", required: false, default: "'outlined'", description: "Visual style." },
+      { name: "size", type: "'xs' | 'sm' | 'lg'", required: false, description: "Select size." },
+      { name: "label", type: "string", required: false, description: "Form field label." },
+      { name: "help", type: "string", required: false, description: "Help text." },
+      { name: "required", type: "boolean", required: false, description: "Mark as required." },
+      { name: "onchange", type: "(value: string) => void", required: false, description: "Called when selection changes." },
+      { name: "class", type: "string", required: false, description: "Additional CSS class." }
+    ],
+    usage: `import { Select } from '@decantr/ui';
+
+Select({
+  label: 'Country',
+  placeholder: 'Choose a country',
+  options: [
+    { value: 'us', label: 'United States' },
+    { value: 'uk', label: 'United Kingdom' },
+    { value: 'de', label: 'Germany', disabled: true },
+  ],
+  onchange: (val) => console.log('Selected:', val),
+})`,
+    relatedComponents: ["Combobox", "Cascader", "TreeSelect", "Input"]
+  },
+  Checkbox: {
+    name: "Checkbox",
+    category: "original",
+    description: "Checkbox input with label, indeterminate state, and validation support.",
+    props: [
+      { name: "checked", type: "boolean | (() => boolean)", required: false, description: "Checked state. Signal for reactive binding." },
+      { name: "disabled", type: "boolean | (() => boolean)", required: false, description: "Disable the checkbox." },
+      { name: "label", type: "string", required: false, description: "Label text next to the checkbox." },
+      { name: "indeterminate", type: "boolean", required: false, description: 'Indeterminate (dash) state for "select all" patterns.' },
+      { name: "error", type: "boolean | string | (() => boolean | string)", required: false, description: "Error state." },
+      { name: "success", type: "boolean | string | (() => boolean | string)", required: false, description: "Success state." },
+      { name: "help", type: "string", required: false, description: "Help text (wraps in form field)." },
+      { name: "required", type: "boolean", required: false, description: "Mark as required." },
+      { name: "size", type: "'xs' | 'sm' | 'lg'", required: false, description: "Checkbox size." },
+      { name: "onchange", type: "(checked: boolean) => void", required: false, description: "Called when checked state changes." },
+      { name: "class", type: "string", required: false, description: "Additional CSS class." }
+    ],
+    usage: `import { Checkbox } from '@decantr/ui';
+import { createSignal } from '@decantr/ui/state';
+
+const [agreed, setAgreed] = createSignal(false);
+
+Checkbox({
+  checked: agreed,
+  onchange: setAgreed,
+  label: 'I agree to the terms and conditions',
+  required: true,
+})`,
+    relatedComponents: ["Switch", "RadioGroup", "Form"]
+  },
+  Switch: {
+    name: "Switch",
+    category: "original",
+    description: 'Toggle switch with accessible role="switch" and ARIA attributes.',
+    props: [
+      { name: "checked", type: "boolean | (() => boolean)", required: false, description: "On/off state. Signal for reactive binding." },
+      { name: "disabled", type: "boolean | (() => boolean)", required: false, description: "Disable the switch." },
+      { name: "label", type: "string", required: false, description: "Label text." },
+      { name: "error", type: "boolean | string | (() => boolean | string)", required: false, description: "Error state." },
+      { name: "size", type: "'xs' | 'sm' | 'lg'", required: false, description: "Switch size." },
+      { name: "name", type: "string", required: false, description: "Form field name." },
+      { name: "required", type: "boolean", required: false, description: "Mark as required." },
+      { name: "onchange", type: "(checked: boolean) => void", required: false, description: "Called when toggled." },
+      { name: "ref", type: "(el: HTMLInputElement) => void", required: false, description: "Callback with the raw input element." },
+      { name: "class", type: "string", required: false, description: "Additional CSS class." }
+    ],
+    usage: `import { Switch } from '@decantr/ui';
+import { createSignal } from '@decantr/ui/state';
+
+const [dark, setDark] = createSignal(false);
+
+Switch({
+  checked: dark,
+  onchange: setDark,
+  label: 'Dark mode',
+})`,
+    relatedComponents: ["Checkbox", "Toggle"]
+  },
+  Badge: {
+    name: "Badge",
+    category: "original",
+    description: "Status indicator pill, dot indicator, or superscript count badge.",
+    props: [
+      { name: "count", type: "number | (() => number)", required: false, description: "Numeric count to display." },
+      { name: "color", type: "string", required: false, description: "CSS color override." },
+      { name: "dot", type: "boolean", required: false, description: "Show as dot instead of pill." },
+      { name: "status", type: "'success' | 'error' | 'warning' | 'info' | 'processing' | 'primary'", required: false, description: "Semantic status color." },
+      { name: "variant", type: "string", required: false, description: "Alias for status." },
+      { name: "solid", type: "boolean", required: false, description: "Use saturated/solid colors instead of subtle." },
+      { name: "icon", type: "string | Node", required: false, description: "Leading icon." },
+      { name: "class", type: "string", required: false, description: "Additional CSS class." }
+    ],
+    usage: `import { Badge } from '@decantr/ui';
+
+// Label badge
+Badge({ variant: 'success' }, 'Active')
+
+// Count superscript on another element
+Badge({ count: 5 }, icon('bell', { size: '1.5em' }))
+
+// Status dot
+Badge({ dot: true, status: 'processing' })`,
+    relatedComponents: ["Chip", "Tag", "Alert"]
+  },
+  Alert: {
+    name: "Alert",
+    category: "original",
+    description: "Inline alert banner with icon, dismissible option, and semantic variants.",
+    props: [
+      { name: "variant", type: "'info' | 'success' | 'warning' | 'error'", required: false, default: "'info'", description: "Semantic variant." },
+      { name: "dismissible", type: "boolean", required: false, description: "Show close button. Removes from DOM on dismiss." },
+      { name: "onDismiss", type: "() => void", required: false, description: "Called when dismissed." },
+      { name: "icon", type: "string | Node", required: false, description: "Leading icon." },
+      { name: "class", type: "string", required: false, description: "Additional CSS class." }
+    ],
+    usage: `import { Alert } from '@decantr/ui';
+
+Alert({ variant: 'warning', dismissible: true },
+  'Your session will expire in 5 minutes.'
+)
+
+Alert({ variant: 'error', icon: 'alert-circle' },
+  'Failed to save changes. Please try again.'
+)`,
+    relatedComponents: ["AlertDialog", "Banner", "notification", "message"]
+  },
+  Accordion: {
+    name: "Accordion",
+    category: "original",
+    description: "Collapsible content panels with animated open/close, keyboard navigation, and single/multiple mode.",
+    props: [
+      { name: "items", type: "Array<{ id: string, title: string, content: (() => Node) | string, disabled?: boolean }>", required: true, description: "Accordion item definitions. content is lazy-rendered." },
+      { name: "multiple", type: "boolean", required: false, default: "false", description: "Allow multiple panels open simultaneously." },
+      { name: "collapsible", type: "boolean", required: false, default: "true", description: "Allow collapsing the last open panel (single mode)." },
+      { name: "defaultOpen", type: "string[]", required: false, description: "Array of item IDs to open initially." },
+      { name: "disabled", type: "boolean | (() => boolean)", required: false, description: "Disable all items or per-item via callback." },
+      { name: "onValueChange", type: "(openIds: string[]) => void", required: false, description: "Called when open panels change." },
+      { name: "class", type: "string", required: false, description: "Additional CSS class." }
+    ],
+    usage: `import { Accordion } from '@decantr/ui';
+
+Accordion({
+  items: [
+    { id: 'faq1', title: 'What is Decantr?', content: () => h('p', {}, 'A Design Intelligence API.') },
+    { id: 'faq2', title: 'How does it work?', content: () => h('p', {}, 'Through the Design Pipeline.') },
+    { id: 'faq3', title: 'Is it free?', content: 'Community tier is free.' },
+  ],
+  defaultOpen: ['faq1'],
+})`,
+    relatedComponents: ["Collapsible", "Tabs"]
+  },
+  Dropdown: {
+    name: "Dropdown",
+    category: "original",
+    description: "Menu triggered by a button with keyboard navigation, separators, icons, and shortcuts.",
+    props: [
+      { name: "trigger", type: "() => HTMLElement", required: false, description: 'Function returning the trigger element. Defaults to a "Menu" button.' },
+      { name: "items", type: "Array<{ label: string, value?: string, icon?: string | Node, shortcut?: string, disabled?: boolean, separator?: boolean, onclick?: () => void }>", required: true, description: "Menu items. Set separator: true for dividers." },
+      { name: "align", type: "'left' | 'right'", required: false, default: "'left'", description: "Dropdown alignment." },
+      { name: "block", type: "boolean", required: false, description: "Full-width trigger." },
+      { name: "class", type: "string", required: false, description: "Additional CSS class." }
+    ],
+    usage: `import { Dropdown, Button } from '@decantr/ui';
+
+Dropdown({
+  trigger: () => Button({ variant: 'outline', iconRight: 'chevron-down' }, 'Actions'),
+  items: [
+    { label: 'Edit', icon: 'pencil', onclick: handleEdit },
+    { label: 'Duplicate', icon: 'copy', shortcut: 'Ctrl+D' },
+    { separator: true },
+    { label: 'Delete', icon: 'trash', onclick: handleDelete },
+  ],
+})`,
+    relatedComponents: ["ContextMenu", "Menu", "Popover"]
+  },
+  Drawer: {
+    name: "Drawer",
+    category: "original",
+    description: "Slide-over panel from any edge with focus trap, animated transitions, and compound sections.",
+    props: [
+      { name: "visible", type: "() => boolean", required: true, description: "Signal getter controlling visibility. MUST be a signal function." },
+      { name: "onClose", type: "() => void", required: false, description: "Called when drawer is closed." },
+      { name: "side", type: "'left' | 'right' | 'top' | 'bottom'", required: false, default: "'right'", description: "Edge to slide from." },
+      { name: "title", type: "string", required: false, description: "Drawer title \u2014 auto-creates header with close button." },
+      { name: "footer", type: "Node | Node[]", required: false, description: "Footer content." },
+      { name: "size", type: "string", required: false, default: "'320px'", description: "CSS width (left/right) or height (top/bottom)." },
+      { name: "closeOnOutside", type: "boolean", required: false, default: "true", description: "Close when clicking outside the panel." },
+      { name: "class", type: "string", required: false, description: "Additional CSS class." }
+    ],
+    usage: `import { Drawer, Button } from '@decantr/ui';
+import { createSignal } from '@decantr/ui/state';
+
+const [open, setOpen] = createSignal(false);
+
+Button({ onclick: () => setOpen(true) }, 'Open Drawer')
+
+Drawer({
+  title: 'Settings',
+  visible: open,
+  onClose: () => setOpen(false),
+  side: 'right',
+  size: '400px',
+}, 'Drawer content here.')`,
+    subComponents: ["Drawer.Header", "Drawer.Body", "Drawer.Footer"],
+    relatedComponents: ["Modal", "AlertDialog"]
+  },
+  Pagination: {
+    name: "Pagination",
+    category: "original",
+    description: "Page navigation with prev/next, page numbers, ellipsis, and reactive signals.",
+    props: [
+      { name: "total", type: "number | (() => number)", required: true, description: "Total number of items." },
+      { name: "perPage", type: "number", required: false, default: "10", description: "Items per page." },
+      { name: "current", type: "number | (() => number)", required: false, default: "1", description: "Current page. Signal for controlled mode." },
+      { name: "onchange", type: "(page: number) => void", required: false, description: "Called when page changes." },
+      { name: "siblings", type: "number", required: false, default: "1", description: "Number of page buttons shown around current page." },
+      { name: "size", type: "'sm' | 'lg'", required: false, description: "Pagination size." },
+      { name: "class", type: "string", required: false, description: "Additional CSS class." }
+    ],
+    usage: `import { Pagination } from '@decantr/ui';
+import { createSignal } from '@decantr/ui/state';
+
+const [page, setPage] = createSignal(1);
+
+Pagination({
+  total: 200,
+  perPage: 10,
+  current: page,
+  onchange: setPage,
+})`,
+    relatedComponents: ["Table", "DataTable"]
+  },
+  Tooltip: {
+    name: "Tooltip",
+    category: "original",
+    description: "Informational popup on hover or focus with configurable position and delay.",
+    props: [
+      { name: "content", type: "string", required: true, description: "Tooltip text content." },
+      { name: "position", type: "'top' | 'bottom' | 'left' | 'right'", required: false, default: "'top'", description: "Tooltip position relative to the trigger." },
+      { name: "delay", type: "number", required: false, default: "200", description: "Show delay in milliseconds." },
+      { name: "class", type: "string", required: false, description: "Additional CSS class." }
+    ],
+    usage: `import { Tooltip, Button } from '@decantr/ui';
+
+Tooltip({ content: 'Save your changes', position: 'bottom' },
+  Button({ variant: 'primary' }, 'Save')
+)`,
+    relatedComponents: ["Popover", "HoverCard"]
+  },
+  Progress: {
+    name: "Progress",
+    category: "original",
+    description: "Progress bar with percentage, variants, striped/animated styles, and label support.",
+    props: [
+      { name: "value", type: "number | (() => number)", required: false, description: "Current value (0 to max). Signal for reactive updates." },
+      { name: "max", type: "number", required: false, default: "100", description: "Maximum value." },
+      { name: "label", type: "string", required: false, description: "Label text (displayed inside bar for md/lg, outside for other sizes)." },
+      { name: "variant", type: "'primary' | 'success' | 'warning' | 'error'", required: false, description: "Color variant." },
+      { name: "size", type: "'sm' | 'md' | 'lg'", required: false, description: "Bar height." },
+      { name: "striped", type: "boolean", required: false, description: "Add striped pattern." },
+      { name: "animated", type: "boolean", required: false, description: "Animate the stripes." },
+      { name: "class", type: "string", required: false, description: "Additional CSS class." }
+    ],
+    usage: `import { Progress } from '@decantr/ui';
+import { createSignal } from '@decantr/ui/state';
+
+const [progress, setProgress] = createSignal(45);
+
+Progress({
+  value: progress,
+  variant: 'primary',
+  size: 'md',
+  label: '45%',
+  striped: true,
+  animated: true,
+})`,
+    relatedComponents: ["Spinner", "Statistic"]
+  },
+  Spinner: {
+    name: "Spinner",
+    category: "original",
+    description: "Loading indicator with multiple animation variants: ring, dots, pulse, bars, orbit.",
+    props: [
+      { name: "variant", type: "'ring' | 'dots' | 'pulse' | 'bars' | 'orbit'", required: false, default: "'ring'", description: "Animation style." },
+      { name: "size", type: "'xs' | 'sm' | 'lg' | 'xl'", required: false, description: "Spinner size." },
+      { name: "color", type: "'primary' | 'success' | 'warning' | 'destructive' | 'info' | 'muted'", required: false, description: "Semantic color." },
+      { name: "icon", type: "string", required: false, description: "Icon name for hybrid mode (ring spins around static center icon)." },
+      { name: "label", type: "string", required: false, default: "'Loading'", description: "Accessible label (screen reader text)." },
+      { name: "class", type: "string", required: false, description: "Additional CSS class." }
+    ],
+    usage: `import { Spinner } from '@decantr/ui';
+
+// Default ring spinner
+Spinner({ size: 'lg', color: 'primary' })
+
+// Dots variant
+Spinner({ variant: 'dots', size: 'sm' })
+
+// Hybrid: ring around an icon
+Spinner({ icon: 'cloud', size: 'xl' })`,
+    relatedComponents: ["Progress", "Button"]
+  },
+  // ─── Data Display ──────────────────────────────────────────────
+  DataTable: {
+    name: "DataTable",
+    category: "data-display",
+    description: "Enterprise data grid with sorting, pagination, multi-selection, column pinning, cell editing, row expansion, filtering, CSV export, virtual scrolling, and column resizing.",
+    props: [
+      { name: "columns", type: "Array<{ key: string, label: string, width?: string, sortable?: boolean, filterable?: boolean, pinned?: 'left' | 'right', render?: (val, row) => Node, editable?: boolean, align?: 'left' | 'center' | 'right', sort?: (a, b) => number }>", required: true, description: "Column definitions with sorting, filtering, pinning, and cell editing options." },
+      { name: "data", type: "Array<Object> | (() => Array<Object>)", required: true, description: "Row data. Signal for reactive updates." },
+      { name: "pagination", type: "{ pageSize?: number, serverSide?: boolean, total?: number | (() => number), onPageChange?: ({page, pageSize}) => void }", required: false, description: "Enable pagination. Supports client-side and server-side modes." },
+      { name: "selection", type: "'single' | 'multi' | 'none'", required: false, default: "'none'", description: "Row selection mode." },
+      { name: "onSelectionChange", type: "(selectedRows: Object[]) => void", required: false, description: "Called when selection changes." },
+      { name: "striped", type: "boolean", required: false, default: "false", description: "Striped rows." },
+      { name: "hoverable", type: "boolean", required: false, default: "true", description: "Row hover highlight." },
+      { name: "stickyHeader", type: "boolean", required: false, default: "false", description: "Sticky table header on scroll." },
+      { name: "onSort", type: '({ key: string, direction: "asc" | "desc" }) => void', required: false, description: "Called when sort changes (for server-side sorting)." },
+      { name: "rowKey", type: "(row: Object, index: number) => string | number", required: false, description: "Unique key extractor for each row. Defaults to index." },
+      { name: "onCellEdit", type: "({ row, column, value, oldValue }) => void", required: false, description: "Called when an editable cell is committed." },
+      { name: "expandable", type: "boolean", required: false, default: "false", description: "Enable row expansion." },
+      { name: "expandRender", type: "(row: Object) => Node | string", required: false, description: "Render function for expanded row content." },
+      { name: "exportable", type: "boolean", required: false, default: "false", description: 'Show "Export CSV" button.' },
+      { name: "emptyText", type: "string", required: false, default: "'No data'", description: "Text shown when data is empty." },
+      { name: "class", type: "string", required: false, description: "Additional CSS class." }
+    ],
+    usage: `import { DataTable } from '@decantr/ui';
+
+DataTable({
+  columns: [
+    { key: 'name', label: 'Name', sortable: true, filterable: true },
+    { key: 'email', label: 'Email', sortable: true },
+    { key: 'role', label: 'Role', render: (val) => Badge({ variant: val === 'admin' ? 'primary' : 'info' }, val) },
+    { key: 'status', label: 'Status', pinned: 'right' },
+  ],
+  data: users,
+  pagination: { pageSize: 20 },
+  selection: 'multi',
+  onSelectionChange: (rows) => console.log('Selected:', rows),
+  striped: true,
+  stickyHeader: true,
+  exportable: true,
+})`,
+    relatedComponents: ["Table", "Pagination", "Checkbox"]
+  },
+  // ─── Composition API ───────────────────────────────────────────
+  compose: {
+    name: "compose",
+    category: "utility",
+    description: "Render a single pattern by ID using the current DNA context. Must be called inside an EssenceProvider.",
+    props: [
+      { name: "patternId", type: "string", required: true, description: 'Pattern ID from the registry (e.g., "hero", "data-table", "kpi-grid").' },
+      { name: "options.props", type: "Record<string, unknown>", required: false, description: "Props to pass to the pattern renderer." },
+      { name: "options.preset", type: "string", required: false, description: "Preset name for the pattern." },
+      { name: "options.slots", type: "Record<string, () => HTMLElement>", required: false, description: "Named slot render functions." }
+    ],
+    usage: `import { compose } from '@decantr/ui/compose';
+
+// Inside an EssenceProvider:
+compose('hero', { props: { title: 'Welcome', subtitle: 'Get started' } })
+compose('data-table', { preset: 'product', props: { data: products } })`,
+    relatedComponents: ["composePage", "EssenceProvider"]
+  },
+  composePage: {
+    name: "composePage",
+    category: "utility",
+    description: "Render a full page from the essence blueprint. Finds the page by ID, resolves each pattern in the layout, and wraps in a shell.",
+    props: [
+      { name: "pageId", type: "string", required: true, description: 'Page ID from the blueprint (e.g., "landing", "dashboard").' }
+    ],
+    usage: `import { composePage } from '@decantr/ui/compose';
+
+// Inside an EssenceProvider:
+composePage('landing')
+composePage('dashboard')`,
+    relatedComponents: ["compose", "EssenceProvider", "EssenceApp"]
+  },
+  EssenceProvider: {
+    name: "EssenceProvider",
+    category: "utility",
+    description: "Context provider that makes the Essence spec (DNA tokens, guard settings) available to all descendant components and compose() calls.",
+    props: [
+      { name: "essence", type: "EssenceV3", required: false, description: "Full v3 essence spec object. If omitted, inherits from parent provider." },
+      { name: "overrides", type: "Partial<EssenceContextValue>", required: false, description: "Partial DNA overrides (style, mode, shape, density, etc.) for nested providers." }
+    ],
+    usage: `import { EssenceProvider } from '@decantr/ui/essence';
+import essence from './decantr.essence.json';
+
+EssenceProvider({ essence },
+  composePage('landing'),
+)
+
+// Nested override:
+EssenceProvider({ overrides: { mode: 'dark', density: 'compact' } },
+  compose('sidebar'),
+)`,
+    relatedComponents: ["EssenceApp", "compose", "composePage"]
+  },
+  EssenceApp: {
+    name: "EssenceApp",
+    category: "utility",
+    description: "Top-level convenience component that wraps children in an EssenceProvider. Use as the root of your app.",
+    props: [
+      { name: "essence", type: "EssenceV3", required: true, description: "Full v3 essence spec object." }
+    ],
+    usage: `import { EssenceApp } from '@decantr/ui/compose';
+import essence from './decantr.essence.json';
+
+document.body.appendChild(
+  EssenceApp({ essence },
+    composePage('landing'),
+  )
+);`,
+    relatedComponents: ["EssenceProvider", "compose", "composePage"]
+  }
+};
+var CATEGORIES = [...new Set(Object.values(COMPONENT_MANIFEST).map((c) => c.category))];
+function getComponentsByCategory(category) {
+  const entries = Object.values(COMPONENT_MANIFEST);
+  const filtered = category && category !== "all" ? entries.filter((c) => c.category === category) : entries;
+  const grouped = {};
+  for (const entry of filtered) {
+    if (!grouped[entry.category]) grouped[entry.category] = [];
+    grouped[entry.category].push(entry);
+  }
+  return grouped;
+}
+
+// src/tools.ts
+var ZONE_ORDER = ["public", "gateway", "primary", "auxiliary"];
+function deriveZones(inputs) {
+  const zoneMap = /* @__PURE__ */ new Map();
+  for (const input of inputs) {
+    const existing = zoneMap.get(input.role);
+    if (existing) {
+      existing.archetypes.push(input.archetypeId);
+      existing.features.push(...input.features);
+      existing.descriptions.push(input.description);
+    } else {
+      zoneMap.set(input.role, {
+        role: input.role,
+        archetypes: [input.archetypeId],
+        shell: input.shell,
+        features: [...input.features],
+        descriptions: [input.description]
+      });
+    }
+  }
+  for (const zone of zoneMap.values()) {
+    zone.features = [...new Set(zone.features)];
+  }
+  return ZONE_ORDER.filter((role) => zoneMap.has(role)).map((role) => zoneMap.get(role));
+}
+var GATEWAY_TRIGGER_MAP = {
+  auth: "authentication",
+  login: "authentication",
+  mfa: "authentication",
+  payment: "payment",
+  subscription: "payment",
+  checkout: "payment",
+  onboarding: "onboarding",
+  "setup-wizard": "onboarding",
+  welcome: "onboarding",
+  invite: "invitation",
+  "access-code": "invitation"
+};
+function resolveGatewayTrigger(features) {
+  for (const feature of features) {
+    const trigger = GATEWAY_TRIGGER_MAP[feature];
+    if (trigger) return trigger;
+  }
+  return "authentication";
+}
+function deriveTransitions(zones) {
+  const transitions = [];
+  const roles = new Set(zones.map((z) => z.role));
+  const gateway = zones.find((z) => z.role === "gateway");
+  const gatewayTrigger = gateway ? resolveGatewayTrigger(gateway.features) : "authentication";
+  const hasApp = roles.has("primary") || roles.has("auxiliary");
+  const hasGateway = roles.has("gateway");
+  const hasPublic = roles.has("public");
+  if (hasPublic && hasGateway) {
+    transitions.push({ from: "public", to: "gateway", type: "conversion", trigger: gatewayTrigger });
+  }
+  if (hasPublic && hasApp && !hasGateway) {
+    transitions.push({ from: "public", to: "app", type: "conversion", trigger: "navigation" });
+  }
+  if (hasGateway && hasApp) {
+    transitions.push({ from: "gateway", to: "app", type: "gate-pass", trigger: gatewayTrigger });
+    transitions.push({ from: "app", to: "gateway", type: "gate-return", trigger: gatewayTrigger });
+  }
+  if (hasApp && hasPublic) {
+    transitions.push({ from: "app", to: "public", type: "navigation", trigger: "external" });
+  }
+  return transitions;
+}
+var READ_ONLY = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false
+};
+var READ_ONLY_NETWORK = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: true
+};
+var WRITE_TOOL = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: false,
+  openWorldHint: false
+};
+var TOOLS = [
+  // 1. decantr_read_essence — local read
+  {
+    name: "decantr_read_essence",
+    title: "Read Essence",
+    description: "Read and return the current decantr.essence.json file from the working directory. For v3 files, optionally filter by layer (dna, blueprint, or full).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Optional path to essence file. Defaults to ./decantr.essence.json." },
+        layer: { type: "string", enum: ["dna", "blueprint", "full"], description: "For v3 essences: return only the specified layer. Defaults to full." }
+      }
+    },
+    annotations: READ_ONLY
+  },
+  // 2. decantr_validate — local read
+  {
+    name: "decantr_validate",
+    title: "Validate Essence",
+    description: "Validate a decantr.essence.json file against the schema and guard rules. For v3, reports DNA vs Blueprint violations separately.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path to essence file. Defaults to ./decantr.essence.json." }
+      }
+    },
+    annotations: READ_ONLY
+  },
+  // 3. decantr_search_registry — network
+  {
+    name: "decantr_search_registry",
+    title: "Search Registry",
+    description: "Search the Decantr community content registry for patterns, archetypes, recipes, and styles.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: 'Search query (e.g. "kanban", "neon", "dashboard")' },
+        type: { type: "string", description: "Filter by type: pattern, archetype, recipe, style" }
+      },
+      required: ["query"]
+    },
+    annotations: READ_ONLY_NETWORK
+  },
+  // 4. decantr_resolve_pattern — network
+  {
+    name: "decantr_resolve_pattern",
+    title: "Resolve Pattern",
+    description: "Get full pattern details including layout spec, components, presets, and code examples.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: 'Pattern ID (e.g. "hero", "data-table", "kpi-grid")' },
+        preset: { type: "string", description: 'Optional preset name (e.g. "product", "content")' },
+        namespace: { type: "string", description: 'Namespace (default: "@official")' }
+      },
+      required: ["id"]
+    },
+    annotations: READ_ONLY_NETWORK
+  },
+  // 5. decantr_resolve_archetype — network
+  {
+    name: "decantr_resolve_archetype",
+    title: "Resolve Archetype",
+    description: "Get archetype details including default pages, layouts, features, and suggested theme.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: 'Archetype ID (e.g. "saas-dashboard", "ecommerce")' },
+        namespace: { type: "string", description: 'Namespace (default: "@official")' }
+      },
+      required: ["id"]
+    },
+    annotations: READ_ONLY_NETWORK
+  },
+  // 6. decantr_resolve_recipe — network
+  {
+    name: "decantr_resolve_recipe",
+    title: "Resolve Recipe",
+    description: "Get recipe visual treatment overrides, decoration rules, shell styles, spatial hints, visual effects, and pattern preferences.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: 'Recipe ID (e.g. "auradecantism")' },
+        namespace: { type: "string", description: 'Namespace (default: "@official")' }
+      },
+      required: ["id"]
+    },
+    annotations: READ_ONLY_NETWORK
+  },
+  // 7. decantr_resolve_blueprint — network
+  {
+    name: "decantr_resolve_blueprint",
+    title: "Resolve Blueprint",
+    description: "Get a blueprint (app composition) with its archetype list, suggested theme, personality traits, and full page structure.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: 'Blueprint ID (e.g. "saas-dashboard", "ecommerce", "portfolio")' },
+        namespace: { type: "string", description: 'Namespace (default: "@official")' }
+      },
+      required: ["id"]
+    },
+    annotations: READ_ONLY_NETWORK
+  },
+  // 8. decantr_suggest_patterns — network
+  {
+    name: "decantr_suggest_patterns",
+    title: "Suggest Patterns",
+    description: "Given a page description, suggest appropriate patterns from the registry. Returns ranked pattern matches with layout specs and component lists.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        description: { type: "string", description: 'Description of the page or section (e.g. "dashboard with metrics and charts", "settings form with toggles")' }
+      },
+      required: ["description"]
+    },
+    annotations: READ_ONLY_NETWORK
+  },
+  // 9. decantr_check_drift — local read
+  {
+    name: "decantr_check_drift",
+    title: "Check Drift",
+    description: "Check if code changes violate the design intent captured in the Essence spec. For v3, returns separate dna_violations and blueprint_drift with autoFixable flags.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path to essence file. Defaults to ./decantr.essence.json." },
+        page_id: { type: "string", description: 'Page ID being modified (e.g. "overview", "settings")' },
+        components_used: {
+          type: "array",
+          items: { type: "string" },
+          description: "List of component names used in the generated code. Checked against page layout patterns."
+        },
+        theme_used: { type: "string", description: "Theme/style name used in the generated code" }
+      }
+    },
+    annotations: READ_ONLY
+  },
+  // 10. decantr_create_essence — network (fetches archetype)
+  {
+    name: "decantr_create_essence",
+    title: "Create Essence",
+    description: "Generate a valid v3 Essence spec skeleton from a project description. Returns a structured essence.json template based on the closest matching archetype and blueprint.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        description: { type: "string", description: 'Natural language project description (e.g. "SaaS dashboard with analytics, user management, and billing")' },
+        framework: { type: "string", description: 'Target framework (e.g. "react", "vue", "svelte"). Defaults to "react".' }
+      },
+      required: ["description"]
+    },
+    annotations: READ_ONLY_NETWORK
+  },
+  // 11. decantr_accept_drift — WRITE tool (NEW)
+  {
+    name: "decantr_accept_drift",
+    title: "Accept Drift",
+    description: "Resolve guard violations by accepting, scoping, rejecting, or deferring drift. For DNA violations, requires explicit confirmation. Updates the essence file or drift log.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        violations: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              rule: { type: "string" },
+              page_id: { type: "string" },
+              details: { type: "string" }
+            },
+            required: ["rule"]
+          },
+          description: "The violations to resolve."
+        },
+        resolution: {
+          type: "string",
+          enum: ["accept", "accept_scoped", "reject", "defer"],
+          description: "How to resolve: accept updates the essence, accept_scoped limits to a page, reject is a no-op, defer logs for later."
+        },
+        scope: { type: "string", description: "For accept_scoped: the page or section scope." },
+        path: { type: "string", description: "Path to essence file. Defaults to ./decantr.essence.json." },
+        confirm_dna: { type: "boolean", description: "Required to be true when accepting DNA-layer violations." }
+      },
+      required: ["violations", "resolution"]
+    },
+    annotations: WRITE_TOOL
+  },
+  // 12. decantr_update_essence — WRITE tool (NEW)
+  {
+    name: "decantr_update_essence",
+    title: "Update Essence",
+    description: "Mutate the essence file: add/remove/update pages, update DNA or blueprint fields, add/remove features. Operates on v3 format (auto-migrates v2).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        operation: {
+          type: "string",
+          enum: ["add_page", "remove_page", "update_page_layout", "update_dna", "update_blueprint", "add_feature", "remove_feature"],
+          description: "The mutation operation to perform."
+        },
+        payload: {
+          type: "object",
+          description: "Operation-specific payload. See tool docs for each operation."
+        },
+        path: { type: "string", description: "Path to essence file. Defaults to ./decantr.essence.json." }
+      },
+      required: ["operation", "payload"]
+    },
+    annotations: WRITE_TOOL
+  },
+  // 13. decantr_get_section_context — local read
+  {
+    name: "decantr_get_section_context",
+    title: "Get Section Context",
+    description: "Get the self-contained context for a specific section of the project. Returns guard rules, theme tokens, visual treatments, recipe decorators, pattern specs, zone context, and pages \u2014 everything an AI needs to work on that section.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        section_id: { type: "string", description: 'Section ID (archetype ID, e.g., "ai-chatbot", "auth-full", "settings-full")' }
+      },
+      required: ["section_id"]
+    },
+    annotations: READ_ONLY
+  },
+  // 14. decantr_component_api — local read (static manifest)
+  {
+    name: "decantr_component_api",
+    title: "Component API",
+    description: 'Query the @decantr/ui component API. Pass a component name to get its full props, usage examples, and related components. Pass "list" to see all available components grouped by category.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        component: {
+          type: "string",
+          description: "Component name (e.g., 'Button', 'Modal', 'Card') or 'list' to see all available components."
+        },
+        category: {
+          type: "string",
+          description: "Filter by category when listing components.",
+          enum: ["original", "general", "layout", "navigation", "form", "data-display", "feedback", "media", "utility", "all"]
+        }
+      },
+      required: ["component"]
+    },
+    annotations: READ_ONLY
+  }
+];
+async function handleTool(name, args) {
+  const apiClient = getAPIClient();
+  switch (name) {
+    case "decantr_read_essence": {
+      const essencePath = args.path || join2(process.cwd(), "decantr.essence.json");
+      try {
+        const raw = await readFile2(essencePath, "utf-8");
+        const essence = JSON.parse(raw);
+        const layer = args.layer;
+        if (layer && isV32(essence)) {
+          if (layer === "dna") return essence.dna;
+          if (layer === "blueprint") return essence.blueprint;
+        }
+        return essence;
+      } catch (e) {
+        return { error: `Could not read essence file: ${e.message}` };
+      }
+    }
+    case "decantr_validate": {
+      const essencePath = args.path || join2(process.cwd(), "decantr.essence.json");
+      let essence;
+      try {
+        essence = JSON.parse(await readFile2(essencePath, "utf-8"));
+      } catch (e) {
+        return { valid: false, errors: [`Could not read: ${e.message}`], guardViolations: [] };
+      }
+      const result = validateEssence(essence);
+      let guardViolations = [];
+      if (result.valid && typeof essence === "object" && essence !== null) {
+        try {
+          guardViolations = evaluateGuard(essence, {});
+        } catch {
+        }
+      }
+      if (result.valid && typeof essence === "object" && essence !== null && isV32(essence)) {
+        const dnaViolations = guardViolations.filter((v) => v.layer === "dna");
+        const blueprintViolations = guardViolations.filter((v) => v.layer === "blueprint");
+        const otherViolations = guardViolations.filter((v) => !v.layer);
+        return {
+          ...result,
+          format: "v3",
+          dna_violations: dnaViolations,
+          blueprint_violations: blueprintViolations,
+          guardViolations: otherViolations
+        };
+      }
+      return { ...result, guardViolations };
+    }
+    case "decantr_search_registry": {
+      const err = validateStringArg(args, "query");
+      if (err) return { error: err };
+      try {
+        const response = await apiClient.search({
+          q: args.query,
+          type: args.type
+        });
+        return {
+          total: response.total,
+          results: response.results.map((r) => ({
+            type: r.type,
+            id: r.slug,
+            namespace: r.namespace,
+            name: r.name,
+            description: r.description,
+            install: `decantr get ${r.type} ${r.slug}`
+          }))
+        };
+      } catch (e) {
+        return { error: `Search failed: ${e.message}` };
+      }
+    }
+    case "decantr_resolve_pattern": {
+      const err = validateStringArg(args, "id");
+      if (err) return { error: err };
+      const namespace = args.namespace || "@official";
+      try {
+        const pattern = await apiClient.getPattern(namespace, args.id);
+        const result = { found: true, ...pattern };
+        if (args.preset && typeof args.preset === "string") {
+          const preset = resolvePatternPreset(pattern, args.preset);
+          if (preset) result.resolvedPreset = preset;
+        }
+        return result;
+      } catch {
+        return { found: false, message: `Pattern "${args.id}" not found in ${namespace}.` };
+      }
+    }
+    case "decantr_resolve_archetype": {
+      const err = validateStringArg(args, "id");
+      if (err) return { error: err };
+      const namespace = args.namespace || "@official";
+      try {
+        const archetype = await apiClient.getArchetype(namespace, args.id);
+        return { found: true, ...archetype };
+      } catch {
+        return { found: false, message: `Archetype "${args.id}" not found in ${namespace}.` };
+      }
+    }
+    case "decantr_resolve_recipe": {
+      const err = validateStringArg(args, "id");
+      if (err) return { error: err };
+      const namespace = args.namespace || "@official";
+      try {
+        const recipe = await apiClient.getRecipe(namespace, args.id);
+        return { found: true, ...recipe };
+      } catch {
+        return { found: false, message: `Recipe "${args.id}" not found in ${namespace}.` };
+      }
+    }
+    case "decantr_resolve_blueprint": {
+      const err = validateStringArg(args, "id");
+      if (err) return { error: err };
+      const namespace = args.namespace || "@official";
+      try {
+        const blueprint = await apiClient.getBlueprint(namespace, args.id);
+        let topology = null;
+        const composeEntries = blueprint.compose || blueprint.data?.compose;
+        if (composeEntries && Array.isArray(composeEntries) && composeEntries.length > 0) {
+          const zoneInputs = [];
+          const archetypePromises = composeEntries.map(async (entry) => {
+            const arcId = typeof entry === "string" ? entry : entry.archetype;
+            try {
+              const arch = await apiClient.getContent("archetypes", namespace, arcId);
+              const archData = arch.data || arch;
+              const explicitRole = typeof entry === "object" ? entry.role : void 0;
+              zoneInputs.push({
+                archetypeId: arcId,
+                role: explicitRole || archData.role || "auxiliary",
+                shell: archData.pages?.[0]?.shell || "sidebar-main",
+                features: archData.features || [],
+                description: archData.description || ""
+              });
+            } catch {
+            }
+          });
+          await Promise.all(archetypePromises);
+          if (zoneInputs.length > 0) {
+            const zones = deriveZones(zoneInputs);
+            const transitions = deriveTransitions(zones);
+            const primaryArchetype = zoneInputs.find((z) => z.role === "primary");
+            topology = {
+              zones: zones.map((z) => ({
+                role: z.role,
+                archetypes: z.archetypes,
+                shell: z.shell,
+                features: z.features,
+                purpose: z.descriptions.join(" ")
+              })),
+              transitions,
+              entryPoints: {
+                anonymous: "/",
+                authenticated: primaryArchetype ? `/${primaryArchetype.archetypeId}` : "/home"
+              }
+            };
+          }
+        }
+        return { found: true, ...blueprint, ...topology ? { topology } : {} };
+      } catch {
+        return { found: false, message: `Blueprint "${args.id}" not found in ${namespace}.` };
+      }
+    }
+    case "decantr_suggest_patterns": {
+      const err = validateStringArg(args, "description");
+      if (err) return { error: err };
+      const desc = args.description.toLowerCase();
+      try {
+        const patternsResponse = await apiClient.listContent("patterns", {
+          namespace: "@official",
+          limit: 100
+        });
+        const suggestions = [];
+        for (const p of patternsResponse.items) {
+          const searchable = [
+            p.name || "",
+            p.description || "",
+            ...p.components || [],
+            ...p.tags || []
+          ].join(" ").toLowerCase();
+          let score = 0;
+          const words = desc.split(/\s+/);
+          for (const word of words) {
+            if (word.length < 3) continue;
+            if (searchable.includes(word)) score += 10;
+          }
+          if (desc.includes("dashboard") && ["kpi-grid", "chart-grid", "data-table", "filter-bar"].includes(p.id)) score += 20;
+          if (desc.includes("metric") && p.id === "kpi-grid") score += 15;
+          if (desc.includes("chart") && p.id === "chart-grid") score += 15;
+          if (desc.includes("table") && p.id === "data-table") score += 15;
+          if (desc.includes("form") && p.id === "form-sections") score += 15;
+          if (desc.includes("setting") && p.id === "form-sections") score += 15;
+          if (desc.includes("landing") && ["hero", "cta-section", "card-grid"].includes(p.id)) score += 20;
+          if (desc.includes("hero") && p.id === "hero") score += 20;
+          if (desc.includes("ecommerce") && ["card-grid", "filter-bar", "detail-header"].includes(p.id)) score += 15;
+          if (desc.includes("product") && p.id === "card-grid") score += 15;
+          if (desc.includes("feed") && p.id === "activity-feed") score += 15;
+          if (desc.includes("filter") && p.id === "filter-bar") score += 15;
+          if (desc.includes("search") && p.id === "filter-bar") score += 10;
+          if (score > 0) {
+            const preset = p.presets ? Object.values(p.presets)[0] : null;
+            suggestions.push({
+              id: p.id,
+              score,
+              name: p.name || p.id,
+              description: p.description || "",
+              components: p.components || [],
+              layout: preset?.layout ? preset.layout.layout : "grid"
+            });
+          }
+        }
+        suggestions.sort((a, b) => b.score - a.score);
+        return {
+          query: args.description,
+          suggestions: suggestions.slice(0, 5),
+          total: suggestions.length
+        };
+      } catch (e) {
+        return { error: `Could not fetch patterns: ${e.message}` };
+      }
+    }
+    case "decantr_check_drift": {
+      const essencePath = args.path || join2(process.cwd(), "decantr.essence.json");
+      let essence;
+      try {
+        essence = JSON.parse(await readFile2(essencePath, "utf-8"));
+      } catch (e) {
+        return { error: `Could not read essence: ${e.message}` };
+      }
+      const validation = validateEssence(essence);
+      if (!validation.valid) {
+        return { drifted: true, reason: "invalid_essence", errors: validation.errors };
+      }
+      const violations = [];
+      if (args.theme_used && typeof args.theme_used === "string") {
+        let expectedStyle;
+        if (isV32(essence)) {
+          expectedStyle = essence.dna.theme.style;
+        } else {
+          const expectedTheme = essence.theme;
+          expectedStyle = expectedTheme?.style;
+        }
+        if (expectedStyle && args.theme_used !== expectedStyle) {
+          violations.push({
+            rule: "theme-match",
+            severity: "critical",
+            message: `Theme drift: code uses "${args.theme_used}" but Essence specifies "${expectedStyle}". Do not switch themes.`,
+            ...isV32(essence) ? { layer: "dna", autoFixable: false } : {}
+          });
+        }
+      }
+      if (args.page_id && typeof args.page_id === "string") {
+        let pages;
+        if (isV32(essence)) {
+          pages = essence.blueprint.pages;
+        } else {
+          pages = essence.structure || [];
+        }
+        if (!pages.find((p) => p.id === args.page_id)) {
+          violations.push({
+            rule: "page-exists",
+            severity: "critical",
+            message: `Page "${args.page_id}" not found in Essence structure. Add it to the Essence before generating code for it.`,
+            ...isV32(essence) ? {
+              layer: "blueprint",
+              autoFixable: true,
+              autoFix: { type: "add_page", patch: { id: args.page_id } }
+            } : {}
+          });
+        }
+      }
+      if (args.components_used && Array.isArray(args.components_used) && args.page_id && typeof args.page_id === "string") {
+        let pages;
+        if (isV32(essence)) {
+          pages = essence.blueprint.pages;
+        } else {
+          pages = essence.structure || [];
+        }
+        const page = pages.find((p) => p.id === args.page_id);
+        if (page && page.layout) {
+          const expectedPatterns = /* @__PURE__ */ new Set();
+          for (const item of page.layout) {
+            if (typeof item === "string") {
+              expectedPatterns.add(item);
+            } else if (typeof item === "object" && item !== null && "pattern" in item) {
+              expectedPatterns.add(item.pattern);
+            }
+          }
+          const componentsUsed = args.components_used;
+          const unmatchedComponents = [];
+          for (const comp of componentsUsed) {
+            const compLower = comp.toLowerCase().replace(/[_\s]/g, "-");
+            let matched = false;
+            for (const pattern of expectedPatterns) {
+              const patternLower = pattern.toLowerCase();
+              if (compLower.includes(patternLower) || patternLower.includes(compLower) || fuzzyScore(compLower, patternLower) >= 60) {
+                matched = true;
+                break;
+              }
+            }
+            if (!matched) {
+              unmatchedComponents.push(comp);
+            }
+          }
+          if (unmatchedComponents.length > 0) {
+            violations.push({
+              rule: "component-pattern-match",
+              severity: "warning",
+              message: `Components [${unmatchedComponents.join(", ")}] do not match any pattern in page "${args.page_id}" layout. Expected patterns: [${[...expectedPatterns].join(", ")}].`,
+              ...isV32(essence) ? { layer: "blueprint", autoFixable: false } : {}
+            });
+          }
+        }
+      }
+      try {
+        const guardViolations = evaluateGuard(essence, {
+          pageId: args.page_id
+        });
+        for (const gv of guardViolations) {
+          violations.push({
+            rule: gv.rule || "guard",
+            severity: gv.severity || "warning",
+            message: gv.message || "Guard violation",
+            ...gv.layer ? { layer: gv.layer } : {},
+            ...gv.autoFixable !== void 0 ? { autoFixable: gv.autoFixable } : {},
+            ...gv.autoFix ? { autoFix: gv.autoFix } : {}
+          });
+        }
+      } catch {
+      }
+      if (isV32(essence)) {
+        const dnaViolations = violations.filter((v) => v.layer === "dna");
+        const blueprintDrift = violations.filter((v) => v.layer === "blueprint");
+        const other = violations.filter((v) => !v.layer);
+        return {
+          drifted: violations.length > 0,
+          dna_violations: dnaViolations,
+          blueprint_drift: blueprintDrift,
+          other_violations: other,
+          checkedAgainst: essencePath
+        };
+      }
+      return {
+        drifted: violations.length > 0,
+        violations,
+        checkedAgainst: essencePath
+      };
+    }
+    case "decantr_create_essence": {
+      const err = validateStringArg(args, "description");
+      if (err) return { error: err };
+      const desc = args.description.toLowerCase();
+      const framework = args.framework || "react";
+      const archetypeScores = [];
+      const archetypeIds = [
+        "saas-dashboard",
+        "ecommerce",
+        "portfolio",
+        "content-site",
+        "financial-dashboard",
+        "cloud-platform",
+        "gaming-platform",
+        "ecommerce-admin",
+        "workbench"
+      ];
+      for (const id of archetypeIds) {
+        let score = 0;
+        if (desc.includes("dashboard") && id.includes("dashboard")) score += 20;
+        if (desc.includes("saas") && id.includes("saas")) score += 20;
+        if (desc.includes("ecommerce") && id.includes("ecommerce")) score += 20;
+        if (desc.includes("shop") && id.includes("ecommerce")) score += 15;
+        if (desc.includes("portfolio") && id.includes("portfolio")) score += 20;
+        if (desc.includes("blog") && id.includes("content")) score += 15;
+        if (desc.includes("content") && id.includes("content")) score += 15;
+        if (desc.includes("finance") && id.includes("financial")) score += 20;
+        if (desc.includes("cloud") && id.includes("cloud")) score += 15;
+        if (desc.includes("game") && id.includes("gaming")) score += 15;
+        if (desc.includes("admin") && id.includes("admin")) score += 15;
+        if (desc.includes("analytics") && id.includes("dashboard")) score += 10;
+        if (desc.includes("tool") && id === "workbench") score += 10;
+        if (score > 0) archetypeScores.push({ id, score });
+      }
+      archetypeScores.sort((a, b) => b.score - a.score);
+      const bestMatch = archetypeScores[0]?.id || "saas-dashboard";
+      let pages;
+      let features = [];
+      try {
+        const archetype = await apiClient.getArchetype("@official", bestMatch);
+        pages = archetype.pages;
+        features = archetype.features || [];
+      } catch {
+      }
+      const rawPages = pages || [{ id: "home", shell: "full-bleed", default_layout: ["hero"] }];
+      const defaultShell = rawPages[0]?.shell || "sidebar-main";
+      const essence = {
+        version: "3.0.0",
+        dna: {
+          theme: {
+            style: "auradecantism",
+            mode: "dark",
+            recipe: "auradecantism",
+            shape: "rounded"
+          },
+          spacing: {
+            base_unit: 4,
+            scale: "linear",
+            density: "comfortable",
+            content_gap: "4"
+          },
+          typography: {
+            scale: "modular",
+            heading_weight: 600,
+            body_weight: 400
+          },
+          color: {
+            palette: "semantic",
+            accent_count: 1,
+            cvd_preference: "auto"
+          },
+          radius: {
+            philosophy: "rounded",
+            base: 8
+          },
+          elevation: {
+            system: "layered",
+            max_levels: 3
+          },
+          motion: {
+            preference: "subtle",
+            duration_scale: 1,
+            reduce_motion: true
+          },
+          accessibility: {
+            wcag_level: "AA",
+            focus_visible: true,
+            skip_nav: true
+          },
+          personality: ["professional"]
+        },
+        blueprint: {
+          shell: defaultShell,
+          pages: rawPages.map((p) => ({
+            id: p.id,
+            ...p.shell !== defaultShell ? { shell_override: p.shell } : {},
+            layout: p.default_layout || []
+          })),
+          features
+        },
+        meta: {
+          archetype: bestMatch,
+          target: framework,
+          platform: { type: "spa", routing: "hash" },
+          guard: { mode: "strict", dna_enforcement: "error", blueprint_enforcement: "warn" }
+        }
+      };
+      return {
+        essence,
+        archetype: bestMatch,
+        format: "v3",
+        instructions: `Save this as decantr.essence.json in your project root. Review the dna (design tokens), blueprint (pages/features), and meta (project config) sections and adjust to match your needs. The guard rules will validate your code against this spec.`,
+        _generated: {
+          matched_archetype: bestMatch,
+          confidence: archetypeScores[0]?.score || 0,
+          alternatives: archetypeScores.slice(1, 4).map((a) => a.id),
+          description: args.description
+        }
+      };
+    }
+    case "decantr_accept_drift": {
+      const violations = args.violations;
+      const resolution = args.resolution;
+      if (!violations || !Array.isArray(violations) || violations.length === 0) {
+        return { error: 'Required parameter "violations" must be a non-empty array.' };
+      }
+      if (!resolution || !["accept", "accept_scoped", "reject", "defer"].includes(resolution)) {
+        return { error: 'Required parameter "resolution" must be one of: accept, accept_scoped, reject, defer.' };
+      }
+      const hasDnaViolation = violations.some((v) => {
+        const rule = v.rule;
+        return ["style", "recipe", "density", "theme-mode", "accessibility", "theme-match"].includes(rule);
+      });
+      if (hasDnaViolation && resolution !== "reject" && resolution !== "defer" && !args.confirm_dna) {
+        return {
+          error: "DNA-layer violations detected. Set confirm_dna: true to accept changes to design axioms (theme, style, density, etc.).",
+          requires_confirmation: true,
+          dna_rules_affected: violations.filter(
+            (v) => ["style", "recipe", "density", "theme-mode", "accessibility", "theme-match"].includes(v.rule)
+          ).map((v) => v.rule)
+        };
+      }
+      if (resolution === "reject") {
+        return {
+          status: "rejected",
+          message: "Violations rejected. No changes made. Revert the code to match the essence spec.",
+          violations_count: violations.length
+        };
+      }
+      if (resolution === "defer") {
+        const projectRoot = args.path ? dirname2(args.path) : void 0;
+        const existingLog = await readDriftLog(projectRoot);
+        const newEntries = violations.map((v) => ({
+          rule: v.rule,
+          page_id: v.page_id,
+          details: v.details,
+          resolution: "deferred",
+          scope: args.scope || void 0,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }));
+        const updatedLog = [...existingLog, ...newEntries];
+        const logPath = await writeDriftLog(updatedLog, projectRoot);
+        return {
+          status: "deferred",
+          message: `${violations.length} violation(s) deferred to drift log.`,
+          log_path: logPath,
+          total_deferred: updatedLog.length
+        };
+      }
+      try {
+        const { essence, path } = await mutateEssenceFile(args.path, (v3) => {
+          for (const v of violations) {
+            applyDriftAcceptance(v3, v, resolution, args.scope);
+          }
+          return v3;
+        });
+        return {
+          status: resolution === "accept_scoped" ? "accepted_scoped" : "accepted",
+          message: `${violations.length} violation(s) resolved. Essence updated.`,
+          path,
+          scope: resolution === "accept_scoped" ? args.scope || "unscoped" : void 0
+        };
+      } catch (e) {
+        return { error: `Failed to update essence: ${e.message}` };
+      }
+    }
+    case "decantr_update_essence": {
+      const operation = args.operation;
+      const payload = args.payload;
+      if (!operation) {
+        return { error: 'Required parameter "operation" is missing.' };
+      }
+      if (!payload || typeof payload !== "object") {
+        return { error: 'Required parameter "payload" must be an object.' };
+      }
+      const validOps = ["add_page", "remove_page", "update_page_layout", "update_dna", "update_blueprint", "add_feature", "remove_feature"];
+      if (!validOps.includes(operation)) {
+        return { error: `Invalid operation "${operation}". Must be one of: ${validOps.join(", ")}` };
+      }
+      try {
+        const { essence, path } = await mutateEssenceFile(args.path, (v3) => {
+          return applyEssenceUpdate(v3, operation, payload);
+        });
+        return {
+          status: "updated",
+          operation,
+          path,
+          summary: describeUpdate(operation, payload)
+        };
+      } catch (e) {
+        return { error: `Failed to update essence: ${e.message}` };
+      }
+    }
+    case "decantr_get_section_context": {
+      const err = validateStringArg(args, "section_id");
+      if (err) return { error: err };
+      const sectionId = args.section_id;
+      let essence;
+      try {
+        const result = await readEssenceFile();
+        essence = result.essence;
+      } catch {
+        return { error: "No valid essence file found. Run decantr init first." };
+      }
+      if (!isV32(essence)) {
+        return { error: "Section context requires a v3 essence file. Run decantr migrate first." };
+      }
+      const sections = essence.blueprint.sections || [];
+      const section = sections.find((s) => s.id === sectionId);
+      if (!section) {
+        return {
+          error: `Section "${sectionId}" not found.`,
+          available_sections: sections.map((s) => ({ id: s.id, role: s.role, pages: s.pages.length }))
+        };
+      }
+      const contextPath = join2(process.cwd(), ".decantr", "context", `section-${sectionId}.md`);
+      if (existsSync(contextPath)) {
+        return {
+          section_id: sectionId,
+          role: section.role,
+          shell: section.shell,
+          features: section.features,
+          pages: section.pages.map((p) => ({ id: p.id, route: p.route, layout: p.layout })),
+          context: readFileSync(contextPath, "utf-8")
+        };
+      }
+      return {
+        section_id: sectionId,
+        role: section.role,
+        shell: section.shell,
+        features: section.features,
+        description: section.description,
+        pages: section.pages.map((p) => ({ id: p.id, route: p.route, layout: p.layout })),
+        note: "Section context file not found. Run decantr refresh to generate it."
+      };
+    }
+    case "decantr_component_api": {
+      const componentName = args.component;
+      const category = args.category;
+      if (!componentName) {
+        return { error: 'The "component" argument is required.' };
+      }
+      if (componentName === "list") {
+        const grouped = getComponentsByCategory(category);
+        const lines2 = ["# @decantr/ui Components\n"];
+        for (const [cat, entries] of Object.entries(grouped)) {
+          lines2.push(`## ${cat}`);
+          for (const entry2 of entries) {
+            lines2.push(`- **${entry2.name}** \u2014 ${entry2.description}`);
+          }
+          lines2.push("");
+        }
+        return { content: lines2.join("\n"), total: Object.keys(COMPONENT_MANIFEST).length };
+      }
+      const entry = COMPONENT_MANIFEST[componentName] || Object.values(COMPONENT_MANIFEST).find(
+        (e) => e.name.toLowerCase() === componentName.toLowerCase()
+      );
+      if (!entry) {
+        const candidates = Object.keys(COMPONENT_MANIFEST);
+        const scored = candidates.map((name2) => ({ name: name2, score: fuzzyScore(componentName.toLowerCase(), name2.toLowerCase()) })).filter((s) => s.score > 0).sort((a, b) => b.score - a.score).slice(0, 5);
+        return {
+          error: `Component "${componentName}" not found in manifest.`,
+          suggestions: scored.map((s) => s.name),
+          hint: 'Use component: "list" to see all available components.'
+        };
+      }
+      const lines = [
+        `# ${entry.name}`,
+        `**Category:** ${entry.category}`,
+        "",
+        entry.description,
+        "",
+        "## Props",
+        "",
+        "| Prop | Type | Required | Default | Description |",
+        "|------|------|----------|---------|-------------|"
+      ];
+      for (const p of entry.props) {
+        const req = p.required ? "Yes" : "No";
+        const def = p.default || "\u2014";
+        const escapedType = p.type.replace(/\|/g, "\\|");
+        lines.push(`| \`${p.name}\` | \`${escapedType}\` | ${req} | ${def} | ${p.description} |`);
+      }
+      lines.push("");
+      lines.push("## Usage");
+      lines.push("");
+      lines.push("```ts");
+      lines.push(entry.usage);
+      lines.push("```");
+      if (entry.subComponents?.length) {
+        lines.push("");
+        lines.push(`**Sub-components:** ${entry.subComponents.join(", ")}`);
+      }
+      if (entry.relatedComponents?.length) {
+        lines.push("");
+        lines.push(`**Related:** ${entry.relatedComponents.join(", ")}`);
+      }
+      return { content: lines.join("\n") };
+    }
+    default:
+      return { error: `Unknown tool: ${name}` };
+  }
+}
+function applyDriftAcceptance(essence, violation, resolution, scope) {
+  switch (violation.rule) {
+    case "theme-match":
+    case "style": {
+      if (violation.details) {
+        essence.dna.theme.style = violation.details;
+      }
+      break;
+    }
+    case "page-exists":
+    case "structure": {
+      if (violation.page_id) {
+        const existing = essence.blueprint.pages.find((p) => p.id === violation.page_id);
+        if (!existing) {
+          essence.blueprint.pages.push({
+            id: violation.page_id,
+            layout: []
+          });
+        }
+      }
+      break;
+    }
+    case "layout": {
+      break;
+    }
+    case "recipe": {
+      if (violation.details) {
+        essence.dna.theme.recipe = violation.details;
+      }
+      break;
+    }
+    case "density": {
+      break;
+    }
+    default:
+      break;
+  }
+}
+function applyEssenceUpdate(essence, operation, payload) {
+  switch (operation) {
+    case "add_page": {
+      const id = payload.id;
+      if (!id) throw new Error('Payload must include "id" for add_page.');
+      const existing = essence.blueprint.pages.find((p) => p.id === id);
+      if (existing) throw new Error(`Page "${id}" already exists.`);
+      essence.blueprint.pages.push({
+        id,
+        layout: payload.layout || [],
+        ...payload.shell_override ? { shell_override: payload.shell_override } : {},
+        ...payload.surface ? { surface: payload.surface } : {}
+      });
+      break;
+    }
+    case "remove_page": {
+      const id = payload.id;
+      if (!id) throw new Error('Payload must include "id" for remove_page.');
+      const idx = essence.blueprint.pages.findIndex((p) => p.id === id);
+      if (idx === -1) throw new Error(`Page "${id}" not found.`);
+      essence.blueprint.pages.splice(idx, 1);
+      break;
+    }
+    case "update_page_layout": {
+      const id = payload.id;
+      const layout = payload.layout;
+      if (!id) throw new Error('Payload must include "id" for update_page_layout.');
+      if (!layout || !Array.isArray(layout)) throw new Error('Payload must include "layout" array for update_page_layout.');
+      const page = essence.blueprint.pages.find((p) => p.id === id);
+      if (!page) throw new Error(`Page "${id}" not found.`);
+      page.layout = layout;
+      break;
+    }
+    case "update_dna": {
+      for (const [key, value] of Object.entries(payload)) {
+        if (key in essence.dna && typeof value === "object" && value !== null && !Array.isArray(value)) {
+          essence.dna[key] = {
+            ...essence.dna[key],
+            ...value
+          };
+        } else {
+          essence.dna[key] = value;
+        }
+      }
+      break;
+    }
+    case "update_blueprint": {
+      for (const [key, value] of Object.entries(payload)) {
+        if (key === "pages") continue;
+        essence.blueprint[key] = value;
+      }
+      break;
+    }
+    case "add_feature": {
+      const feature = payload.feature;
+      if (!feature) throw new Error('Payload must include "feature" for add_feature.');
+      if (!essence.blueprint.features.includes(feature)) {
+        essence.blueprint.features.push(feature);
+      }
+      break;
+    }
+    case "remove_feature": {
+      const feature = payload.feature;
+      if (!feature) throw new Error('Payload must include "feature" for remove_feature.');
+      const idx = essence.blueprint.features.indexOf(feature);
+      if (idx === -1) throw new Error(`Feature "${feature}" not found.`);
+      essence.blueprint.features.splice(idx, 1);
+      break;
+    }
+  }
+  return essence;
+}
+function describeUpdate(operation, payload) {
+  switch (operation) {
+    case "add_page":
+      return `Added page "${payload.id}".`;
+    case "remove_page":
+      return `Removed page "${payload.id}".`;
+    case "update_page_layout":
+      return `Updated layout for page "${payload.id}".`;
+    case "update_dna":
+      return `Updated DNA: ${Object.keys(payload).join(", ")}.`;
+    case "update_blueprint":
+      return `Updated blueprint: ${Object.keys(payload).join(", ")}.`;
+    case "add_feature":
+      return `Added feature "${payload.feature}".`;
+    case "remove_feature":
+      return `Removed feature "${payload.feature}".`;
+    default:
+      return `Performed ${operation}.`;
+  }
+}
+
+// src/index.ts
+var VERSION = "0.2.0";
+var server = new Server(
+  { name: "decantr", version: VERSION },
+  { capabilities: { tools: {} } }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return { tools: TOOLS };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    const result = await handleTool(name, args ?? {});
+    const response = {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+    };
+    if (result && typeof result === "object" && "error" in result) {
+      response.isError = true;
+    }
+    return response;
+  } catch (err) {
+    return {
+      content: [{ type: "text", text: JSON.stringify({ error: err.message }) }],
+      isError: true
+    };
+  }
+});
+var transport = new StdioServerTransport();
+await server.connect(transport);