@hyperfixi/mcp-server 2.0.0 → 2.2.0

package/dist/index.js

@@ -5,6 +5,8 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
   CallToolRequestSchema,
+  GetPromptRequestSchema,
+  ListPromptsRequestSchema,
   ListResourcesRequestSchema,
   ListToolsRequestSchema,
   ReadResourceRequestSchema
@@ -14,7 +16,7 @@ import {
 var analysisTools = [
   {
     name: "analyze_complexity",
-    description: "Calculate code complexity metrics (cyclomatic, cognitive, Halstead) for hyperscript",
+    description: "Calculate numeric complexity scores for hyperscript: cyclomatic, cognitive, and Halstead metrics. Use for code review when deciding if code is too complex.",
     inputSchema: {
       type: "object",
       properties: {
@@ -28,7 +30,7 @@ var analysisTools = [
   },
   {
     name: "analyze_metrics",
-    description: "Perform comprehensive code analysis including patterns, code smells, and quality metrics",
+    description: "Detect code smells and quality issues in hyperscript. Returns patterns, problems (too many commands, missing error handling), and quality scores. More detailed than analyze_complexity.",
     inputSchema: {
       type: "object",
       properties: {
@@ -42,7 +44,7 @@ var analysisTools = [
   },
   {
     name: "explain_code",
-    description: "Generate natural language explanation of hyperscript code",
+    description: 'Generate a plain English explanation of hyperscript code for humans. Use when a user asks "what does this code do?" Supports beginner/intermediate/expert audience levels.',
     inputSchema: {
       type: "object",
       properties: {
@@ -66,7 +68,7 @@ var analysisTools = [
   },
   {
     name: "recognize_intent",
-    description: "Analyze hyperscript code to understand its purpose and classify common patterns",
+    description: "Classify what hyperscript code does: returns intent labels (dom-manipulation, form-handling, data-fetching, animation, etc.) with confidence scores. Use to categorize code purpose, not measure quality.",
     inputSchema: {
       type: "object",
       properties: {
@@ -377,7 +379,7 @@ function simpleIntentRecognition(code) {
 var patternTools = [
   {
     name: "get_examples",
-    description: "Get hyperscript examples relevant to a task for few-shot learning",
+    description: 'Get hyperscript code examples matching a natural language task description (e.g., "toggle a class on click"). Returns working code with quality scores. Best for generating new code by example.',
     inputSchema: {
       type: "object",
       properties: {
@@ -401,7 +403,7 @@ var patternTools = [
   },
   {
     name: "search_patterns",
-    description: "Search the pattern database for hyperscript examples",
+    description: "Search the pattern database by keyword or category filter (class-manipulation, visibility, async, validation, etc.). Unlike get_examples which takes task descriptions, this searches pattern names and content.",
     inputSchema: {
       type: "object",
       properties: {
@@ -424,7 +426,7 @@ var patternTools = [
   },
   {
     name: "translate_hyperscript",
-    description: "Translate hyperscript between languages",
+    description: "Translate hyperscript keywords between any of 24 languages via pattern substitution. Preserves selectors and values. For higher-fidelity translation with grammar transformation, use translate_code instead.",
     inputSchema: {
       type: "object",
       properties: {
@@ -1169,7 +1171,7 @@ function getSemanticAnalyzer() {
 var validationTools = [
   {
     name: "validate_hyperscript",
-    description: "Validate hyperscript syntax and return any errors",
+    description: "Check hyperscript code for syntax errors and role warnings. Use as the FIRST validation step before returning code to users. For detailed line/column positions, use get_diagnostics instead.",
     inputSchema: {
       type: "object",
       properties: {
@@ -1188,7 +1190,7 @@ var validationTools = [
   },
   {
     name: "validate_schema",
-    description: "Validate command schemas for design issues. Returns structured validation items with machine-readable codes, severity levels (error/warning/note), and suggested fixes. Useful for catching schema issues before they cause runtime problems.",
+    description: "Validate internal command SCHEMA definitions for design issues \u2014 NOT for checking user-written hyperscript. Returns structured items with error codes and severity. Use only when developing or debugging LokaScript command schemas.",
     inputSchema: {
       type: "object",
       properties: {
@@ -1282,7 +1284,7 @@ var validationTools = [
   },
   {
     name: "translate_to_english",
-    description: "Translate hyperscript from any supported language to English. Essential for LLMs to understand non-English code.",
+    description: "Normalize non-English hyperscript to English. Returns English code plus explicit bracket syntax. Set getAllLanguages=true to get all 24 translations at once. Use when you receive code in Japanese, Korean, Arabic, etc.",
     inputSchema: {
       type: "object",
       properties: {
@@ -1741,59 +1743,133 @@ var COMMAND_SUGGESTIONS = {
   toggle: {
     command: "toggle",
     example: "toggle .active",
+    explicitSyntax: "[toggle patient:.active destination:#element]",
     description: "Toggle a class, attribute, or visibility"
   },
   add: {
     command: "add",
     example: "add .highlight to me",
+    explicitSyntax: "[add patient:.highlight destination:#element]",
     description: "Add a class, attribute, or style"
   },
   remove: {
     command: "remove",
     example: "remove .error from #form",
+    explicitSyntax: "[remove patient:.error source:#form]",
     description: "Remove a class, attribute, or element"
   },
   show: {
     command: "show",
     example: "show #modal with *opacity",
+    explicitSyntax: "[show patient:#modal style:opacity]",
     description: "Show a hidden element"
   },
-  hide: { command: "hide", example: "hide me with *opacity", description: "Hide an element" },
-  set: { command: "set", example: "set :count to 0", description: "Set a variable or property" },
+  hide: {
+    command: "hide",
+    example: "hide me with *opacity",
+    explicitSyntax: "[hide patient:me style:opacity]",
+    description: "Hide an element"
+  },
+  set: {
+    command: "set",
+    example: "set :count to 0",
+    explicitSyntax: "[set destination::count patient:0]",
+    description: "Set a variable or property"
+  },
   put: {
     command: "put",
     example: 'put "Hello" into #greeting',
+    explicitSyntax: '[put patient:"Hello" destination:#greeting]',
     description: "Set element content"
   },
-  fetch: { command: "fetch", example: "fetch /api as json", description: "Make HTTP request" },
-  wait: { command: "wait", example: "wait 500ms", description: "Pause execution" },
-  send: { command: "send", example: "send refresh to #list", description: "Dispatch custom event" },
-  go: { command: "go", example: "go to /page", description: "Navigate to URL" },
+  fetch: {
+    command: "fetch",
+    example: "fetch /api as json",
+    explicitSyntax: "[fetch source:/api responseType:json]",
+    description: "Make HTTP request"
+  },
+  wait: {
+    command: "wait",
+    example: "wait 500ms",
+    explicitSyntax: "[wait patient:500ms]",
+    description: "Pause execution"
+  },
+  send: {
+    command: "send",
+    example: "send refresh to #list",
+    explicitSyntax: "[send event:refresh destination:#list]",
+    description: "Dispatch custom event"
+  },
+  go: {
+    command: "go",
+    example: "go to /page",
+    explicitSyntax: "[go destination:/page]",
+    description: "Navigate to URL"
+  },
   increment: {
     command: "increment",
     example: "increment :count",
+    explicitSyntax: "[increment patient::count]",
     description: "Add 1 to a number"
   },
   decrement: {
     command: "decrement",
     example: "decrement :count",
+    explicitSyntax: "[decrement patient::count]",
     description: "Subtract 1 from a number"
   },
-  focus: { command: "focus", example: "focus #input", description: "Focus an element" },
+  focus: {
+    command: "focus",
+    example: "focus #input",
+    explicitSyntax: "[focus patient:#input]",
+    description: "Focus an element"
+  },
   call: {
     command: "call",
     example: "call myFunction()",
+    explicitSyntax: "[call patient:myFunction()]",
     description: "Call a JavaScript function"
   },
-  log: { command: "log", example: "log me", description: "Log to console" },
-  beep: { command: "beep", example: "beep me", description: "Debug output with type info" },
-  break: { command: "break", example: "break", description: "Exit current loop" },
-  copy: { command: "copy", example: "copy #input.value", description: "Copy to clipboard" },
-  exit: { command: "exit", example: "exit", description: "Exit event handler" },
-  pick: { command: "pick", example: "pick .items", description: "Pick random item" },
+  log: {
+    command: "log",
+    example: "log me",
+    explicitSyntax: "[log patient:me]",
+    description: "Log to console"
+  },
+  beep: {
+    command: "beep",
+    example: "beep me",
+    explicitSyntax: "[beep patient:me]",
+    description: "Debug output with type info"
+  },
+  break: {
+    command: "break",
+    example: "break",
+    explicitSyntax: "[break]",
+    description: "Exit current loop"
+  },
+  copy: {
+    command: "copy",
+    example: "copy #input.value",
+    explicitSyntax: "[copy patient:#input]",
+    description: "Copy to clipboard"
+  },
+  exit: {
+    command: "exit",
+    example: "exit",
+    explicitSyntax: "[exit]",
+    description: "Exit event handler"
+  },
+  pick: {
+    command: "pick",
+    example: "pick .items",
+    explicitSyntax: "[pick source:.items]",
+    description: "Pick random item"
+  },
   render: {
     command: "render",
     example: 'render "<p>${name}</p>" with {name: "World"}',
+    explicitSyntax: '[render patient:"<p>${name}</p>"]',
     description: "Render a template"
   }
 };
@@ -1833,6 +1909,7 @@ function translateSuggestion(suggestion, language) {
         return {
           command: trans.primary,
           example: suggestion.example.replace(suggestion.command, trans.primary),
+          explicitSyntax: suggestion.explicitSyntax,
           description: suggestion.description,
           englishCommand: suggestion.command
         };
@@ -2586,18 +2663,37 @@ var astToolkit = null;
 try {
   astToolkit = await import("@hyperfixi/core/ast-utils");
 } catch {
+  console.error(
+    "[mcp:lsp-bridge] @hyperfixi/core/ast-utils not available \u2014 AST-based diagnostics disabled"
+  );
 }
 var parseFunction = null;
 try {
   const core = await import("@hyperfixi/core");
   parseFunction = core.parse;
 } catch {
+  console.error("[mcp:lsp-bridge] @hyperfixi/core not available \u2014 parse-based analysis disabled");
 }
 var semanticPackage2 = null;
 try {
   semanticPackage2 = await import("@lokascript/semantic");
 } catch {
+  console.error(
+    "[mcp:lsp-bridge] @lokascript/semantic not available \u2014 multilingual support disabled"
+  );
+}
+var frameworkIR = null;
+try {
+  const fw = await import("@lokascript/framework");
+  frameworkIR = { fromInterchangeNode: fw.fromInterchangeNode, renderExplicit: fw.renderExplicit };
+} catch {
+  console.error(
+    "[mcp:lsp-bridge] @lokascript/framework not available \u2014 LSE bracket notation in hover disabled"
+  );
 }
+console.error(
+  `[mcp:lsp-bridge] capabilities: ast=${!!astToolkit}, parse=${!!parseFunction}, semantic=${!!semanticPackage2}, framework=${!!frameworkIR}`
+);
 var cachedAnalyzer2 = null;
 function getSemanticAnalyzer2() {
   if (!semanticPackage2) return null;
@@ -3214,11 +3310,17 @@ function inferContext(beforeCursor) {
   return "default";
 }
 async function getHoverInfo(code, line, character, language) {
-  if (astToolkit && parseFunction) {
+  if (astToolkit && parseFunction && astToolkit.fromCoreAST && astToolkit.interchangeToLSPHover) {
     try {
       const ast = parseFunction(code);
-      if (ast && astToolkit.astToLSPHover) {
-        const hover2 = astToolkit.astToLSPHover(ast, { line, character });
+      if (ast) {
+        const interchange = astToolkit.fromCoreAST(ast);
+        const nodes = Array.isArray(interchange) ? interchange : [interchange];
+        const hoverOptions = {};
+        if (frameworkIR) {
+          hoverOptions.renderLSE = (node) => frameworkIR.renderExplicit(frameworkIR.fromInterchangeNode(node));
+        }
+        const hover2 = astToolkit.interchangeToLSPHover(nodes, { line, character }, hoverOptions);
         if (hover2) {
           return {
             content: [{ type: "text", text: JSON.stringify({ ...hover2, language }, null, 2) }]
@@ -3507,7 +3609,7 @@ var languageDocsTools = [
   },
   {
     name: "search_language_elements",
-    description: "Search across all hyperscript language elements (commands, expressions, keywords, features, special symbols). Useful for discovering available features.",
+    description: 'Search across all hyperscript language elements (commands, expressions, keywords, features, special symbols, semantic roles). Useful for discovering available features. Search for role names like "patient", "destination", "source" to understand semantic roles used in explicit syntax.',
     inputSchema: {
       type: "object",
       properties: {
@@ -3519,7 +3621,7 @@ var languageDocsTools = [
           type: "array",
           items: {
             type: "string",
-            enum: ["command", "expression", "keyword", "feature", "special_symbol"]
+            enum: ["command", "expression", "keyword", "feature", "special_symbol", "role"]
           },
           description: "Filter by element types. If not specified, searches all types."
         },
@@ -3575,6 +3677,49 @@ function generateSyntaxString(schema) {
   }
   return parts.join(" ");
 }
+function generateExplicitExample(schema) {
+  const action = schema.action;
+  if (!schema.roles || schema.roles.length === 0) {
+    return `[${action}]`;
+  }
+  const parts = [action];
+  for (const role of schema.roles) {
+    const exampleValue = getExampleValue(role);
+    parts.push(`${role.role}:${exampleValue}`);
+  }
+  return `[${parts.join(" ")}]`;
+}
+function generateJsonExample(schema) {
+  const roles = {};
+  for (const role of schema.roles || []) {
+    const primaryType = role.expectedTypes?.[0] ?? "literal";
+    roles[role.role] = {
+      type: primaryType === "expression" ? "literal" : primaryType,
+      value: getExampleValue(role)
+    };
+  }
+  return { action: schema.action, roles };
+}
+function getExampleValue(role) {
+  if (role.default) {
+    return role.default.value ?? "me";
+  }
+  const primaryType = role.expectedTypes?.[0];
+  switch (primaryType) {
+    case "selector":
+      return role.description?.toLowerCase().includes("class") ? ".active" : "#element";
+    case "reference":
+      return "me";
+    case "number":
+      return 5;
+    case "boolean":
+      return true;
+    case "duration":
+      return "500ms";
+    default:
+      return '"value"';
+  }
+}
 var EXPRESSION_CATALOG = {
   // === CORE: references ===
   me: {
@@ -4025,6 +4170,165 @@ var SPECIAL_SYMBOLS_CATALOG = [
     description: "Block terminator for if/repeat/for/while blocks"
   }
 ];
+var ROLE_CATALOG = {
+  patient: {
+    name: "patient",
+    description: "The entity undergoing the action \u2014 what is being acted upon. The most common role, used by 25+ commands.",
+    origin: "Linguistic thematic role: the entity that undergoes a change of state.",
+    usage: "The class being toggled, the content being put, the element being shown, the variable being incremented.",
+    commands: [
+      "toggle",
+      "add",
+      "remove",
+      "put",
+      "set",
+      "show",
+      "hide",
+      "wait",
+      "log",
+      "increment",
+      "decrement",
+      "append",
+      "prepend",
+      "copy",
+      "throw",
+      "call",
+      "return",
+      "focus",
+      "blur",
+      "beep",
+      "pick",
+      "render",
+      "morph",
+      "swap"
+    ],
+    explicitExample: "[toggle patient:.active]"
+  },
+  destination: {
+    name: "destination",
+    description: "Where the action targets or where something ends up. Intentionally broad: DOM element, URL, or variable. Disambiguated by value type per command.",
+    origin: "Linguistic thematic role: the endpoint or goal location of a motion/transfer.",
+    usage: "The element receiving a class (toggle/add), the container for content (put), the URL to navigate to (go), the variable to store into (set).",
+    commands: [
+      "toggle",
+      "add",
+      "put",
+      "remove",
+      "append",
+      "prepend",
+      "trigger",
+      "clone",
+      "show",
+      "hide",
+      "transition",
+      "go",
+      "tell",
+      "set",
+      "get",
+      "fetch",
+      "send",
+      "morph",
+      "swap"
+    ],
+    explicitExample: '[put patient:"hello" destination:#output]'
+  },
+  source: {
+    name: "source",
+    description: "Where something originates from \u2014 the origin of data or the element to act on.",
+    origin: "Linguistic thematic role: the starting point of a motion/transfer.",
+    usage: "The element to remove from, the URL to fetch from, the event source element.",
+    commands: ["remove", "on", "get", "take", "pick", "repeat", "for", "measure", "fetch"],
+    explicitExample: "[fetch source:/api/data responseType:json]"
+  },
+  event: {
+    name: "event",
+    description: "The trigger event for an event handler.",
+    origin: "DOM event model.",
+    usage: "The event name that starts execution: click, input, keydown, mouseover, custom events.",
+    commands: ["on", "trigger", "send", "repeat"],
+    explicitExample: "[on event:click body:[toggle patient:.active]]"
+  },
+  condition: {
+    name: "condition",
+    description: "A boolean expression that controls whether something executes.",
+    origin: "Control flow semantics.",
+    usage: "The test in an if/unless/while block.",
+    commands: ["if", "unless", "while"],
+    explicitExample: '[if condition:"x > 5"]'
+  },
+  quantity: {
+    name: "quantity",
+    description: "A numeric amount for the action.",
+    origin: "Linguistic quantifier role.",
+    usage: "How much to increment/decrement by, how many times to repeat.",
+    commands: ["increment", "decrement", "repeat", "for"],
+    explicitExample: "[increment patient:#count quantity:5]"
+  },
+  duration: {
+    name: "duration",
+    description: "A time span for the action.",
+    origin: "Temporal adverbial role.",
+    usage: "How long a transition takes.",
+    commands: ["transition"],
+    explicitExample: "[transition patient:opacity duration:500ms]"
+  },
+  goal: {
+    name: "goal",
+    description: "The target value or state to reach.",
+    origin: "Linguistic thematic role: the desired end-state.",
+    usage: "The target value in a transition.",
+    commands: ["transition"],
+    explicitExample: "[transition patient:opacity goal:0]"
+  },
+  style: {
+    name: "style",
+    description: "The visual or behavioral manner of the action.",
+    origin: "Adverbial modifier for manner/instrument.",
+    usage: "Animation style for show/hide (fade, slide, opacity).",
+    commands: ["show", "hide", "render", "transition"],
+    explicitExample: "[show patient:#modal style:opacity]"
+  },
+  method: {
+    name: "method",
+    description: "The technique or HTTP method used.",
+    origin: "Instrument/manner role, specialized for web.",
+    usage: "HTTP method for fetch (GET, POST), swap strategy (innerHTML, outerHTML).",
+    commands: ["swap", "fetch"],
+    explicitExample: "[fetch source:/api method:POST responseType:json]"
+  },
+  responseType: {
+    name: "responseType",
+    description: "The expected response format.",
+    origin: "HTTP content negotiation.",
+    usage: "How to parse a fetch response: json, text, html, blob.",
+    commands: ["fetch"],
+    explicitExample: "[fetch source:/api responseType:json]"
+  },
+  manner: {
+    name: "manner",
+    description: 'Reserved role for insertion position. Not currently used in command schemas \u2014 swap uses "method", put handles position via destination markers.',
+    origin: "Linguistic adverbial role for how an action is performed.",
+    usage: "Reserved for future use.",
+    commands: [],
+    explicitExample: "(not currently used)"
+  },
+  agent: {
+    name: "agent",
+    description: "Who or what performs the action. Reserved for future use (AI agents, server-side execution).",
+    origin: "Linguistic thematic role: the entity that initiates the action.",
+    usage: "Reserved for future use.",
+    commands: [],
+    explicitExample: "(not currently used)"
+  },
+  loopType: {
+    name: "loopType",
+    description: "The loop variant for repeat commands.",
+    origin: "Control flow semantics.",
+    usage: "Loop style: forever, times, while, until, until-event.",
+    commands: ["repeat"],
+    explicitExample: "[repeat loopType:forever]"
+  }
+};
 var BEST_PRACTICES = [
   {
     id: "prefer-toggle",
@@ -4274,6 +4578,8 @@ function handleGetCommandDocs(args) {
                 command: schema.action,
                 description: schema.description,
                 syntax: generateSyntaxString(schema),
+                explicitSyntax: generateExplicitExample(schema),
+                jsonSyntax: generateJsonExample(schema),
                 category: schema.category,
                 primaryRole: schema.primaryRole,
                 hasBody: schema.hasBody || false,
@@ -4413,7 +4719,14 @@ function handleSearchLanguageElements(args) {
   const query = args.query.toLowerCase();
   const types = args.types;
   const limit = args.limit || 10;
-  const searchTypes = types || ["command", "expression", "keyword", "feature", "special_symbol"];
+  const searchTypes = types || [
+    "command",
+    "expression",
+    "keyword",
+    "feature",
+    "special_symbol",
+    "role"
+  ];
   const results = [];
   if (searchTypes.includes("command")) {
     if (semanticPackage3?.commandSchemas) {
@@ -4499,6 +4812,21 @@ function handleSearchLanguageElements(args) {
       }
     }
   }
+  if (searchTypes.includes("role")) {
+    for (const [name, role] of Object.entries(ROLE_CATALOG)) {
+      if (name.includes(query) || role.description.toLowerCase().includes(query) || role.origin.toLowerCase().includes(query) || role.usage.toLowerCase().includes(query) || role.commands.some((c) => c.includes(query))) {
+        results.push({
+          type: "role",
+          name: role.name,
+          description: role.description,
+          origin: role.origin,
+          usage: role.usage,
+          commands: role.commands,
+          explicitExample: role.explicitExample
+        });
+      }
+    }
+  }
   const limited = results.slice(0, limit);
   return {
     content: [
@@ -4972,7 +5300,7 @@ async function getService() {
 var compilationTools = [
   {
     name: "compile_hyperscript",
-    description: "Compile hyperscript to optimized JavaScript. Accepts natural language (24 languages), explicit syntax ([command role:value]), or LLM JSON ({ action, roles, trigger }).",
+    description: 'Compile hyperscript to optimized JavaScript. Accepts natural language (code + language), explicit syntax (explicit), or LLM JSON (semantic). Common roles: patient (what to act on), destination (where to), source (where from). Use get_command_docs for per-command roles. Examples: explicit="[toggle patient:.active destination:#btn]", semantic={ action: "toggle", roles: { patient: { type: "selector", value: ".active" } } }',
     inputSchema: {
       type: "object",
       properties: {
@@ -5006,7 +5334,7 @@ var compilationTools = [
   },
   {
     name: "validate_and_compile",
-    description: "Validate hyperscript without compiling. Returns semantic representation and diagnostics. Same input format as compile_hyperscript.",
+    description: "Parse hyperscript into semantic IR with diagnostics, without generating JavaScript. Returns action, roles, and trigger structure. Accepts natural language, explicit bracket syntax, or LLM JSON \u2014 same input formats as compile_hyperscript.",
     inputSchema: {
       type: "object",
       properties: {
@@ -5020,7 +5348,7 @@ var compilationTools = [
   },
   {
     name: "translate_code",
-    description: "Translate hyperscript between any of 24 supported languages.",
+    description: "Translate hyperscript between any of 24 languages via full semantic parsing. Higher fidelity than translate_hyperscript \u2014 handles SVO/SOV/VSO grammar transformation. Preferred for production translations.",
     inputSchema: {
       type: "object",
       properties: {
@@ -5046,13 +5374,17 @@ var compilationTools = [
           type: "string",
           enum: ["runtime", "compiled"],
           description: "How to load hyperscript in test (default runtime)"
+        },
+        framework: {
+          type: "string",
+          description: 'Test framework to target (default "playwright")'
         }
       }
     }
   },
   {
     name: "generate_component",
-    description: "Generate a React component from hyperscript. Maps semantic operations to React hooks and JSX.",
+    description: "Generate a React component from hyperscript. Maps semantic operations to React hooks and JSX, Vue 3 Composition API and templates, or Svelte 5 runes. Supports react (default), vue, and svelte frameworks.",
     inputSchema: {
       type: "object",
       properties: {
@@ -5064,6 +5396,10 @@ var compilationTools = [
         typescript: {
           type: "boolean",
           description: "TypeScript output (default true)"
+        },
+        framework: {
+          type: "string",
+          description: 'Component framework to target: "react" (default), "vue", or "svelte"'
         }
       }
     }
@@ -5148,7 +5484,8 @@ async function handleCompilationTool(name, args) {
           semantic: args.semantic,
           language: args.language,
           testName: args.testName,
-          executionMode: args.executionMode
+          executionMode: args.executionMode,
+          framework: args.framework
         });
         return {
           content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
@@ -5162,7 +5499,8 @@ async function handleCompilationTool(name, args) {
           semantic: args.semantic,
           language: args.language,
           componentName: args.componentName,
-          typescript: args.typescript
+          typescript: args.typescript,
+          framework: args.framework
         });
         return {
           content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
@@ -5199,36 +5537,3402 @@ async function handleCompilationTool(name, args) {
   }
 }
 
-// src/resources/content.ts
-function getCommandsReference() {
-  return `# Hyperscript Commands Reference
-
-## DOM Manipulation
+// src/tools/utils.ts
+function validateRequired(args, required) {
+  for (const param of required) {
+    if (args[param] === void 0 || args[param] === null) {
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                error: `Missing required parameter: ${param}`,
+                required,
+                received: Object.keys(args)
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  }
+  return null;
+}
+function getString(args, name, defaultValue = "") {
+  const value = args[name];
+  return typeof value === "string" ? value : defaultValue;
+}
+function getBoolean(args, name, defaultValue = false) {
+  const value = args[name];
+  return typeof value === "boolean" ? value : defaultValue;
+}
+function getNumber(args, name, defaultValue = 0) {
+  const value = args[name];
+  return typeof value === "number" ? value : defaultValue;
+}
+function jsonResponse(data) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(data, null, 2)
+      }
+    ]
+  };
+}
+function errorResponse(error, details) {
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          {
+            error,
+            ...details
+          },
+          null,
+          2
+        )
+      }
+    ]
+  };
+}
 
-| Command | Usage | Example |
-|---------|-------|---------|
-| \`toggle\` | Toggle class/attribute | \`toggle .active on #menu\` |
-| \`add\` | Add class/attribute/style | \`add .highlight to me\` |
-| \`remove\` | Remove class/attribute/element | \`remove .error from #form\` |
-| \`show\` | Show element | \`show #modal with *opacity\` |
-| \`hide\` | Hide element | \`hide me with *opacity\` |
-| \`put\` | Set element content | \`put "Hello" into #greeting\` |
-| \`append\` | Add to end | \`append "<li/>" to #list\` |
-| \`swap\` | Replace content | \`swap #target innerHTML\` |
+// src/tools/routes.ts
+var scanRoutesImpl = null;
+var generators = {};
+async function getScanRoutes() {
+  if (scanRoutesImpl) return scanRoutesImpl;
+  try {
+    const mod = await import("@hyperfixi/server-bridge");
+    scanRoutesImpl = mod.scanRoutes;
+    generators = {
+      express: mod.ExpressGenerator,
+      hono: mod.HonoGenerator,
+      openapi: mod.OpenAPIGenerator,
+      django: mod.DjangoGenerator,
+      fastapi: mod.FastAPIGenerator
+    };
+    return scanRoutesImpl;
+  } catch {
+    throw new Error(
+      "@hyperfixi/server-bridge not available. Install it to use route extraction tools."
+    );
+  }
+}
+var routeTools = [
+  {
+    name: "extract_routes",
+    description: "Extract server route contracts from HTML content containing hyperscript fetch commands, htmx attributes (hx-get, hx-post, etc.), and fixi attributes (fx-action). Returns RouteDescriptor[] with path, method, responseFormat, pathParams, and requestBody.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        html: {
+          type: "string",
+          description: "HTML content to scan for route declarations"
+        },
+        filename: {
+          type: "string",
+          description: 'Optional filename for source attribution (default: "input.html")'
+        }
+      },
+      required: ["html"]
+    }
+  },
+  {
+    name: "generate_server_routes",
+    description: "Generate server-side route scaffolding from HTML content. Scans for routes and produces framework-specific code. Supports Express, Hono, OpenAPI, Django, and FastAPI output.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        html: {
+          type: "string",
+          description: "HTML content to scan for route declarations"
+        },
+        framework: {
+          type: "string",
+          description: 'Target framework: "express", "hono", "openapi", "django", or "fastapi" (default: "express")',
+          enum: ["express", "hono", "openapi", "django", "fastapi"]
+        },
+        typescript: {
+          type: "boolean",
+          description: "Generate TypeScript output (default: true)"
+        },
+        filename: {
+          type: "string",
+          description: 'Optional filename for source attribution (default: "input.html")'
+        }
+      },
+      required: ["html"]
+    }
+  }
+];
+async function handleRouteTool(name, args) {
+  try {
+    switch (name) {
+      case "extract_routes":
+        return await extractRoutes(args);
+      case "generate_server_routes":
+        return await generateServerRoutes(args);
+      default:
+        return errorResponse(`Unknown route tool: ${name}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return errorResponse(`Route tool error: ${message}`);
+  }
+}
+async function extractRoutes(args) {
+  const error = validateRequired(args, ["html"]);
+  if (error) return error;
+  const html = getString(args, "html");
+  const filename = getString(args, "filename", "input.html");
+  const scanRoutes = await getScanRoutes();
+  const result = scanRoutes(html, filename);
+  return jsonResponse({
+    routes: result.routes,
+    count: result.routes.length,
+    errors: result.errors
+  });
+}
+async function generateServerRoutes(args) {
+  const error = validateRequired(args, ["html"]);
+  if (error) return error;
+  const html = getString(args, "html");
+  const framework = getString(args, "framework", "express");
+  const typescript = getBoolean(args, "typescript", true);
+  const filename = getString(args, "filename", "input.html");
+  const scanRoutes = await getScanRoutes();
+  const result = scanRoutes(html, filename);
+  if (result.routes.length === 0) {
+    return jsonResponse({
+      files: [],
+      routes: 0,
+      message: "No routes found in the provided HTML.",
+      errors: result.errors
+    });
+  }
+  const GeneratorClass = generators[framework];
+  if (!GeneratorClass) {
+    return errorResponse(
+      `Unknown framework: ${framework}. Supported: express, hono, openapi, django, fastapi`
+    );
+  }
+  const generator = new GeneratorClass();
+  const generated = generator.generate(result.routes, {
+    outputDir: "./server/routes",
+    typescript
+  });
+  return jsonResponse({
+    framework: generator.framework,
+    routes: result.routes.length,
+    files: generated.files.map((f) => ({
+      path: f.path,
+      content: f.content
+    })),
+    warnings: generated.warnings,
+    scanErrors: result.errors
+  });
+}
 
-## Data Commands
+// src/tools/domain-registry-setup.ts
+import { DomainRegistry } from "@lokascript/framework";
+function createDomainRegistry() {
+  const registry2 = new DomainRegistry();
+  registry2.register({
+    name: "sql",
+    description: "natural language SQL",
+    languages: ["en", "es", "ja", "ar", "ko", "zh", "tr", "fr"],
+    inputLabel: "query",
+    inputDescription: 'SQL query in natural language (e.g., "select name from users")',
+    outputDescription: "a SQL query string",
+    getDSL: () => import("@lokascript/domain-sql").then((m) => m.createSQLDSL()),
+    getRenderer: () => import("@lokascript/domain-sql").then((m) => m.renderSQL),
+    scanConfig: {
+      attributes: ["data-sql", "_sql"],
+      scriptTypes: ["text/sql-dsl"],
+      defaultLanguage: "en"
+    }
+  });
+  registry2.register({
+    name: "bdd",
+    description: "BDD scenario",
+    languages: ["en", "es", "ja", "ar"],
+    inputLabel: "scenario",
+    inputDescription: 'BDD scenario text (e.g., "given #button is exists")',
+    outputDescription: "Playwright test code with Given/When/Then assertions",
+    getDSL: () => import("@lokascript/domain-bdd").then((m) => m.createBDDDSL()),
+    getRenderer: () => import("@lokascript/domain-bdd").then((m) => m.renderBDD),
+    scanConfig: {
+      attributes: ["data-bdd", "_bdd"],
+      scriptTypes: ["text/bdd"],
+      defaultLanguage: "en"
+    }
+  });
+  registry2.register({
+    name: "jsx",
+    description: "natural language JSX/React",
+    languages: ["en", "es", "ja", "ar", "ko", "zh", "tr", "fr"],
+    inputLabel: "code",
+    inputDescription: 'JSX description in natural language (e.g., "element div with className app")',
+    outputDescription: "JSX/React component markup",
+    getDSL: () => import("@lokascript/domain-jsx").then((m) => m.createJSXDSL()),
+    getRenderer: () => import("@lokascript/domain-jsx").then((m) => m.renderJSX),
+    scanConfig: {
+      attributes: ["data-jsx", "_jsx"],
+      scriptTypes: ["text/jsx-dsl"],
+      defaultLanguage: "en"
+    }
+  });
+  registry2.register({
+    name: "todo",
+    description: "natural language todo management",
+    languages: ["en", "es", "ja", "ar", "ko", "zh", "tr", "fr"],
+    inputLabel: "command",
+    inputDescription: 'Todo command in natural language (e.g., "add milk to groceries")',
+    outputDescription: "a structured todo operation object",
+    getDSL: () => import("@lokascript/domain-todo").then((m) => m.createTodoDSL()),
+    getRenderer: () => import("@lokascript/domain-todo").then((m) => m.renderTodo),
+    scanConfig: {
+      attributes: ["data-todo", "_todo"],
+      scriptTypes: ["text/todo"],
+      defaultLanguage: "en"
+    }
+  });
+  registry2.register({
+    name: "behaviorspec",
+    description: "interaction testing specification",
+    languages: ["en", "es", "ja", "ar", "ko", "zh", "tr", "fr"],
+    inputLabel: "scenario",
+    inputDescription: 'BehaviorSpec scenario text (e.g., "given page /home")',
+    outputDescription: "a Playwright interaction test with page assertions",
+    getDSL: () => import("@lokascript/domain-behaviorspec").then((m) => m.createBehaviorSpecDSL()),
+    getRenderer: () => import("@lokascript/domain-behaviorspec").then((m) => m.renderBehaviorSpec),
+    scanConfig: {
+      attributes: ["data-spec", "_spec"],
+      scriptTypes: ["text/behaviorspec"],
+      defaultLanguage: "en"
+    }
+  });
+  registry2.register({
+    name: "llm",
+    description: "natural language LLM prompts (ask, summarize, analyze, translate)",
+    languages: ["en", "es", "ja", "ar", "ko", "zh", "tr", "fr"],
+    inputLabel: "command",
+    inputDescription: 'LLM command in natural language (e.g., "ask claude to summarize #article as bullets")',
+    outputDescription: "an LLMPromptSpec JSON (action, messages, model preferences)",
+    getDSL: () => import("@lokascript/domain-llm").then((m) => m.createLLMDSL()),
+    getRenderer: () => import("@lokascript/domain-llm").then((m) => m.renderLLM),
+    scanConfig: {
+      attributes: ["data-llm", "_llm"],
+      scriptTypes: ["text/llm"],
+      defaultLanguage: "en"
+    }
+  });
+  registry2.register({
+    name: "flow",
+    description: "declarative reactive data flow pipelines (fetch, poll, stream, submit)",
+    languages: ["en", "es", "ja", "ar", "ko", "zh", "tr", "fr"],
+    inputLabel: "pipeline",
+    inputDescription: 'FlowScript pipeline (e.g., "fetch /api/users as json into #list")',
+    outputDescription: "reactive data flow JavaScript (fetch/poll/stream handlers)",
+    getDSL: () => import("@lokascript/domain-flow").then((m) => m.createFlowDSL()),
+    getRenderer: () => import("@lokascript/domain-flow").then((m) => m.renderFlow),
+    scanConfig: {
+      attributes: ["data-flow", "_flow"],
+      scriptTypes: ["text/flowscript"],
+      defaultLanguage: "en"
+    }
+  });
+  registry2.register({
+    name: "voice",
+    description: "voice/accessibility commands for speech-controlled web interaction",
+    languages: ["en", "es", "ja", "ar", "ko", "zh", "tr", "fr"],
+    inputLabel: "command",
+    inputDescription: 'Voice command in natural language (e.g., "click the submit button")',
+    outputDescription: "a DOM interaction command (click, scroll, type, navigate)",
+    getDSL: () => import("@lokascript/domain-voice").then((m) => m.createVoiceDSL()),
+    getRenderer: () => import("@lokascript/domain-voice").then((m) => m.renderVoice),
+    scanConfig: {
+      attributes: ["data-voice", "_voice"],
+      scriptTypes: ["text/voice"],
+      defaultLanguage: "en"
+    }
+  });
+  loadAllSchemas(registry2);
+  return registry2;
+}
+async function loadAllSchemas(registry2) {
+  const loaders = [
+    { domain: "sql", load: () => import("@lokascript/domain-sql").then((m) => [...m.allSchemas]) },
+    { domain: "bdd", load: () => import("@lokascript/domain-bdd").then((m) => [...m.allSchemas]) },
+    { domain: "jsx", load: () => import("@lokascript/domain-jsx").then((m) => [...m.allSchemas]) },
+    { domain: "todo", load: () => import("@lokascript/domain-todo").then((m) => [...m.allSchemas]) },
+    {
+      domain: "behaviorspec",
+      load: () => import("@lokascript/domain-behaviorspec").then((m) => [...m.allSchemas])
+    },
+    { domain: "llm", load: () => import("@lokascript/domain-llm").then((m) => [...m.allSchemas]) },
+    { domain: "flow", load: () => import("@lokascript/domain-flow").then((m) => [...m.allSchemas]) },
+    {
+      domain: "voice",
+      load: () => import("@lokascript/domain-voice").then((m) => [...m.allSchemas])
+    }
+  ];
+  await Promise.allSettled(
+    loaders.map(async ({ domain, load }) => {
+      try {
+        const schemas = await load();
+        registry2.setSchemas(domain, schemas);
+      } catch {
+      }
+    })
+  );
+}
 
-| Command | Usage | Example |
-|---------|-------|---------|
-| \`set\` | Set variable/property | \`set :count to 0\` |
-| \`get\` | Get value | \`get #input.value\` |
-| \`increment\` | Add 1 | \`increment :count\` |
-| \`decrement\` | Subtract 1 | \`decrement :count\` |
+// src/tools/bdd-extras.ts
+var bddScenarioParser = null;
+var bddGenerator = null;
+var bddRenderer = null;
+async function getBDDExtras() {
+  if (bddScenarioParser)
+    return { parseScenario: bddScenarioParser, generator: bddGenerator, renderer: bddRenderer };
+  try {
+    const mod = await import("@lokascript/domain-bdd");
+    bddScenarioParser = mod.parseBDDScenario;
+    bddGenerator = mod.bddCodeGenerator;
+    bddRenderer = mod.renderBDD ?? null;
+    return { parseScenario: bddScenarioParser, generator: bddGenerator, renderer: bddRenderer };
+  } catch {
+    throw new Error("@lokascript/domain-bdd not available for multi-step parsing.");
+  }
+}
+function serializeRoles(roles) {
+  const result = {};
+  for (const [key, value] of roles) {
+    result[key] = value;
+  }
+  return result;
+}
+function isMultiStepBDD(args) {
+  const scenario = getString(args, "scenario");
+  return /[,\n،、。]/.test(scenario);
+}
+async function handleBDDMultiStep(name, args) {
+  const scenario = getString(args, "scenario");
+  if (!scenario) return errorResponse("Missing required parameter: scenario");
+  try {
+    const { parseScenario, generator, renderer } = await getBDDExtras();
+    const operation = name.replace("_bdd", "");
+    if (operation === "parse") {
+      const language = getString(args, "language", "en");
+      const result = parseScenario(scenario, language);
+      return jsonResponse({
+        type: "scenario",
+        stepCount: result.steps.length,
+        steps: result.steps.map((step) => ({
+          action: step.action,
+          roles: serializeRoles(step.roles)
+        })),
+        errors: result.errors,
+        language
+      });
+    }
+    if (operation === "compile") {
+      const language = getString(args, "language", "en");
+      const result = parseScenario(scenario, language);
+      const code = generator.generate(result.scenario);
+      return jsonResponse({
+        ok: result.errors.length === 0,
+        code,
+        stepCount: result.steps.length,
+        ...result.name ? { scenarioName: result.name } : {},
+        errors: result.errors.length > 0 ? result.errors : void 0,
+        language
+      });
+    }
+    if (operation === "validate") {
+      const language = getString(args, "language", "en");
+      const result = parseScenario(scenario, language);
+      return jsonResponse({
+        valid: result.errors.length === 0,
+        stepCount: result.steps.length,
+        errorCount: result.errors.length,
+        errors: result.errors,
+        language
+      });
+    }
+    if (operation === "translate") {
+      const from = getString(args, "from");
+      const to = getString(args, "to");
+      if (!from || !to) return errorResponse("Missing required parameter: from, to");
+      const result = parseScenario(scenario, from);
+      let rendered = null;
+      if (renderer) {
+        const renderedSteps = result.steps.map((step) => renderer(step, to));
+        rendered = renderedSteps.join("\n");
+      }
+      return jsonResponse({
+        input: { scenario, language: from },
+        translated: rendered,
+        playwright: generator.generate(result.scenario),
+        steps: result.steps.map((step) => ({
+          action: step.action,
+          roles: serializeRoles(step.roles)
+        })),
+        errors: result.errors
+      });
+    }
+    return errorResponse(`Unknown BDD operation: ${operation}`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return errorResponse(`BDD multi-step error: ${message}`);
+  }
+}
 
-## Events
+// src/tools/behaviorspec-extras.ts
+var behaviorSpecParser = null;
+var behaviorCompiler = null;
+var behaviorRenderer = null;
+async function getBehaviorSpecExtras() {
+  if (behaviorSpecParser)
+    return { parseSpec: behaviorSpecParser, compile: behaviorCompiler, render: behaviorRenderer };
+  try {
+    const mod = await import("@lokascript/domain-behaviorspec");
+    behaviorSpecParser = mod.parseBehaviorSpec;
+    behaviorCompiler = mod.compileBehaviorSpec;
+    behaviorRenderer = mod.renderBehaviorSpec;
+    return { parseSpec: behaviorSpecParser, compile: behaviorCompiler, render: behaviorRenderer };
+  } catch {
+    throw new Error("@lokascript/domain-behaviorspec not available for multi-line parsing.");
+  }
+}
+function serializeRoles2(roles) {
+  const result = {};
+  for (const [key, value] of roles) {
+    result[key] = value;
+  }
+  return result;
+}
+function isMultiLineBehaviorSpec(args) {
+  const scenario = getString(args, "scenario");
+  return scenario.includes("\n");
+}
+async function handleBehaviorSpecMultiLine(name, args) {
+  const scenario = getString(args, "scenario");
+  if (!scenario) return errorResponse("Missing required parameter: scenario");
+  try {
+    const { parseSpec, compile, render } = await getBehaviorSpecExtras();
+    const operation = name.replace("_behaviorspec", "");
+    if (operation === "parse") {
+      const language = getString(args, "language", "en");
+      const result = parseSpec(scenario, language);
+      return jsonResponse({
+        type: "spec",
+        testCount: result.tests.length,
+        tests: result.tests.map((test) => ({
+          name: test.name,
+          givenCount: test.givens.length,
+          interactionCount: test.interactions.length,
+          givens: test.givens.map((g) => ({
+            action: g.action,
+            roles: serializeRoles2(g.roles)
+          })),
+          interactions: test.interactions.map((i) => ({
+            when: { action: i.when.action, roles: serializeRoles2(i.when.roles) },
+            expectationCount: i.expectations.length
+          }))
+        })),
+        errors: result.errors,
+        language
+      });
+    }
+    if (operation === "compile") {
+      const language = getString(args, "language", "en");
+      const code = compile(scenario, language);
+      return jsonResponse({ ok: true, code, language });
+    }
+    if (operation === "validate") {
+      const language = getString(args, "language", "en");
+      const result = parseSpec(scenario, language);
+      return jsonResponse({
+        valid: result.errors.length === 0,
+        testCount: result.tests.length,
+        errorCount: result.errors.length,
+        errors: result.errors,
+        language
+      });
+    }
+    if (operation === "translate") {
+      const from = getString(args, "from");
+      const to = getString(args, "to");
+      if (!from || !to) return errorResponse("Missing required parameter: from, to");
+      const result = parseSpec(scenario, from);
+      const renderedTests = [];
+      for (const test of result.tests) {
+        const lines = [];
+        lines.push(`test "${test.name}"`);
+        for (const given of test.givens) {
+          lines.push(`  ${render(given, to)}`);
+        }
+        for (const interaction of test.interactions) {
+          lines.push(`  ${render(interaction.when, to)}`);
+          for (const exp of interaction.expectations) {
+            lines.push(`    ${render(exp.node, to)}`);
+          }
+        }
+        renderedTests.push(lines.join("\n"));
+      }
+      return jsonResponse({
+        input: { scenario, language: from },
+        translated: renderedTests.join("\n\n"),
+        playwright: compile(scenario, from),
+        errors: result.errors
+      });
+    }
+    return errorResponse(`Unknown BehaviorSpec operation: ${operation}`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return errorResponse(`BehaviorSpec multi-line error: ${message}`);
+  }
+}
 
-| Command | Usage | Example |
-|---------|-------|---------|
+// src/prompts/index.ts
+var LLM_PROMPTS = [
+  {
+    name: "llm_ask",
+    description: "Ask an LLM a question with optional context and response style",
+    arguments: [
+      { name: "question", description: "The question or prompt to ask", required: true },
+      {
+        name: "context",
+        description: "DOM selector, URL, or text to use as context",
+        required: false
+      },
+      {
+        name: "style",
+        description: "Response style: bullets, json, paragraph, brief",
+        required: false
+      },
+      { name: "model", description: "Model hint: claude, gpt, etc.", required: false }
+    ]
+  },
+  {
+    name: "llm_summarize",
+    description: "Summarize content using an LLM",
+    arguments: [
+      { name: "content", description: "Text or selector of content to summarize", required: true },
+      {
+        name: "length",
+        description: 'Target length: "3 sentences", "100 words", "2 paragraphs"',
+        required: false
+      },
+      {
+        name: "format",
+        description: "Output format: bullets, paragraph, tldr, markdown",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "llm_analyze",
+    description: "Analyze content for a specific quality (sentiment, entities, themes, etc.)",
+    arguments: [
+      { name: "content", description: "Text or selector of content to analyze", required: true },
+      {
+        name: "analysis_type",
+        description: "Analysis type: sentiment, entities, themes, tone, keywords",
+        required: true
+      }
+    ]
+  },
+  {
+    name: "llm_translate",
+    description: "Translate content between natural languages using an LLM",
+    arguments: [
+      { name: "content", description: "Text or selector of content to translate", required: true },
+      {
+        name: "from_language",
+        description: "Source language (english, spanish, japanese, etc.)",
+        required: true
+      },
+      {
+        name: "to_language",
+        description: "Target language (english, spanish, japanese, etc.)",
+        required: true
+      }
+    ]
+  }
+];
+function getLLMPromptDefinitions() {
+  return LLM_PROMPTS;
+}
+function renderLLMPrompt(name, args) {
+  switch (name) {
+    case "llm_ask":
+      return renderAskPrompt(args);
+    case "llm_summarize":
+      return renderSummarizePrompt(args);
+    case "llm_analyze":
+      return renderAnalyzePrompt(args);
+    case "llm_translate":
+      return renderTranslatePrompt(args);
+    default:
+      throw new Error(`Unknown LLM prompt: ${name}`);
+  }
+}
+function renderAskPrompt(args) {
+  const { question, context, style, model } = args;
+  let content = question || "(no question provided)";
+  if (context) content = `Context: ${context}
+
+${content}`;
+  if (style) content += `
+
+Please respond as: ${style}`;
+  const modelNote = model ? ` (using ${model})` : "";
+  return {
+    description: `Ask${modelNote}: ${question}`,
+    messages: [{ role: "user", content: { type: "text", text: content } }]
+  };
+}
+function renderSummarizePrompt(args) {
+  const { content, length, format } = args;
+  let text = `Please summarize the following content`;
+  if (length) text += ` in ${length}`;
+  if (format) text += ` as ${format}`;
+  text += `:
+
+${content || "(no content provided)"}`;
+  return {
+    description: `Summarize${length ? ` in ${length}` : ""}`,
+    messages: [{ role: "user", content: { type: "text", text } }]
+  };
+}
+function renderAnalyzePrompt(args) {
+  const { content, analysis_type } = args;
+  const text = `Please analyze the following content for ${analysis_type || "general insights"}:
+
+${content || "(no content provided)"}`;
+  return {
+    description: `Analyze as ${analysis_type}`,
+    messages: [{ role: "user", content: { type: "text", text } }]
+  };
+}
+function renderTranslatePrompt(args) {
+  const { content, from_language, to_language } = args;
+  const text = `Please translate the following from ${from_language || "the source language"} to ${to_language || "the target language"}:
+
+${content || "(no content provided)"}`;
+  return {
+    description: `Translate from ${from_language} to ${to_language}`,
+    messages: [{ role: "user", content: { type: "text", text } }]
+  };
+}
+
+// src/prompts/debug-prompts.ts
+var DEBUG_PROMPTS = [
+  {
+    name: "debug_explain_state",
+    description: "Explain the current debug state when paused in the HyperFixi debugger. Provide a snapshot of the execution state and get a human-friendly explanation.",
+    arguments: [
+      {
+        name: "snapshot",
+        description: "JSON-serialized DebugSnapshot: { commandName, element, variables, depth, index }",
+        required: true
+      },
+      {
+        name: "handler_code",
+        description: "The full hyperscript handler code for additional context",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "debug_why_wrong",
+    description: "Diagnose why a variable has an unexpected value during debugging. Provide the execution history and expected vs actual values.",
+    arguments: [
+      {
+        name: "variable",
+        description: 'The variable name (e.g., "it", ":count", "me")',
+        required: true
+      },
+      {
+        name: "expected",
+        description: "What the developer expected the value to be",
+        required: true
+      },
+      {
+        name: "actual",
+        description: "The actual value observed",
+        required: true
+      },
+      {
+        name: "history",
+        description: "JSON-serialized array of DebugSnapshot objects showing execution history",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "debug_suggest_breakpoints",
+    description: "Given hyperscript code and a description of the issue, suggest where to place breakpoints for effective debugging.",
+    arguments: [
+      {
+        name: "code",
+        description: "The hyperscript event handler code",
+        required: true
+      },
+      {
+        name: "issue",
+        description: 'Description of the problem to debug (e.g., "the counter does not increment")',
+        required: true
+      }
+    ]
+  }
+];
+function getDebugPromptDefinitions() {
+  return DEBUG_PROMPTS;
+}
+function renderDebugPrompt(name, args) {
+  switch (name) {
+    case "debug_explain_state":
+      return renderExplainState(args);
+    case "debug_why_wrong":
+      return renderWhyWrong(args);
+    case "debug_suggest_breakpoints":
+      return renderSuggestBreakpoints(args);
+    default:
+      throw new Error(`Unknown debug prompt: ${name}`);
+  }
+}
+function isDebugPrompt(name) {
+  return DEBUG_PROMPTS.some((p) => p.name === name);
+}
+function renderExplainState(args) {
+  const { snapshot, handler_code } = args;
+  let text = `I'm paused in the HyperFixi interactive debugger. Here is my current execution state:
+
+`;
+  text += `**Debug Snapshot:**
+\`\`\`json
+${snapshot}
+\`\`\`
+
+`;
+  if (handler_code) {
+    text += `**Full handler code:**
+\`\`\`hyperscript
+${handler_code}
+\`\`\`
+
+`;
+  }
+  text += `Please explain:
+`;
+  text += `1. What command is about to execute and what it will do
+`;
+  text += `2. What the current variable state tells us
+`;
+  text += `3. What will likely happen next
+`;
+  text += `4. Any potential issues you see in the state`;
+  return {
+    description: "Explain current debug state",
+    messages: [{ role: "user", content: { type: "text", text } }]
+  };
+}
+function renderWhyWrong(args) {
+  const { variable, expected, actual, history } = args;
+  let text = `I'm debugging a HyperFixi hyperscript handler and a variable has an unexpected value.
+
+`;
+  text += `**Variable:** \`${variable}\`
+`;
+  text += `**Expected:** ${expected}
+`;
+  text += `**Actual:** ${actual}
+
+`;
+  if (history) {
+    text += `**Execution history (DebugSnapshots):**
+\`\`\`json
+${history}
+\`\`\`
+
+`;
+  }
+  text += `Please analyze:
+`;
+  text += `1. What likely caused \`${variable}\` to be \`${actual}\` instead of \`${expected}\`
+`;
+  text += `2. Which command in the history is the most likely source of the problem
+`;
+  text += `3. How to fix it`;
+  return {
+    description: `Diagnose unexpected value of ${variable}`,
+    messages: [{ role: "user", content: { type: "text", text } }]
+  };
+}
+function renderSuggestBreakpoints(args) {
+  const { code, issue } = args;
+  let text = `I need to debug this HyperFixi hyperscript code:
+
+`;
+  text += `\`\`\`hyperscript
+${code}
+\`\`\`
+
+`;
+  text += `**Issue:** ${issue}
+
+`;
+  text += `Please suggest:
+`;
+  text += `1. Where to place breakpoints (by command name or element selector)
+`;
+  text += `2. What variables to watch at each breakpoint
+`;
+  text += `3. A step-by-step debugging strategy to isolate the issue`;
+  return {
+    description: `Debug strategy for: ${issue}`,
+    messages: [{ role: "user", content: { type: "text", text } }]
+  };
+}
+
+// src/prompts/lse-prompts.ts
+var LSE_PROMPTS = [
+  {
+    name: "lse_generate",
+    description: "Generate LokaScript Explicit Syntax (LSE) from a task description. Includes schema-aware system prompt context.",
+    arguments: [
+      {
+        name: "task",
+        description: 'Natural language description of what to do (e.g., "fetch users from API and show in a list")',
+        required: true
+      },
+      {
+        name: "domain",
+        description: "Domain to generate for (flow, sql, bdd, llm, jsx, todo, behaviorspec, voice). Default: flow",
+        required: false
+      },
+      {
+        name: "format",
+        description: "Output format: explicit (bracket syntax), json (LLM-simplified), or both. Default: explicit",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "lse_fix",
+    description: "Fix invalid LSE given the original input and diagnostic errors. Returns corrected LSE with explanation.",
+    arguments: [
+      {
+        name: "input",
+        description: "The invalid LSE bracket syntax or JSON that failed validation",
+        required: true
+      },
+      {
+        name: "errors",
+        description: "Error messages or diagnostic output from the validator",
+        required: true
+      },
+      {
+        name: "domain",
+        description: "Domain context (flow, sql, bdd, etc.). Helps narrow valid commands.",
+        required: false
+      }
+    ]
+  }
+];
+function getLSEPromptDefinitions() {
+  return LSE_PROMPTS;
+}
+function isLSEPrompt(name) {
+  return name === "lse_generate" || name === "lse_fix";
+}
+function renderLSEPrompt(name, args) {
+  switch (name) {
+    case "lse_generate":
+      return renderGeneratePrompt(args);
+    case "lse_fix":
+      return renderFixPrompt(args);
+    default:
+      throw new Error(`Unknown LSE prompt: ${name}`);
+  }
+}
+function renderGeneratePrompt(args) {
+  const { task, domain, format } = args;
+  const domainName = domain || "flow";
+  const outputFormat = format || "explicit";
+  const systemPrompt = buildLSESystemPrompt(domainName, outputFormat);
+  const userPrompt = task || "(no task provided)";
+  return {
+    description: `Generate LSE for: ${task}`,
+    messages: [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: `${systemPrompt}
+
+---
+
+**Task:** ${userPrompt}
+
+Generate the LSE output for this task.`
+        }
+      }
+    ]
+  };
+}
+function renderFixPrompt(args) {
+  const { input, errors, domain } = args;
+  const domainNote = domain ? ` in the ${domain} domain` : "";
+  const text = `You are fixing invalid LokaScript Explicit Syntax (LSE)${domainNote}.
+
+**Original input:**
+\`\`\`
+${input || "(no input provided)"}
+\`\`\`
+
+**Errors:**
+\`\`\`
+${errors || "(no errors provided)"}
+\`\`\`
+
+**Rules for fixing:**
+1. Preserve the original intent \u2014 only fix what's broken
+2. Use valid bracket syntax: \`[command role:value ...]\`
+3. All required roles must be present
+4. Value types must match the role's expected type
+5. Command names must be lowercase
+
+**Output:** Provide the corrected LSE and briefly explain what was wrong.`;
+  return {
+    description: `Fix LSE: ${(input || "").slice(0, 50)}...`,
+    messages: [{ role: "user", content: { type: "text", text } }]
+  };
+}
+function buildLSESystemPrompt(domain, format) {
+  const formatInstructions = format === "json" ? 'Output valid JSON in the full-fidelity format: { "kind": "command", "action": "...", "roles": { "roleName": { "type": "...", "value": "..." } } }' : format === "both" ? 'Output EITHER bracket syntax [command role:value ...] OR full-fidelity JSON { "kind": "command", "action": "...", "roles": { ... } }.' : "Output valid LSE bracket syntax: [command role:value ...]";
+  return `You are generating LokaScript Explicit Syntax (LSE) for the "${domain}" domain.
+
+**LSE Bracket Syntax:**
+- Commands: \`[action role1:value1 role2:value2 +flag]\`
+- No spaces around the colon in role:value pairs
+- Selectors: \`#id\`, \`.class\`, \`[attr]\`, \`@aria\`, \`*wild\`
+- Strings with spaces: \`"hello world"\`
+- References: \`me\`, \`you\`, \`it\`, \`result\`, \`event\`, \`target\`, \`body\`
+- Flags: \`+enabled\`, \`~disabled\`
+- Durations: \`500ms\`, \`2s\`, \`1m\`, \`1h\`
+- Compound: \`[add patient:.loading] then [fetch source:/api]\` (chain operators: then, and, async, sequential)
+
+**Event Handlers:**
+\`[on event:click body:[toggle patient:.active]]\`
+
+**Conditional (v1.1):**
+\`[if condition:"x > 0" then:[toggle patient:.active] else:[remove patient:.active]]\`
+
+**Loop (v1.1):**
+- \`[repeat loopVariant:forever body:[wait delay:1s]]\`
+- \`[repeat quantity:5 loopVariant:times body:[increment patient:#count]]\`
+- \`[repeat source:#items loopVariant:for loopVariable:item body:[add patient:.active]]\`
+- \`[repeat condition:"x > 0" loopVariant:while body:[decrement patient:#count]]\`
+
+**Pipe operator (v1.2):**
+\`[fetch source:/api/users] |> [put destination:#list]\` (threads output of left into right)
+- In JSON: compound node with \`chainType: "pipe"\`
+
+**Match / pattern dispatch (v1.2):**
+\`[match patient:status arms:[{pattern:"active" body:[show patient:#panel]},{pattern:"idle" body:[hide patient:#panel]}] defaultArm:[log patient:"unknown"]]\`
+- Arms are ordered; first match wins; \`defaultArm\` is the catch-all
+
+**Try / catch / finally (v1.2):**
+\`[try body:[fetch source:/api] catchBranch:[show patient:#error] finallyBranch:[remove patient:.loading]]\`
+- \`catchBranch\` and \`finallyBranch\` are both optional
+
+**Async coordination (v1.2):**
+- \`[all asyncBody:[fetch source:/api/users, fetch source:/api/posts]]\` \u2014 wait for all, fail fast
+- \`[race asyncBody:[fetch source:/cache, fetch source:/api]]\` \u2014 first to resolve wins
+
+**Annotations (v1.2):**
+\`@timeout(5s) @retry(3) [fetch source:/api/users]\`
+- In JSON: \`annotations: [{name:"timeout",value:"5s"},{name:"retry",value:"3"}]\` on the node
+- Annotations are metadata; they do not change command semantics
+
+**Value types:** selector, literal (string/number/boolean/duration), reference, expression, property-path, flag.
+
+**Node kinds (JSON):** command, event-handler, compound.
+- Conditionals are \`command\` nodes with \`thenBranch\`/\`elseBranch\` arrays.
+- Loops are \`command\` nodes with \`loopVariant\`, \`loopBody\`, \`loopVariable\`?, \`indexVariable\`?.
+- Try/catch is a \`command\` node with \`body\`, \`catchBranch\`?, \`finallyBranch\`? arrays.
+- Async is a \`command\` node with \`asyncVariant: "all"|"race"\` and \`asyncBody\` array.
+- Match is a \`command\` node with \`arms\` array and optional \`defaultArm\` array.
+
+**${formatInstructions}**
+
+Every value must have a role name. Do not invent commands or roles not in the schema. When unsure, use the "expression" value type.`;
+}
+
+// src/tools/llm-sampling.ts
+var samplingTools = [
+  {
+    name: "ask_claude",
+    description: "Ask Claude a question with optional context. Uses MCP sampling \u2014 the client handles model selection and user approval.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        question: {
+          type: "string",
+          description: "The question or prompt to ask"
+        },
+        context: {
+          type: "string",
+          description: "Optional context text to include with the question"
+        },
+        style: {
+          type: "string",
+          description: "Response style: bullets, json, paragraph, brief",
+          enum: ["bullets", "json", "paragraph", "brief"]
+        },
+        maxTokens: {
+          type: "number",
+          description: "Maximum tokens for the response (default: 1024)"
+        }
+      },
+      required: ["question"]
+    }
+  },
+  {
+    name: "summarize_content",
+    description: "Summarize text content using Claude. Uses MCP sampling \u2014 the client handles model selection and user approval.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        content: {
+          type: "string",
+          description: "Text content to summarize"
+        },
+        length: {
+          type: "string",
+          description: 'Target length: "3 sentences", "100 words", "2 paragraphs"'
+        },
+        format: {
+          type: "string",
+          description: "Output format: bullets, paragraph, tldr, markdown",
+          enum: ["bullets", "paragraph", "tldr", "markdown"]
+        },
+        maxTokens: {
+          type: "number",
+          description: "Maximum tokens for the response (default: 512)"
+        }
+      },
+      required: ["content"]
+    }
+  },
+  {
+    name: "analyze_content",
+    description: "Analyze text content for sentiment, entities, themes, or other qualities using Claude. Uses MCP sampling.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        content: {
+          type: "string",
+          description: "Text content to analyze"
+        },
+        analysis_type: {
+          type: "string",
+          description: "Analysis type: sentiment, entities, themes, tone, keywords",
+          enum: ["sentiment", "entities", "themes", "tone", "keywords"]
+        },
+        maxTokens: {
+          type: "number",
+          description: "Maximum tokens for the response (default: 512)"
+        }
+      },
+      required: ["content", "analysis_type"]
+    }
+  },
+  {
+    name: "translate_content",
+    description: "Translate text between natural languages using Claude. Uses MCP sampling \u2014 the client handles model selection and user approval.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        content: {
+          type: "string",
+          description: "Text content to translate"
+        },
+        from_language: {
+          type: "string",
+          description: "Source language (english, spanish, japanese, etc.)"
+        },
+        to_language: {
+          type: "string",
+          description: "Target language (english, spanish, japanese, etc.)"
+        },
+        maxTokens: {
+          type: "number",
+          description: "Maximum tokens for the response (default: 1024)"
+        }
+      },
+      required: ["content", "from_language", "to_language"]
+    }
+  },
+  {
+    name: "execute_llm",
+    description: 'Execute an LLM command written in natural language (8 languages supported). Compiles via domain-llm then invokes Claude via MCP sampling. Examples: "ask what is 2+2", "summarize #article as bullets", "\uC694\uC57D \uC774 \uBB38\uC11C\uB97C \uAE00\uBA38\uB9AC\uB85C" (Korean).',
+    inputSchema: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: 'LLM command in natural language (e.g., "ask what is the capital of France")'
+        },
+        language: {
+          type: "string",
+          description: "Language code for the command (en, es, ja, ar, ko, zh, tr, fr). Default: en",
+          default: "en"
+        }
+      },
+      required: ["command"]
+    }
+  }
+];
+function specToSamplingParams(spec) {
+  const systemMessages = spec.messages.filter((m) => m.role === "system");
+  const chatMessages = spec.messages.filter((m) => m.role !== "system");
+  return {
+    systemPrompt: systemMessages.length ? systemMessages.map((m) => m.content).join("\n") : void 0,
+    messages: chatMessages.map((m) => ({
+      role: m.role,
+      content: { type: "text", text: m.content }
+    })),
+    maxTokens: spec.maxTokens ?? 1024,
+    ...spec.modelPreferences && { modelPreferences: spec.modelPreferences }
+  };
+}
+function argsToSpec(name, args) {
+  switch (name) {
+    case "ask_claude":
+      return buildAskSpec(args);
+    case "summarize_content":
+      return buildSummarizeSpec(args);
+    case "analyze_content":
+      return buildAnalyzeSpec(args);
+    case "translate_content":
+      return buildTranslateSpec(args);
+    default:
+      throw new Error(`Unknown sampling tool: ${name}`);
+  }
+}
+function buildAskSpec(args) {
+  const question = String(args.question || "");
+  const context = args.context ? String(args.context) : void 0;
+  const style = args.style ? String(args.style) : void 0;
+  const styleInstruction = style ? `Respond in ${style} format.` : "Respond clearly and concisely.";
+  const messages = [{ role: "system", content: styleInstruction }];
+  if (context) {
+    messages.push({ role: "user", content: `Context:
+${context}` });
+  }
+  messages.push({ role: "user", content: question });
+  return {
+    action: "ask",
+    messages,
+    maxTokens: typeof args.maxTokens === "number" ? args.maxTokens : 1024,
+    metadata: {
+      sourceLanguage: "en",
+      roles: { patient: question, source: context, manner: style }
+    }
+  };
+}
+function buildSummarizeSpec(args) {
+  const content = String(args.content || "");
+  const length = args.length ? String(args.length) : void 0;
+  const format = args.format ? String(args.format) : void 0;
+  const lengthHint = length ? ` in ${length}` : "";
+  const formatHint = format ? ` as ${format}` : "";
+  return {
+    action: "summarize",
+    messages: [
+      {
+        role: "system",
+        content: `You are a summarization assistant. Provide concise${formatHint} summaries${lengthHint}.`
+      },
+      { role: "user", content: `Summarize the following:
+
+${content}` }
+    ],
+    maxTokens: typeof args.maxTokens === "number" ? args.maxTokens : 512,
+    metadata: {
+      sourceLanguage: "en",
+      roles: { patient: content, quantity: length, manner: format }
+    }
+  };
+}
+function buildAnalyzeSpec(args) {
+  const content = String(args.content || "");
+  const analysisType = String(args.analysis_type || "general quality");
+  return {
+    action: "analyze",
+    messages: [
+      {
+        role: "system",
+        content: `You are an analysis assistant. Analyze content for ${analysisType}. Be specific and structured in your response.`
+      },
+      {
+        role: "user",
+        content: `Analyze the following for ${analysisType}:
+
+${content}`
+      }
+    ],
+    maxTokens: typeof args.maxTokens === "number" ? args.maxTokens : 512,
+    metadata: {
+      sourceLanguage: "en",
+      roles: { patient: content, manner: analysisType }
+    }
+  };
+}
+function buildTranslateSpec(args) {
+  const content = String(args.content || "");
+  const fromLang = String(args.from_language || "the source language");
+  const toLang = String(args.to_language || "English");
+  return {
+    action: "translate",
+    messages: [
+      {
+        role: "system",
+        content: `You are a professional translator. Translate accurately from ${fromLang} to ${toLang}. Preserve tone and meaning. Return only the translation without explanation.`
+      },
+      {
+        role: "user",
+        content: `Translate from ${fromLang} to ${toLang}:
+
+${content}`
+      }
+    ],
+    maxTokens: typeof args.maxTokens === "number" ? args.maxTokens : 2048,
+    metadata: {
+      sourceLanguage: "en",
+      roles: { patient: content, source: fromLang, destination: toLang }
+    }
+  };
+}
+async function handleSamplingTool(name, args, server2, registry2) {
+  try {
+    if (name === "execute_llm") {
+      return await handleExecuteLLM(args, server2, registry2);
+    }
+    const spec = argsToSpec(name, args);
+    return await executeSpec(spec, server2);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      content: [{ type: "text", text: `Sampling error: ${message}` }],
+      isError: true
+    };
+  }
+}
+async function executeSpec(spec, server2) {
+  const params = specToSamplingParams(spec);
+  const response = await server2.createMessage(params);
+  const text = response.content.type === "text" ? response.content.text : `Received non-text response of type: ${response.content.type}`;
+  return { content: [{ type: "text", text }] };
+}
+async function handleExecuteLLM(args, server2, registry2) {
+  if (!registry2) {
+    return {
+      content: [{ type: "text", text: "execute_llm requires domain registry (internal error)" }],
+      isError: true
+    };
+  }
+  const command = String(args.command || "");
+  const language = String(args.language || "en");
+  if (!command.trim()) {
+    return {
+      content: [{ type: "text", text: "execute_llm requires a non-empty command" }],
+      isError: true
+    };
+  }
+  const dsl = await registry2.getDSLForDomain("llm");
+  if (!dsl) {
+    return {
+      content: [{ type: "text", text: "LLM domain not registered" }],
+      isError: true
+    };
+  }
+  const result = dsl.compile(command, language);
+  if (!result.ok || !result.code) {
+    const errors = result.errors?.join(", ") || "Unknown compilation error";
+    return {
+      content: [{ type: "text", text: `Compilation failed: ${errors}` }],
+      isError: true
+    };
+  }
+  let spec;
+  try {
+    spec = JSON.parse(result.code);
+  } catch {
+    return {
+      content: [{ type: "text", text: `Invalid LLMPromptSpec JSON: ${result.code}` }],
+      isError: true
+    };
+  }
+  return await executeSpec(spec, server2);
+}
+
+// src/tools/dispatcher.ts
+import { CrossDomainDispatcher } from "@lokascript/framework";
+var dispatcher = null;
+function getDispatcher(registry2) {
+  if (!dispatcher) {
+    dispatcher = new CrossDomainDispatcher(registry2, {
+      minConfidence: 0.5,
+      // Domains with more specific schemas should win over generic catch-all domains
+      // when confidence scores are close. voice/flow have broad patterns that match
+      // inputs intended for sql/bdd/todo/jsx.
+      priority: ["sql", "bdd", "behaviorspec", "jsx", "todo", "llm", "flow", "voice"]
+    });
+  }
+  return dispatcher;
+}
+function serializeRoles3(roles) {
+  const result = {};
+  for (const [key, value] of roles) {
+    result[key] = value;
+  }
+  return result;
+}
+var dispatcherTools = [
+  {
+    name: "detect_domain",
+    description: "Auto-detect which registered domain handles the input. Tries all domains (sql, bdd, jsx, todo, behaviorspec, llm, flow, voice) and returns the best match by confidence score.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "The natural-language input to classify"
+        },
+        language: {
+          type: "string",
+          description: "Language code (en, es, ja, ar, ko, zh, tr, fr). Default: en",
+          default: "en"
+        }
+      },
+      required: ["input"]
+    }
+  },
+  {
+    name: "parse_composite",
+    description: "Parse multi-line input where each line may belong to a different domain. Skips blank and comment lines (//, --, #). Returns per-line results with domain, action, roles, and confidence.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "Multi-line input text. Each non-blank line is matched to the best domain."
+        },
+        language: {
+          type: "string",
+          description: "Language code (en, es, ja, ar, ko, zh, tr, fr). Default: en",
+          default: "en"
+        }
+      },
+      required: ["input"]
+    }
+  },
+  {
+    name: "compile_auto",
+    description: "Auto-detect domain and compile in one shot. Returns compiled output along with the detected domain name.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "The natural-language input to compile"
+        },
+        language: {
+          type: "string",
+          description: "Language code (en, es, ja, ar, ko, zh, tr, fr). Default: en",
+          default: "en"
+        }
+      },
+      required: ["input"]
+    }
+  },
+  {
+    name: "compile_composite",
+    description: "Compile multi-line input where each line may belong to a different domain. Lines are auto-detected and compiled via their domain. Supports natural language and explicit bracket syntax. Skips blank and comment lines (//, --, #).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "Multi-line input text. Each non-blank line is detected and compiled."
+        },
+        language: {
+          type: "string",
+          description: "Language code (en, es, ja, ar, ko, zh, tr, fr). Default: en",
+          default: "en"
+        }
+      },
+      required: ["input"]
+    }
+  }
+];
+async function handleDispatcherTool(name, args, registry2) {
+  const input = getString(args, "input");
+  if (!input) return errorResponse("Missing required parameter: input");
+  const language = getString(args, "language", "en");
+  const dispatch = getDispatcher(registry2);
+  try {
+    switch (name) {
+      case "detect_domain":
+        return handleDetect(dispatch, input, language);
+      case "parse_composite":
+        return handleParseComposite(dispatch, input, language);
+      case "compile_auto":
+        return handleCompileAuto(dispatch, input, language);
+      case "compile_composite":
+        return handleCompileComposite(dispatch, input, language);
+      default:
+        return errorResponse(`Unknown dispatcher tool: ${name}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return errorResponse(`Dispatcher error: ${message}`);
+  }
+}
+async function handleDetect(dispatch, input, language) {
+  const result = await dispatch.detect(input, language);
+  if (!result) {
+    return jsonResponse({
+      domain: null,
+      reason: "No domain matched this input above the confidence threshold",
+      input,
+      language
+    });
+  }
+  return jsonResponse({
+    domain: result.domain,
+    action: result.node.action,
+    roles: serializeRoles3(result.node.roles),
+    confidence: result.confidence,
+    language
+  });
+}
+async function handleParseComposite(dispatch, input, language) {
+  const result = await dispatch.parseComposite(input, language);
+  return jsonResponse({
+    statements: result.statements.map((s) => ({
+      line: s.line,
+      input: s.input,
+      domain: s.domain,
+      action: s.node.action,
+      roles: serializeRoles3(s.node.roles),
+      confidence: s.confidence
+    })),
+    errors: result.errors,
+    language,
+    summary: {
+      matched: result.statements.length,
+      unmatched: result.errors.length,
+      domains: [...new Set(result.statements.map((s) => s.domain))]
+    }
+  });
+}
+async function handleCompileComposite(dispatch, input, language) {
+  const result = await dispatch.compileComposite(input, language);
+  return jsonResponse({
+    statements: result.statements.map((s) => ({
+      line: s.line,
+      input: s.input,
+      domain: s.domain,
+      ok: s.ok,
+      code: s.code ?? null,
+      errors: s.errors ?? []
+    })),
+    errors: result.errors,
+    language,
+    summary: {
+      compiled: result.statements.length,
+      succeeded: result.statements.filter((s) => s.ok).length,
+      failed: result.statements.filter((s) => !s.ok).length,
+      unmatched: result.errors.length,
+      domains: [...new Set(result.statements.map((s) => s.domain))]
+    }
+  });
+}
+async function handleCompileAuto(dispatch, input, language) {
+  const result = await dispatch.compile(input, language);
+  if (!result) {
+    return jsonResponse({
+      domain: null,
+      ok: false,
+      errors: ["No domain matched this input"],
+      input,
+      language
+    });
+  }
+  return jsonResponse({
+    domain: result.domain,
+    ok: result.ok,
+    code: result.code ?? null,
+    errors: result.errors ?? [],
+    language
+  });
+}
+
+// src/tools/ir-tools.ts
+import {
+  parseExplicit,
+  renderExplicit,
+  fromProtocolJSON,
+  toProtocolJSON,
+  validateProtocolJSON,
+  toEnvelopeJSON,
+  fromEnvelopeJSON,
+  isEnvelope,
+  fromInterchangeNode
+} from "@lokascript/framework";
+var irTools = [
+  {
+    name: "convert_format",
+    description: "Convert between explicit bracket syntax, LLM JSON, and InterchangeNode AST without compilation. Provide `explicit` (bracket syntax), `semantic` (JSON), or `interchange` (InterchangeNode AST). Returns both explicit and protocol JSON formats for bidirectional use. Tip: use lse_from_hyperscript to parse natural hyperscript into LSE first, then pipe its output here.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        explicit: {
+          type: "string",
+          description: "Explicit syntax to convert: [command role:value ...]"
+        },
+        interchange: {
+          type: "object",
+          description: 'InterchangeNode AST object (from core or semantic parser). Must have a `type` discriminant field (e.g., "command", "event", "if", "repeat", etc.).',
+          properties: {
+            type: { type: "string", description: "Node type discriminant" }
+          }
+        },
+        semantic: {
+          type: "object",
+          description: 'Protocol JSON to convert. `kind` is optional (defaults to "command"). `trigger` is convenience sugar that wraps a command in an event handler. Full form: { kind?, action, roles, trigger?, body?, statements?, chainType?, thenBranch?, elseBranch?, loopVariant?, loopBody?, loopVariable?, indexVariable?, catchBranch?, finallyBranch?, asyncVariant?, asyncBody?, arms?, defaultArm?, annotations?, diagnostics? }. Envelope: { lseVersion, nodes[], features? }.',
+          properties: {
+            kind: {
+              type: "string",
+              enum: ["command", "event-handler", "compound"],
+              description: 'Node kind (optional, defaults to "command")'
+            },
+            action: { type: "string" },
+            roles: { type: "object" },
+            trigger: {
+              type: "object",
+              description: "Convenience sugar: wraps command in event handler. { event: string, modifiers?: object }"
+            },
+            body: {
+              type: "array",
+              description: "Event handler body commands (event-handler nodes)"
+            },
+            statements: {
+              type: "array",
+              description: "Chained commands (compound nodes)"
+            },
+            chainType: {
+              type: "string",
+              enum: ["then", "and", "async", "sequential", "pipe"],
+              description: "Chain operator (compound nodes)"
+            },
+            thenBranch: {
+              type: "array",
+              description: "Then-branch commands (v1.1 conditional)"
+            },
+            elseBranch: {
+              type: "array",
+              description: "Else-branch commands (v1.1 conditional)"
+            },
+            loopVariant: {
+              type: "string",
+              enum: ["forever", "times", "for", "while", "until"],
+              description: "Loop variant (v1.1 loop)"
+            },
+            loopBody: {
+              type: "array",
+              description: "Loop body commands (v1.1 loop)"
+            },
+            loopVariable: {
+              type: "string",
+              description: "Loop iteration variable name (v1.1 loop)"
+            },
+            indexVariable: {
+              type: "string",
+              description: "Optional loop index variable name (v1.1 loop)"
+            },
+            catchBranch: {
+              type: "array",
+              description: "Catch branch commands (v1.2 try/catch)"
+            },
+            finallyBranch: {
+              type: "array",
+              description: "Finally branch commands (v1.2 try/finally)"
+            },
+            asyncVariant: {
+              type: "string",
+              enum: ["all", "race"],
+              description: "Async coordination variant (v1.2)"
+            },
+            asyncBody: {
+              type: "array",
+              description: "Async body commands (v1.2)"
+            },
+            arms: {
+              type: "array",
+              description: "Match arms \u2014 array of { pattern, body } (v1.2)"
+            },
+            defaultArm: {
+              type: "array",
+              description: "Default match arm commands (v1.2)"
+            },
+            annotations: {
+              type: "array",
+              description: "Metadata annotations \u2014 array of { name, value? } (v1.2)"
+            },
+            diagnostics: {
+              type: "array",
+              description: "Type constraint diagnostics \u2014 array of { level, role, message, code } (v1.2)"
+            }
+          }
+        }
+      }
+    }
+  },
+  {
+    name: "validate_explicit",
+    description: "Validate explicit bracket syntax like `[toggle patient:.active]` without full compilation. Faster than validate_and_compile. Use ONLY for bracket syntax input, not natural language hyperscript.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        explicit: {
+          type: "string",
+          description: "Explicit syntax to validate: [command role:value ...]"
+        }
+      },
+      required: ["explicit"]
+    }
+  },
+  {
+    name: "validate_protocol",
+    description: "Validate a protocol JSON node (v1.1/v1.2). Returns diagnostics for any structural issues.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        json: {
+          type: "object",
+          description: "Protocol JSON node to validate (must have `kind` field)"
+        }
+      },
+      required: ["json"]
+    }
+  },
+  {
+    name: "to_envelope",
+    description: "Wrap one or more protocol JSON nodes into an LSE v1.2 envelope with version metadata and feature flags.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        nodes: {
+          type: "array",
+          description: "Array of protocol JSON nodes (or explicit bracket strings to parse first)"
+        },
+        version: {
+          type: "string",
+          description: 'LSE version string (default: "1.2")'
+        }
+      },
+      required: ["nodes"]
+    }
+  },
+  {
+    name: "from_envelope",
+    description: "Unwrap an LSE v1.2 envelope into its constituent semantic nodes and metadata.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        envelope: {
+          type: "object",
+          description: "LSE envelope JSON: { lseVersion, nodes[], features? }"
+        }
+      },
+      required: ["envelope"]
+    }
+  }
+];
+async function handleIRTool(name, args) {
+  try {
+    switch (name) {
+      case "convert_format":
+        return handleConvertFormat(args);
+      case "validate_explicit":
+        return handleValidateExplicit(args);
+      case "validate_protocol":
+        return handleValidateProtocol(args);
+      case "to_envelope":
+        return handleToEnvelope(args);
+      case "from_envelope":
+        return handleFromEnvelope(args);
+      default:
+        return errorResponse(`Unknown IR tool: ${name}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return errorResponse(`IR tool error: ${message}`);
+  }
+}
+function handleConvertFormat(args) {
+  const explicitInput = typeof args.explicit === "string" ? args.explicit : void 0;
+  const interchangeInput = typeof args.interchange === "object" && args.interchange ? args.interchange : void 0;
+  const semanticInput = typeof args.semantic === "object" && args.semantic ? args.semantic : void 0;
+  if (!explicitInput && !interchangeInput && !semanticInput) {
+    return errorResponse(
+      "Provide `explicit` (bracket syntax), `interchange` (InterchangeNode AST), or `semantic` (JSON)."
+    );
+  }
+  if (explicitInput) {
+    const node2 = parseExplicit(explicitInput);
+    return jsonResponse({
+      ok: true,
+      explicit: renderExplicit(node2),
+      semantic: toProtocolJSON(node2)
+    });
+  }
+  if (interchangeInput) {
+    const input2 = interchangeInput;
+    if (!input2.type || typeof input2.type !== "string") {
+      return errorResponse("InterchangeNode must have a `type` string field.");
+    }
+    const node2 = fromInterchangeNode(input2);
+    return jsonResponse({
+      ok: true,
+      explicit: renderExplicit(node2),
+      semantic: toProtocolJSON(node2)
+    });
+  }
+  const input = semanticInput;
+  if (isEnvelope(input)) {
+    const envelope = fromEnvelopeJSON(input);
+    const results = envelope.nodes.map((node2) => ({
+      explicit: renderExplicit(node2),
+      semantic: toProtocolJSON(node2)
+    }));
+    return jsonResponse({
+      ok: true,
+      envelope: { lseVersion: envelope.lseVersion, features: envelope.features },
+      nodes: results
+    });
+  }
+  const diagnostics = validateProtocolJSON(input);
+  const errors = diagnostics.filter((d) => d.severity === "error");
+  if (errors.length > 0) {
+    return jsonResponse({ ok: false, diagnostics: errors });
+  }
+  const node = fromProtocolJSON(input);
+  return jsonResponse({
+    ok: true,
+    explicit: renderExplicit(node),
+    semantic: toProtocolJSON(node)
+  });
+}
+function handleValidateExplicit(args) {
+  const explicit = typeof args.explicit === "string" ? args.explicit : void 0;
+  if (!explicit) {
+    return errorResponse("Missing required parameter: explicit");
+  }
+  try {
+    const node = parseExplicit(explicit);
+    const json = toProtocolJSON(node);
+    return jsonResponse({
+      ok: true,
+      semantic: json,
+      diagnostics: []
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return jsonResponse({
+      ok: false,
+      diagnostics: [
+        {
+          severity: "error",
+          code: "EXPLICIT_PARSE_ERROR",
+          message
+        }
+      ]
+    });
+  }
+}
+function handleValidateProtocol(args) {
+  const json = typeof args.json === "object" && args.json ? args.json : void 0;
+  if (!json) {
+    return errorResponse("Missing required parameter: json");
+  }
+  const diagnostics = validateProtocolJSON(json);
+  const errors = diagnostics.filter((d) => d.severity === "error");
+  const warnings = diagnostics.filter((d) => d.severity === "warning");
+  return jsonResponse({
+    ok: errors.length === 0,
+    errors,
+    warnings
+  });
+}
+function handleToEnvelope(args) {
+  const nodes = Array.isArray(args.nodes) ? args.nodes : void 0;
+  if (!nodes || nodes.length === 0) {
+    return errorResponse("Missing required parameter: nodes (non-empty array)");
+  }
+  const semanticNodes = nodes.map((n, i) => {
+    if (typeof n === "string") {
+      return parseExplicit(n);
+    }
+    if (typeof n === "object" && n) {
+      const diags = validateProtocolJSON(n);
+      const errs = diags.filter((d) => d.severity === "error");
+      if (errs.length > 0) {
+        throw new Error(`Node ${i}: ${errs.map((e) => e.message).join("; ")}`);
+      }
+      return fromProtocolJSON(n);
+    }
+    throw new Error(`Node ${i}: must be a string (explicit) or object (protocol JSON)`);
+  });
+  const version = typeof args.version === "string" ? args.version : "1.2";
+  const envelope = toEnvelopeJSON({ lseVersion: version, nodes: semanticNodes });
+  return jsonResponse({
+    ok: true,
+    envelope
+  });
+}
+function handleFromEnvelope(args) {
+  const envelope = typeof args.envelope === "object" && args.envelope ? args.envelope : void 0;
+  if (!envelope) {
+    return errorResponse("Missing required parameter: envelope");
+  }
+  if (!isEnvelope(envelope)) {
+    return errorResponse("Invalid envelope: must have `lseVersion` and `nodes` fields");
+  }
+  const result = fromEnvelopeJSON(envelope);
+  const nodes = result.nodes.map((node) => ({
+    explicit: renderExplicit(node),
+    semantic: toProtocolJSON(node)
+  }));
+  return jsonResponse({
+    ok: true,
+    lseVersion: result.lseVersion,
+    features: result.features,
+    nodes
+  });
+}
+
+// src/tools/debug-tools.ts
+var debugTools = [
+  {
+    name: "debug_analyze_snapshot",
+    description: "Analyze a HyperFixi debug snapshot. Given the current command, element, variables, and execution depth, explains what the command does, what state is available, and predicts what will happen next. Use when a developer is paused in the debugger and wants to understand the current state.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        snapshot: {
+          type: "object",
+          description: "A DebugSnapshot object: { commandName, element, variables, timestamp, depth, index }",
+          properties: {
+            commandName: {
+              type: "string",
+              description: "The hyperscript command about to execute"
+            },
+            element: {
+              type: "string",
+              description: 'Description of the target element, e.g. "<button#submit.primary>"'
+            },
+            variables: {
+              type: "object",
+              description: "Map of variable names to values (it, result, me, :locals, event.type, etc.)"
+            },
+            depth: { type: "number", description: "Nesting depth (0 = top-level)" },
+            index: { type: "number", description: "Sequential command index" }
+          },
+          required: ["commandName"]
+        }
+      },
+      required: ["snapshot"]
+    }
+  },
+  {
+    name: "debug_explain_handler",
+    description: "Explain a hyperscript event handler step-by-step. Given the full handler code, breaks down what each command does, identifies potential issues (null references, missing elements, type mismatches), and suggests where to set breakpoints for debugging.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        code: {
+          type: "string",
+          description: 'The full hyperscript event handler code (e.g., "on click toggle .active on me then add .clicked")'
+        },
+        issue: {
+          type: "string",
+          description: 'Optional description of the problem being debugged (e.g., "the class is not toggling")'
+        }
+      },
+      required: ["code"]
+    }
+  },
+  {
+    name: "debug_suggest_fix",
+    description: "Given a debug snapshot where something went wrong (unexpected variable value, wrong element, error), analyze the state and suggest likely causes and fixes. Combines debug state analysis with hyperscript diagnostics.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        snapshot: {
+          type: "object",
+          description: "The DebugSnapshot at the point of failure",
+          properties: {
+            commandName: { type: "string" },
+            element: { type: "string" },
+            variables: { type: "object" },
+            depth: { type: "number" },
+            index: { type: "number" }
+          },
+          required: ["commandName"]
+        },
+        expected: {
+          type: "string",
+          description: 'What the developer expected to happen (e.g., "it should be 5 but it is null")'
+        },
+        error: {
+          type: "string",
+          description: "Error message if an exception occurred"
+        }
+      },
+      required: ["snapshot"]
+    }
+  },
+  {
+    name: "debug_trace_variable",
+    description: "Given an array of debug snapshots (execution history) and a variable name, trace how that variable changed over time. Shows each step where the variable was modified, its old and new values, and which command caused the change.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        history: {
+          type: "array",
+          description: "Array of DebugSnapshot objects from the execution history",
+          items: {
+            type: "object",
+            properties: {
+              commandName: { type: "string" },
+              variables: { type: "object" },
+              index: { type: "number" }
+            }
+          }
+        },
+        variable: {
+          type: "string",
+          description: 'The variable name to trace (e.g., "it", ":count", "me")'
+        }
+      },
+      required: ["history", "variable"]
+    }
+  }
+];
+async function handleDebugTool(name, args) {
+  try {
+    switch (name) {
+      case "debug_analyze_snapshot":
+        return analyzeSnapshot(args.snapshot);
+      case "debug_explain_handler":
+        return explainHandler(args.code, args.issue);
+      case "debug_suggest_fix":
+        return suggestFix(
+          args.snapshot,
+          args.expected,
+          args.error
+        );
+      case "debug_trace_variable":
+        return traceVariable(
+          args.history,
+          args.variable
+        );
+      default:
+        return {
+          content: [{ type: "text", text: `Unknown debug tool: ${name}` }],
+          isError: true
+        };
+    }
+  } catch (err) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Debug tool error: ${err instanceof Error ? err.message : String(err)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+function analyzeSnapshot(snapshot) {
+  const cmd = snapshot.commandName;
+  const element = snapshot.element;
+  const variables = snapshot.variables || {};
+  const depth = snapshot.depth || 0;
+  const index = snapshot.index || 0;
+  const analysis = [];
+  analysis.push(`## Debug Snapshot Analysis (Step ${index})`);
+  analysis.push("");
+  analysis.push(`**Current Command:** \`${cmd}\``);
+  analysis.push(
+    `**Nesting Depth:** ${depth} ${depth === 0 ? "(top-level)" : `(${depth} level${depth > 1 ? "s" : ""} deep)`}`
+  );
+  if (element) {
+    analysis.push(`**Target Element:** \`${element}\``);
+  }
+  const insight = getCommandInsight(cmd);
+  if (insight) {
+    analysis.push("");
+    analysis.push(`**What this command does:** ${insight}`);
+  }
+  const varEntries = Object.entries(variables);
+  if (varEntries.length > 0) {
+    analysis.push("");
+    analysis.push("**Available State:**");
+    for (const [name, value] of varEntries) {
+      analysis.push(`- \`${name}\` = \`${formatVal(value)}\``);
+    }
+  }
+  const warnings = detectIssues(cmd, element, variables);
+  if (warnings.length > 0) {
+    analysis.push("");
+    analysis.push("**Potential Issues:**");
+    for (const w of warnings) {
+      analysis.push(`- ${w}`);
+    }
+  }
+  return { content: [{ type: "text", text: analysis.join("\n") }] };
+}
+function explainHandler(code, issue) {
+  if (!code) {
+    return {
+      content: [{ type: "text", text: "Error: code parameter is required" }],
+      isError: true
+    };
+  }
+  const lines = [];
+  lines.push("## Event Handler Analysis");
+  lines.push("");
+  lines.push("```hyperscript");
+  lines.push(code);
+  lines.push("```");
+  lines.push("");
+  const commands = code.replace(/^on\s+\w+\s*/, "").split(/\s+then\s+/).map((c) => c.trim()).filter(Boolean);
+  lines.push("**Step-by-step breakdown:**");
+  commands.forEach((cmd, i) => {
+    lines.push(`${i + 1}. \`${cmd}\``);
+    const insight = getCommandInsightFromCode(cmd);
+    if (insight) lines.push(`   ${insight}`);
+  });
+  lines.push("");
+  lines.push("**Suggested breakpoints:**");
+  const bpSuggestions = suggestBreakpoints(commands, issue);
+  for (const bp of bpSuggestions) {
+    lines.push(`- ${bp}`);
+  }
+  if (issue) {
+    lines.push("");
+    lines.push(`**Regarding "${issue}":**`);
+    lines.push(diagnoseIssue(commands, issue));
+  }
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+function suggestFix(snapshot, expected, error) {
+  const cmd = snapshot.commandName;
+  const element = snapshot.element;
+  const variables = snapshot.variables || {};
+  const lines = [];
+  lines.push("## Debug Fix Suggestions");
+  lines.push("");
+  lines.push(`**Failed at:** \`${cmd}\``);
+  if (error) {
+    lines.push(`**Error:** ${error}`);
+    lines.push("");
+    lines.push("**Likely causes:**");
+    const causes = diagnosError(cmd, error, variables);
+    for (const c of causes) {
+      lines.push(`- ${c}`);
+    }
+  }
+  if (expected) {
+    lines.push("");
+    lines.push(`**Expected:** ${expected}`);
+    lines.push("");
+    lines.push("**Analysis:**");
+    if (variables["it"] === null || variables["it"] === void 0) {
+      lines.push("- `it` is null/undefined. The previous command may not have returned a value.");
+      lines.push("  Check if a `get` or `fetch` command ran successfully before this step.");
+    }
+    if (!element) {
+      lines.push("- No target element. The CSS selector may not match any element on the page.");
+    }
+  }
+  lines.push("");
+  lines.push("**Suggested fixes:**");
+  const fixes = generateFixes(cmd, element, variables, error);
+  for (const f of fixes) {
+    lines.push(`- ${f}`);
+  }
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+function traceVariable(history, variable) {
+  if (!history || !Array.isArray(history) || !variable) {
+    return {
+      content: [{ type: "text", text: "Error: history array and variable name are required" }],
+      isError: true
+    };
+  }
+  const lines = [];
+  lines.push(`## Variable Trace: \`${variable}\``);
+  lines.push("");
+  let prevValue = void 0;
+  const changes = [];
+  for (const snap of history) {
+    const vars = snap.variables || {};
+    const currentValue = vars[variable];
+    const index = snap.index;
+    const cmd = snap.commandName;
+    if (currentValue !== prevValue) {
+      changes.push({
+        index,
+        cmd,
+        oldVal: prevValue,
+        newVal: currentValue
+      });
+      prevValue = currentValue;
+    }
+  }
+  if (changes.length === 0) {
+    lines.push(`Variable \`${variable}\` was not found in any snapshot, or never changed.`);
+  } else {
+    lines.push(`| Step | Command | Old Value | New Value |`);
+    lines.push(`|------|---------|-----------|-----------|`);
+    for (const c of changes) {
+      lines.push(
+        `| ${c.index} | \`${c.cmd}\` | \`${formatVal(c.oldVal)}\` | \`${formatVal(c.newVal)}\` |`
+      );
+    }
+    lines.push("");
+    lines.push(`**Total changes:** ${changes.length}`);
+    lines.push(`**Final value:** \`${formatVal(prevValue)}\``);
+  }
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+function formatVal(v) {
+  if (v === void 0) return "undefined";
+  if (v === null) return "null";
+  if (typeof v === "string") return v.length > 40 ? `"${v.slice(0, 37)}..."` : `"${v}"`;
+  return String(v);
+}
+var COMMAND_INSIGHTS = {
+  toggle: "Toggles a CSS class on the target element. If the class is present, it removes it; if absent, it adds it.",
+  add: "Adds a CSS class or attribute to the target element.",
+  remove: "Removes a CSS class, attribute, or the element itself from the DOM.",
+  set: "Sets a variable or property to a value.",
+  get: "Evaluates an expression and stores the result in `it`.",
+  put: "Places content into an element (similar to setting innerHTML or textContent).",
+  show: "Makes a hidden element visible (removes display:none or similar).",
+  hide: "Hides an element (sets display:none or similar).",
+  fetch: "Makes an HTTP request and stores the response in `it`.",
+  wait: "Pauses execution for a specified duration.",
+  trigger: "Dispatches a custom event on an element.",
+  send: "Sends a custom event to a target element.",
+  log: "Logs a value to the browser console.",
+  call: "Calls a JavaScript function.",
+  if: "Conditional branch \u2014 executes commands only if the condition is true.",
+  repeat: "Loops over commands a specified number of times or for each item.",
+  increment: "Increases a numeric value by 1 (or a specified amount).",
+  decrement: "Decreases a numeric value by 1 (or a specified amount).",
+  append: "Appends content to an element (adds to end, does not replace).",
+  go: "Navigates to a URL."
+};
+function getCommandInsight(cmd) {
+  return COMMAND_INSIGHTS[cmd] || null;
+}
+function getCommandInsightFromCode(code) {
+  const firstWord = code.trim().split(/\s+/)[0].toLowerCase();
+  return COMMAND_INSIGHTS[firstWord] || null;
+}
+function detectIssues(cmd, element, variables) {
+  const issues = [];
+  if (["toggle", "add", "remove", "show", "hide"].includes(cmd) && !element) {
+    issues.push("No target element \u2014 DOM commands need an element to act on.");
+  }
+  if (["put", "set"].includes(cmd) && variables["it"] === null) {
+    issues.push(
+      "`it` is null \u2014 if using `it` as the value to set/put, this may produce unexpected results."
+    );
+  }
+  if (cmd === "fetch" && !element) {
+    issues.push("fetch command detected \u2014 ensure the URL is correct and the server is running.");
+  }
+  return issues;
+}
+function suggestBreakpoints(commands, issue) {
+  const suggestions = [];
+  if (commands.length > 1) {
+    suggestions.push(
+      `Set breakpoint on command \`${commands[0].split(/\s+/)[0]}\` to verify the first step executes correctly.`
+    );
+  }
+  const fetchIdx = commands.findIndex((c) => c.trim().startsWith("fetch"));
+  if (fetchIdx >= 0) {
+    suggestions.push(
+      `Set breakpoint after \`fetch\` (step ${fetchIdx + 1}) to inspect the response in \`it\`.`
+    );
+  }
+  const ifIdx = commands.findIndex((c) => c.trim().startsWith("if"));
+  if (ifIdx >= 0) {
+    suggestions.push(
+      `Set breakpoint on \`if\` (step ${ifIdx + 1}) to inspect the condition value.`
+    );
+  }
+  if (issue && suggestions.length === 0) {
+    suggestions.push(
+      "Set breakpoint on the first command and step through to find where behavior diverges from expectations."
+    );
+  }
+  return suggestions.length > 0 ? suggestions : ["Step through from the beginning with F10 (Step Over)."];
+}
+function diagnoseIssue(commands, issue) {
+  const lowerIssue = issue.toLowerCase();
+  if (lowerIssue.includes("not toggling") || lowerIssue.includes("class")) {
+    return "Check that the CSS selector in `toggle` matches the intended element. Use the element highlighter in the debug overlay to verify which element is being targeted.";
+  }
+  if (lowerIssue.includes("null") || lowerIssue.includes("undefined")) {
+    return "A variable is unexpectedly null. Step through each command and check `it` after each step \u2014 a command may be failing silently.";
+  }
+  if (lowerIssue.includes("fetch") || lowerIssue.includes("network") || lowerIssue.includes("api")) {
+    return "The fetch command may be failing. Set a breakpoint after `fetch` and check `it` for the response. Also check the browser Network tab for HTTP errors.";
+  }
+  return "Set a breakpoint on the first command and use Step Over (F10) to execute one command at a time, checking variables after each step.";
+}
+function diagnosError(cmd, error, variables) {
+  const causes = [];
+  const lowerError = error.toLowerCase();
+  if (lowerError.includes("null") || lowerError.includes("undefined")) {
+    causes.push(
+      "A variable or element reference is null. Check that selectors match existing elements."
+    );
+    if (variables["me"] === null || variables["me"] === void 0) {
+      causes.push("`me` is null \u2014 the command may not have a valid context element.");
+    }
+  }
+  if (lowerError.includes("not a function")) {
+    causes.push(
+      "Attempting to call something that is not a function. Check that the method or function name is spelled correctly."
+    );
+  }
+  if (lowerError.includes("network") || lowerError.includes("fetch")) {
+    causes.push(
+      "Network request failed. Check the URL, CORS settings, and that the server is running."
+    );
+  }
+  if (causes.length === 0) {
+    causes.push(
+      `The \`${cmd}\` command threw an error. Check the command syntax and that all referenced elements/variables exist.`
+    );
+  }
+  return causes;
+}
+function generateFixes(cmd, element, variables, error) {
+  const fixes = [];
+  if (!element && ["toggle", "add", "remove"].includes(cmd)) {
+    fixes.push(
+      "Add a target element: e.g., `toggle .active on me` or `toggle .active on #myElement`"
+    );
+  }
+  if (variables["it"] === null && ["put", "set"].includes(cmd)) {
+    fixes.push(
+      "Ensure a previous command sets `it` before using it. Try adding `get ...` or `set ... to ...` before this command."
+    );
+  }
+  if (error && error.includes("not found")) {
+    fixes.push(
+      "Verify the CSS selector matches an element in the DOM. Use browser DevTools Elements panel to check."
+    );
+  }
+  if (fixes.length === 0) {
+    fixes.push(
+      "Use the debug overlay to step through execution and identify the exact point where behavior diverges."
+    );
+    fixes.push("Check the browser console for additional error details.");
+  }
+  return fixes;
+}
+
+// src/tools/inventory.ts
+var extractSnippetsFromProjectImpl = null;
+async function getExtractor() {
+  if (extractSnippetsFromProjectImpl) return extractSnippetsFromProjectImpl;
+  try {
+    const mod = await import("@hyperfixi/developer-tools");
+    if (mod?.extractSnippetsFromProject) {
+      extractSnippetsFromProjectImpl = mod.extractSnippetsFromProject;
+    } else {
+      extractSnippetsFromProjectImpl = createInlineExtractor();
+    }
+    return extractSnippetsFromProjectImpl;
+  } catch {
+    extractSnippetsFromProjectImpl = createInlineExtractor();
+    return extractSnippetsFromProjectImpl;
+  }
+}
+var cachedSnippets = [];
+var cachedProjectDir = "";
+var inventoryTools = [
+  {
+    name: "scan_inventory",
+    description: "Scan a project directory for all hyperscript (_=), htmx (hx-*), and fixi (fx-*) attributes across HTML templates. Returns a summary with snippet counts by category, command, event, and element type, plus the full snippet list. Use this to understand how a project uses hyperscript and htmx.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        directory: {
+          type: "string",
+          description: 'Absolute path to the project directory to scan (e.g., "/path/to/project/templates")'
+        },
+        category: {
+          type: "string",
+          description: 'Filter by category: "hyperscript", "htmx-request", "htmx-swap", "htmx-target", "htmx-trigger", "htmx-other", "fixi". Omit for all.'
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of snippets to return (default: 50). Use 0 for summary only."
+        }
+      },
+      required: ["directory"]
+    }
+  },
+  {
+    name: "query_inventory",
+    description: "Search and filter within previously scanned inventory results. Must call scan_inventory first. Supports filtering by text search, category, command, event, file path, and element type.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        search: {
+          type: "string",
+          description: "Text search across snippet values, file paths, attribute names, commands, and events"
+        },
+        category: {
+          type: "string",
+          description: "Filter by snippet category"
+        },
+        command: {
+          type: "string",
+          description: 'Filter by hyperscript command (e.g., "toggle", "add", "fetch")'
+        },
+        event: {
+          type: "string",
+          description: 'Filter by event name (e.g., "click", "load", "change")'
+        },
+        file: {
+          type: "string",
+          description: "Filter by file path (substring match)"
+        },
+        element: {
+          type: "string",
+          description: 'Filter by HTML element type (e.g., "button", "form", "div")'
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of snippets to return (default: 30)"
+        }
+      }
+    }
+  }
+];
+async function handleInventoryTool(name, args) {
+  try {
+    switch (name) {
+      case "scan_inventory":
+        return await scanInventory(args);
+      case "query_inventory":
+        return queryInventory(args);
+      default:
+        return errorResponse(`Unknown inventory tool: ${name}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return errorResponse(`Inventory tool error: ${message}`);
+  }
+}
+async function scanInventory(args) {
+  const directory = getString(args, "directory");
+  if (!directory) {
+    return errorResponse("Missing required parameter: directory");
+  }
+  const category = getString(args, "category") || void 0;
+  const limit = getNumber(args, "limit", 50);
+  const extract = await getExtractor();
+  const allSnippets = await extract(directory);
+  cachedSnippets = allSnippets;
+  cachedProjectDir = directory;
+  let snippets = allSnippets;
+  if (category) {
+    snippets = snippets.filter((s) => s.category === category);
+  }
+  const summary = computeSummary(snippets);
+  const returnSnippets = limit === 0 ? [] : snippets.slice(0, limit).map(formatSnippet);
+  return jsonResponse({
+    projectDir: directory,
+    total: snippets.length,
+    summary,
+    snippets: returnSnippets,
+    ...snippets.length > limit && limit > 0 ? {
+      note: `Showing ${limit} of ${snippets.length}. Use query_inventory to filter or increase limit.`
+    } : {}
+  });
+}
+function queryInventory(args) {
+  if (cachedSnippets.length === 0) {
+    return errorResponse(
+      "No inventory data. Call scan_inventory first to scan a project directory."
+    );
+  }
+  const search = getString(args, "search") || void 0;
+  const category = getString(args, "category") || void 0;
+  const command = getString(args, "command") || void 0;
+  const event = getString(args, "event") || void 0;
+  const file = getString(args, "file") || void 0;
+  const element = getString(args, "element") || void 0;
+  const limit = getNumber(args, "limit", 30);
+  let snippets = cachedSnippets;
+  if (category) snippets = snippets.filter((s) => s.category === category);
+  if (command) snippets = snippets.filter((s) => s.commands?.includes(command));
+  if (event) snippets = snippets.filter((s) => s.events?.includes(event));
+  if (file) snippets = snippets.filter((s) => s.relativePath?.includes(file));
+  if (element) snippets = snippets.filter((s) => s.elementType === element);
+  if (search) {
+    const q = search.toLowerCase();
+    snippets = snippets.filter(
+      (s) => s.value?.toLowerCase().includes(q) || s.relativePath?.toLowerCase().includes(q) || s.attributeName?.toLowerCase().includes(q) || s.commands?.some((c) => c.includes(q)) || s.events?.some((e) => e.includes(q))
+    );
+  }
+  const summary = computeSummary(snippets);
+  const returnSnippets = snippets.slice(0, limit).map(formatSnippet);
+  return jsonResponse({
+    projectDir: cachedProjectDir,
+    matched: snippets.length,
+    summary,
+    snippets: returnSnippets,
+    ...snippets.length > limit ? { note: `Showing ${limit} of ${snippets.length}. Narrow your filters or increase limit.` } : {}
+  });
+}
+function computeSummary(snippets) {
+  const files = new Set(snippets.map((s) => s.filePath || s.relativePath));
+  const byCategory = {};
+  const byCommand = {};
+  const byEvent = {};
+  const byElementType = {};
+  for (const s of snippets) {
+    byCategory[s.category] = (byCategory[s.category] ?? 0) + 1;
+    if (s.elementType) byElementType[s.elementType] = (byElementType[s.elementType] ?? 0) + 1;
+    for (const cmd of s.commands ?? []) {
+      byCommand[cmd] = (byCommand[cmd] ?? 0) + 1;
+    }
+    for (const evt of s.events ?? []) {
+      byEvent[evt] = (byEvent[evt] ?? 0) + 1;
+    }
+  }
+  return {
+    totalFiles: files.size,
+    totalSnippets: snippets.length,
+    byCategory,
+    ...Object.keys(byCommand).length > 0 ? { byCommand } : {},
+    ...Object.keys(byEvent).length > 0 ? { byEvent } : {},
+    ...Object.keys(byElementType).length > 0 ? { byElementType } : {}
+  };
+}
+function formatSnippet(s) {
+  return {
+    file: s.relativePath,
+    line: s.line,
+    attribute: s.attributeName,
+    value: s.value,
+    category: s.category,
+    element: s.elementType,
+    ...s.commands?.length ? { commands: s.commands } : {},
+    ...s.events?.length ? { events: s.events } : {}
+  };
+}
+function createInlineExtractor() {
+  return async function extractSnippets(dir, _options) {
+    const fs = await import("fs");
+    const path = await import("path");
+    const crypto = await import("crypto");
+    const { glob } = await import("./esm-LUPOYJFX.js");
+    const globs = [
+      "**/*.html",
+      "**/*.htm",
+      "**/*.djhtml",
+      "**/*.jinja",
+      "**/*.j2",
+      "**/*.erb",
+      "**/*.php",
+      "**/*.vue",
+      "**/*.svelte",
+      "**/*.jsx",
+      "**/*.tsx",
+      "**/*.hbs",
+      "**/*.ejs",
+      "**/*.astro"
+    ];
+    const ignore = ["**/node_modules/**", "**/dist/**", "**/.git/**", "**/venv/**", "**/.venv/**"];
+    const files = await glob(globs, { cwd: dir, ignore, absolute: true });
+    const snippets = [];
+    const patterns = [
+      [/(_)\s*=\s*"((?:[^"\\]|\\.)*)"/gi, "hyperscript"],
+      [/(_)\s*=\s*'((?:[^'\\]|\\.)*)'/gi, "hyperscript"],
+      [/(hx-on:\w+)\s*=\s*"((?:[^"\\]|\\.)*)"/gi, "hyperscript"],
+      [/(hx-(?:get|post|put|patch|delete))\s*=\s*"((?:[^"\\]|\\.)*)"/gi, "htmx-request"],
+      [/(hx-(?:get|post|put|patch|delete))\s*=\s*'((?:[^'\\]|\\.)*)'/gi, "htmx-request"],
+      [/((?:hx|fx)-swap)\s*=\s*"((?:[^"\\]|\\.)*)"/gi, "htmx-swap"],
+      [/((?:hx|fx)-target)\s*=\s*"((?:[^"\\]|\\.)*)"/gi, "htmx-target"],
+      [/((?:hx|fx)-trigger)\s*=\s*"((?:[^"\\]|\\.)*)"/gi, "htmx-trigger"],
+      [/(fx-action)\s*=\s*"((?:[^"\\]|\\.)*)"/gi, "fixi"],
+      [
+        /(hx-(?:confirm|push-url|replace-url|indicator|select|vals|headers|include|boost|ext|encoding|params))\s*=\s*"((?:[^"\\]|\\.)*)"/gi,
+        "htmx-other"
+      ],
+      [
+        /(hx-(?:confirm|push-url|replace-url|indicator|select|vals|headers|include|boost|ext|encoding|params))\s*=\s*'((?:[^'\\]|\\.)*)'/gi,
+        "htmx-other"
+      ]
+    ];
+    const cmdRe = /\b(toggle|add|remove|show|hide|set|get|put|append|take|increment|decrement|log|send|trigger|wait|transition|go|call|focus|blur|return|fetch|tell|install)\b/g;
+    const evtRe = /\bon\s+(\w+)/g;
+    for (const file of files) {
+      try {
+        const content = fs.readFileSync(file, "utf-8");
+        const stat = fs.statSync(file);
+        const relPath = path.relative(dir, file);
+        const seen = /* @__PURE__ */ new Set();
+        for (const [pattern, category] of patterns) {
+          const re = new RegExp(pattern.source, pattern.flags);
+          let m;
+          while (m = re.exec(content)) {
+            const attrName = m[1];
+            const value = m[2];
+            const offset = m.index + m[0].indexOf(m[2]);
+            if (seen.has(offset)) continue;
+            seen.add(offset);
+            let line = 1;
+            for (let i = 0; i < m.index && i < content.length; i++) {
+              if (content[i] === "\n") line++;
+            }
+            let start = m.index;
+            while (start > 0 && content[start] !== "<") start--;
+            const tagMatch = content.slice(start).match(/^<\s*(\w[\w-]*)/);
+            const elementType = tagMatch ? tagMatch[1].toLowerCase() : "unknown";
+            const isHS = category === "hyperscript";
+            const commands = [];
+            const events = [];
+            if (isHS) {
+              let cm;
+              const cr = new RegExp(cmdRe.source, "g");
+              while (cm = cr.exec(value)) commands.push(cm[1]);
+              const er = new RegExp(evtRe.source, "g");
+              while (cm = er.exec(value)) events.push(cm[1]);
+            }
+            const id = crypto.createHash("md5").update(`${file}:${offset}`).digest("hex").slice(0, 12);
+            snippets.push({
+              id,
+              filePath: file,
+              relativePath: relPath,
+              attributeName: attrName,
+              value,
+              isMultiline: value.includes("\n"),
+              line,
+              column: 1,
+              elementType,
+              category,
+              commands: [...new Set(commands)],
+              events: [...new Set(events)],
+              fileMtime: stat.mtimeMs
+            });
+          }
+        }
+      } catch {
+      }
+    }
+    snippets.sort(
+      (a, b) => a.relativePath.localeCompare(b.relativePath) || a.line - b.line
+    );
+    return snippets;
+  };
+}
+
+// src/tools/training-data.ts
+var trainingDataTools = [
+  {
+    name: "generate_training_data",
+    description: "Synthesize (natural_language, LSE) training pairs from domain command schemas. Returns JSONL-formatted data for LLM fine-tuning.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        domain: {
+          type: "string",
+          description: "Domain to generate training data for (flow, sql, bdd, llm, jsx, todo, behaviorspec, voice)"
+        },
+        max_per_command: {
+          type: "number",
+          description: "Maximum pairs per command. Default: 5"
+        },
+        languages: {
+          type: "string",
+          description: "Comma-separated language codes. Default: en"
+        },
+        min_quality: {
+          type: "number",
+          description: "Minimum quality threshold (0-1). Default: 0.5"
+        },
+        format: {
+          type: "string",
+          description: "Output format: jsonl (default) or json"
+        }
+      },
+      required: ["domain"]
+    }
+  }
+];
+async function handleTrainingDataTool(name, args) {
+  if (name !== "generate_training_data") {
+    return {
+      content: [{ type: "text", text: `Unknown training data tool: ${name}` }],
+      isError: true
+    };
+  }
+  try {
+    const { synthesizeFromSchemas, toJSONL } = await import("@lokascript/framework");
+    const domain = args.domain;
+    if (!domain) {
+      return {
+        content: [{ type: "text", text: "Missing required parameter: domain" }],
+        isError: true
+      };
+    }
+    const schemas = await loadDomainSchemas(domain);
+    if (!schemas || schemas.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `No schemas found for domain: ${domain}. Available: flow, sql, bdd, llm, jsx, todo, behaviorspec, voice`
+          }
+        ],
+        isError: true
+      };
+    }
+    const languages = typeof args.languages === "string" ? args.languages.split(",").map((l) => l.trim()) : ["en"];
+    const result = synthesizeFromSchemas(schemas, {
+      domain,
+      maxPairsPerCommand: typeof args.max_per_command === "number" ? args.max_per_command : 5,
+      minQuality: typeof args.min_quality === "number" ? args.min_quality : 0.5,
+      languages
+    });
+    const format = args.format === "json" ? "json" : "jsonl";
+    const output = format === "json" ? JSON.stringify(result, null, 2) : toJSONL(result.pairs);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Generated ${result.metadata.pairCount} training pairs for domain "${domain}" (${result.metadata.commandCount} commands, languages: ${languages.join(", ")})
+
+${output}`
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Training data generation error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function loadDomainSchemas(domain) {
+  try {
+    switch (domain) {
+      case "flow":
+        return (await import("@lokascript/domain-flow")).allSchemas;
+      case "sql":
+        return (await import("@lokascript/domain-sql")).allSchemas;
+      case "bdd":
+        return (await import("@lokascript/domain-bdd")).allSchemas;
+      case "llm":
+        return (await import("@lokascript/domain-llm")).allSchemas;
+      case "jsx":
+        return (await import("@lokascript/domain-jsx")).allSchemas;
+      case "todo":
+        return (await import("@lokascript/domain-todo")).allSchemas;
+      case "behaviorspec":
+        return (await import("@lokascript/domain-behaviorspec")).allSchemas;
+      case "voice":
+        return (await import("@lokascript/domain-voice")).allSchemas;
+      default:
+        return null;
+    }
+  } catch {
+    return null;
+  }
+}
+
+// src/tools/feedback-tools.ts
+var feedbackTools = [
+  {
+    name: "lse_validate_and_feedback",
+    description: "Validate LSE input and return structured feedback with machine-actionable hints, corrected examples, and schema context for LLM self-correction.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        input: {
+          type: "string",
+          description: "The LSE input to validate (bracket syntax, JSON, or natural language)"
+        },
+        format: {
+          type: "string",
+          description: "Input format: explicit (default), json, protocol (full-fidelity v1.1/v1.2), envelope (v1.2 multi-node), or natural"
+        },
+        domain: {
+          type: "string",
+          description: "Domain to validate against (flow, sql, bdd, llm, jsx, todo, behaviorspec, voice)"
+        }
+      },
+      required: ["input"]
+    }
+  },
+  {
+    name: "lse_pattern_stats",
+    description: "Return pattern hit-rate statistics: success rates by command and language, top diagnostic failures, and outcome distribution.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        domain: {
+          type: "string",
+          description: "Filter stats by domain (optional)"
+        }
+      }
+    }
+  }
+];
+async function handleFeedbackTool(name, args) {
+  switch (name) {
+    case "lse_validate_and_feedback":
+      return handleValidateAndFeedback(args);
+    case "lse_pattern_stats":
+      return handlePatternStats();
+    default:
+      return {
+        content: [{ type: "text", text: `Unknown feedback tool: ${name}` }],
+        isError: true
+      };
+  }
+}
+async function handleValidateAndFeedback(args) {
+  try {
+    const { buildFeedback, parseExplicit: parseExplicit2 } = await import("@lokascript/framework");
+    const input = args.input;
+    if (!input) {
+      return {
+        content: [{ type: "text", text: "Missing required parameter: input" }],
+        isError: true
+      };
+    }
+    const format = args.format || "explicit";
+    const domain = args.domain;
+    let action;
+    let schemaLookup;
+    const diagnostics = [];
+    if (domain) {
+      const schemas = await loadDomainSchemas2(domain);
+      if (schemas) {
+        schemaLookup = createSchemaLookup(schemas);
+      }
+    }
+    if (format === "explicit") {
+      try {
+        const result = parseExplicit2(input, { schemaLookup });
+        if (result) {
+          action = result.action;
+        }
+      } catch (e) {
+        diagnostics.push({
+          severity: "error",
+          message: e instanceof Error ? e.message : "Parse error: invalid bracket syntax",
+          code: "parse-error"
+        });
+      }
+    } else if (format === "json") {
+      try {
+        const parsed = JSON.parse(input);
+        action = parsed.action;
+        if (!action) {
+          diagnostics.push({
+            severity: "error",
+            message: 'JSON missing required "action" field',
+            code: "missing-role"
+          });
+        }
+      } catch {
+        diagnostics.push({
+          severity: "error",
+          message: "Invalid JSON syntax",
+          code: "parse-error"
+        });
+      }
+    } else if (format === "protocol") {
+      try {
+        const { validateProtocolJSON: validateProtocolJSON2, fromProtocolJSON: fromProtocolJSON2 } = await import("@lokascript/framework");
+        const parsed = JSON.parse(input);
+        const protoDiags = validateProtocolJSON2(parsed);
+        for (const d of protoDiags) {
+          diagnostics.push({ severity: d.severity, message: d.message, code: d.code });
+        }
+        if (protoDiags.filter((d) => d.severity === "error").length === 0) {
+          const node = fromProtocolJSON2(parsed);
+          action = node.action;
+        }
+      } catch (e) {
+        diagnostics.push({
+          severity: "error",
+          message: e instanceof Error ? e.message : "Invalid protocol JSON",
+          code: "parse-error"
+        });
+      }
+    } else if (format === "envelope") {
+      try {
+        const { isEnvelope: isEnvelope2, fromEnvelopeJSON: fromEnvelopeJSON2, validateProtocolJSON: validateProtocolJSON2 } = await import("@lokascript/framework");
+        const parsed = JSON.parse(input);
+        if (!isEnvelope2(parsed)) {
+          diagnostics.push({
+            severity: "error",
+            message: "Not a valid LSE envelope: missing lseVersion or nodes",
+            code: "invalid-envelope"
+          });
+        } else {
+          for (let i = 0; i < parsed.nodes.length; i++) {
+            const nodeDiags = validateProtocolJSON2(parsed.nodes[i]);
+            for (const d of nodeDiags) {
+              diagnostics.push({
+                severity: d.severity,
+                message: `Node ${i}: ${d.message}`,
+                code: d.code
+              });
+            }
+          }
+          if (diagnostics.filter((d) => d.severity === "error").length === 0) {
+            const envelope = fromEnvelopeJSON2(parsed);
+            action = envelope.nodes[0]?.action;
+          }
+        }
+      } catch (e) {
+        diagnostics.push({
+          severity: "error",
+          message: e instanceof Error ? e.message : "Invalid envelope JSON",
+          code: "parse-error"
+        });
+      }
+    }
+    const feedbackFormat = format === "protocol" || format === "envelope" ? "json" : format;
+    const feedback = buildFeedback(input, feedbackFormat, diagnostics, schemaLookup, action);
+    return {
+      content: [{ type: "text", text: JSON.stringify(feedback, null, 2) }]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Feedback tool error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+var _tracker = null;
+async function getTracker() {
+  if (!_tracker) {
+    const { PatternTracker } = await import("@lokascript/framework");
+    _tracker = new PatternTracker(1e3);
+  }
+  return _tracker;
+}
+async function handlePatternStats() {
+  try {
+    const tracker = await getTracker();
+    const summary = tracker.getSummary();
+    const text = summary.totalEvents === 0 ? "No pattern events recorded yet. Events are recorded as LSE inputs are validated." : JSON.stringify(summary, null, 2);
+    return {
+      content: [{ type: "text", text }]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Pattern stats error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function loadDomainSchemas2(domain) {
+  try {
+    switch (domain) {
+      case "flow":
+        return (await import("@lokascript/domain-flow")).allSchemas;
+      case "sql":
+        return (await import("@lokascript/domain-sql")).allSchemas;
+      case "bdd":
+        return (await import("@lokascript/domain-bdd")).allSchemas;
+      case "llm":
+        return (await import("@lokascript/domain-llm")).allSchemas;
+      case "jsx":
+        return (await import("@lokascript/domain-jsx")).allSchemas;
+      case "todo":
+        return (await import("@lokascript/domain-todo")).allSchemas;
+      case "behaviorspec":
+        return (await import("@lokascript/domain-behaviorspec")).allSchemas;
+      case "voice":
+        return (await import("@lokascript/domain-voice")).allSchemas;
+      default:
+        return null;
+    }
+  } catch {
+    return null;
+  }
+}
+function createSchemaLookup(schemas) {
+  const map = /* @__PURE__ */ new Map();
+  for (const s of schemas) {
+    map.set(s.action, s);
+  }
+  return {
+    getSchema(action) {
+      return map.get(action);
+    }
+  };
+}
+
+// src/tools/lse-pipeline.ts
+var lsePipelineTools = [
+  // ── Phase 7.5: LLM-Native LSE tools ──────────────────────────────────────
+  {
+    name: "execute_lse",
+    description: "Execute LSE bracket syntax directly. Parses the LSE, compiles to JavaScript, and returns the execution result. Use this when an LLM has generated LSE and you want to run it.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        lse: {
+          type: "string",
+          description: "LSE bracket syntax: [command role:value ...]"
+        }
+      },
+      required: ["lse"]
+    }
+  },
+  {
+    name: "validate_lse",
+    description: "Validate LSE bracket syntax or protocol JSON without executing. Returns diagnostics (errors, warnings) and the normalized LSE. Use for pre-flight checks before execution.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        lse: {
+          type: "string",
+          description: "LSE bracket syntax to validate"
+        },
+        protocol: {
+          type: "object",
+          description: "Protocol JSON to validate (alternative to lse)"
+        }
+      }
+    }
+  },
+  {
+    name: "translate_lse",
+    description: "Translate LSE bracket syntax to natural language in a specified target language. Returns the natural-language hyperscript equivalent. Supports all 24 languages.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        lse: {
+          type: "string",
+          description: "LSE bracket syntax: [command role:value ...]"
+        },
+        language: {
+          type: "string",
+          description: "Target language code (e.g., en, ja, es, ko, ar, zh)"
+        }
+      },
+      required: ["lse", "language"]
+    }
+  },
+  // ── Existing pipeline tools ───────────────────────────────────────────────
+  {
+    name: "lse_from_hyperscript",
+    description: "Parse hyperscript code (any of 24 languages) to LSE bracket syntax and protocol JSON. Use this to get a structured representation for LLM modification or cross-language translation. Returns both bracket syntax (human-readable) and protocol JSON (machine-readable).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        code: {
+          type: "string",
+          description: "Hyperscript code in any supported language"
+        },
+        language: {
+          type: "string",
+          description: "ISO 639-1 language code (default: en)"
+        },
+        confidence: {
+          type: "number",
+          description: "Minimum confidence threshold for semantic parsing (default: 0.5)"
+        }
+      },
+      required: ["code"]
+    }
+  },
+  {
+    name: "lse_to_hyperscript",
+    description: "Validate and optionally compile LSE bracket syntax or protocol JSON returned by an LLM. Returns validation diagnostics, the normalized LSE, and optionally compiled JavaScript. Use lse_validate_and_feedback for richer error feedback with correction hints.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        lse: {
+          type: "string",
+          description: "LSE bracket syntax: [command role:value ...]"
+        },
+        protocol: {
+          type: "object",
+          description: "Protocol JSON (alternative to lse). Must have `kind` field."
+        },
+        compile: {
+          type: "boolean",
+          description: "Also compile to JavaScript (default: true)"
+        }
+      }
+    }
+  }
+];
+async function handleLsePipelineTool(name, args) {
+  try {
+    switch (name) {
+      case "execute_lse":
+        return await handleExecuteLse(args);
+      case "validate_lse":
+        return await handleValidateLse(args);
+      case "translate_lse":
+        return await handleTranslateLse(args);
+      case "lse_from_hyperscript":
+        return await handleFromHyperscript(args);
+      case "lse_to_hyperscript":
+        return await handleToHyperscript(args);
+      default:
+        return errorResponse(`Unknown LSE pipeline tool: ${name}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return errorResponse(`LSE pipeline error: ${message}`);
+  }
+}
+async function handleFromHyperscript(args) {
+  const code = args.code;
+  if (!code || typeof code !== "string") {
+    return errorResponse("Missing required parameter: code");
+  }
+  const language = args.language || "en";
+  const minConfidence = typeof args.confidence === "number" ? args.confidence : 0.5;
+  const { parseSemantic } = await import("@lokascript/semantic");
+  const parseResult = parseSemantic(code, language);
+  if (!parseResult.node) {
+    return jsonResponse({
+      ok: false,
+      error: "Semantic parsing failed \u2014 no node produced",
+      confidence: parseResult.confidence,
+      language
+    });
+  }
+  if (parseResult.confidence < minConfidence) {
+    return jsonResponse({
+      ok: false,
+      error: `Confidence ${parseResult.confidence.toFixed(2)} below threshold ${minConfidence}`,
+      confidence: parseResult.confidence,
+      language
+    });
+  }
+  const { fromSemanticAST } = await import("@lokascript/semantic");
+  const { fromInterchangeNode: fromInterchangeNode2, renderExplicit: renderExplicit2, toProtocolJSON: toProtocolJSON2 } = await import("@lokascript/framework");
+  const interchangeNode = fromSemanticAST(parseResult.node);
+  const semanticNode = fromInterchangeNode2(interchangeNode);
+  const explicit = renderExplicit2(semanticNode);
+  const protocol = toProtocolJSON2(semanticNode);
+  return jsonResponse({
+    ok: true,
+    lse: explicit,
+    protocol,
+    confidence: parseResult.confidence,
+    language
+  });
+}
+async function handleToHyperscript(args) {
+  const lseInput = typeof args.lse === "string" ? args.lse : void 0;
+  const protocolInput = typeof args.protocol === "object" && args.protocol ? args.protocol : void 0;
+  const shouldCompile = args.compile !== false;
+  if (!lseInput && !protocolInput) {
+    return errorResponse("Provide `lse` (bracket syntax) or `protocol` (JSON).");
+  }
+  const { parseExplicit: parseExplicit2, renderExplicit: renderExplicit2, toProtocolJSON: toProtocolJSON2, fromProtocolJSON: fromProtocolJSON2, validateProtocolJSON: validateProtocolJSON2 } = await import("@lokascript/framework");
+  let node;
+  const diagnostics = [];
+  if (lseInput) {
+    try {
+      node = parseExplicit2(lseInput);
+    } catch (e) {
+      const errorMessage = e instanceof Error ? e.message : "Invalid bracket syntax";
+      try {
+        const { buildFeedback } = await import("@lokascript/framework");
+        const actionMatch = lseInput.match(/^\[\s*(\w+)/);
+        const feedback = buildFeedback(
+          lseInput,
+          "explicit",
+          [{ severity: "error", message: errorMessage, code: "EXPLICIT_PARSE_ERROR" }],
+          void 0,
+          actionMatch?.[1]
+        );
+        return jsonResponse({ ok: false, feedback });
+      } catch {
+        diagnostics.push({
+          severity: "error",
+          code: "EXPLICIT_PARSE_ERROR",
+          message: errorMessage
+        });
+      }
+    }
+  } else if (protocolInput) {
+    const protoDiags = validateProtocolJSON2(protocolInput);
+    const hasErrors = protoDiags.some((d) => d.severity === "error");
+    if (hasErrors) {
+      try {
+        const { buildFeedback } = await import("@lokascript/framework");
+        const feedback = buildFeedback(
+          JSON.stringify(protocolInput, null, 2),
+          "json",
+          protoDiags.map((d) => ({
+            severity: d.severity,
+            message: d.message,
+            code: d.code
+          })),
+          void 0,
+          protocolInput.action
+        );
+        return jsonResponse({ ok: false, feedback });
+      } catch {
+        for (const d of protoDiags) {
+          diagnostics.push({ severity: d.severity, code: d.code, message: d.message });
+        }
+      }
+    } else {
+      for (const d of protoDiags) {
+        diagnostics.push({ severity: d.severity, code: d.code, message: d.message });
+      }
+      node = fromProtocolJSON2(protocolInput);
+    }
+  }
+  if (!node) {
+    return jsonResponse({ ok: false, diagnostics });
+  }
+  const normalizedLse = renderExplicit2(node);
+  const normalizedProtocol = toProtocolJSON2(node);
+  const result = {
+    ok: true,
+    lse: normalizedLse,
+    protocol: normalizedProtocol,
+    diagnostics
+  };
+  if (shouldCompile) {
+    try {
+      const { CompilationService } = await import("@lokascript/compilation-service");
+      const service = await CompilationService.create();
+      const compileResult = service.compile({ explicit: normalizedLse });
+      result.js = compileResult.ok ? compileResult.js : void 0;
+      if (!compileResult.ok && compileResult.diagnostics) {
+        for (const d of compileResult.diagnostics) {
+          if (d.severity === "error") {
+            diagnostics.push({
+              severity: "error",
+              code: "COMPILE_ERROR",
+              message: d.message
+            });
+          }
+        }
+      }
+    } catch (e) {
+      result.js = void 0;
+      result.compileNote = "Compilation service unavailable";
+    }
+  }
+  return jsonResponse(result);
+}
+async function handleExecuteLse(args) {
+  const lseInput = args.lse;
+  if (!lseInput || typeof lseInput !== "string") {
+    return errorResponse("Missing required parameter: lse");
+  }
+  const { parseExplicit: parseExplicit2, renderExplicit: renderExplicit2, toProtocolJSON: toProtocolJSON2 } = await import("@lokascript/framework");
+  let node;
+  try {
+    node = parseExplicit2(lseInput);
+  } catch (e) {
+    return errorResponse(`LSE parse error: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  const normalizedLse = renderExplicit2(node);
+  const protocol = toProtocolJSON2(node);
+  let js;
+  try {
+    const { CompilationService } = await import("@lokascript/compilation-service");
+    const service = await CompilationService.create();
+    const compileResult = service.compile({ explicit: normalizedLse });
+    js = compileResult.ok ? compileResult.js : void 0;
+  } catch {
+  }
+  return jsonResponse({
+    ok: true,
+    lse: normalizedLse,
+    protocol,
+    js,
+    note: js ? "Compiled successfully" : "Compilation service unavailable \u2014 parsed and validated only"
+  });
+}
+async function handleValidateLse(args) {
+  const lseInput = typeof args.lse === "string" ? args.lse : void 0;
+  const protocolInput = typeof args.protocol === "object" && args.protocol ? args.protocol : void 0;
+  if (!lseInput && !protocolInput) {
+    return errorResponse("Provide `lse` (bracket syntax) or `protocol` (JSON).");
+  }
+  const { parseExplicit: parseExplicit2, renderExplicit: renderExplicit2, validateProtocolJSON: validateProtocolJSON2 } = await import("@lokascript/framework");
+  const diagnostics = [];
+  if (lseInput) {
+    try {
+      const node = parseExplicit2(lseInput);
+      const normalized = renderExplicit2(node);
+      return jsonResponse({
+        valid: true,
+        normalized,
+        diagnostics: []
+      });
+    } catch (e) {
+      diagnostics.push({
+        severity: "error",
+        code: "PARSE_ERROR",
+        message: e instanceof Error ? e.message : String(e)
+      });
+      return jsonResponse({ valid: false, diagnostics });
+    }
+  }
+  if (protocolInput) {
+    const protoDiags = validateProtocolJSON2(protocolInput);
+    const hasErrors = protoDiags.some((d) => d.severity === "error");
+    return jsonResponse({
+      valid: !hasErrors,
+      diagnostics: protoDiags
+    });
+  }
+  return jsonResponse({ valid: false, diagnostics });
+}
+async function handleTranslateLse(args) {
+  const lseInput = args.lse;
+  const language = args.language;
+  if (!lseInput || typeof lseInput !== "string") {
+    return errorResponse("Missing required parameter: lse");
+  }
+  if (!language || typeof language !== "string") {
+    return errorResponse("Missing required parameter: language");
+  }
+  try {
+    const { parseExplicit: parseExplicit2, renderExplicit: renderExplicit2 } = await import("@lokascript/framework");
+    const { translate } = await import("@lokascript/semantic");
+    const node = parseExplicit2(lseInput);
+    const normalized = renderExplicit2(node);
+    const action = node.action;
+    const roles = node.roles;
+    const parts = [action];
+    const roleEntries = roles instanceof Map ? [...roles.entries()] : Object.entries(roles || {});
+    for (const [role, value] of roleEntries) {
+      const val = typeof value === "object" && value !== null ? value.value ?? value : value;
+      if (role === "patient") {
+        parts.push(String(val));
+      } else if (role === "destination") {
+        parts.push("on", String(val));
+      } else if (role === "source") {
+        parts.push("from", String(val));
+      } else {
+        parts.push(String(val));
+      }
+    }
+    const english = parts.join(" ");
+    const translated = translate(english, "en", language);
+    return jsonResponse({
+      ok: true,
+      language,
+      translated,
+      lse: normalized,
+      english
+    });
+  } catch (e) {
+    return errorResponse(`Translation error: ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
+
+// src/resources/content.ts
+function getCommandsReference() {
+  return `# Hyperscript Commands Reference
+
+## DOM Manipulation
+
+| Command | Usage | Example |
+|---------|-------|---------|
+| \`toggle\` | Toggle class/attribute | \`toggle .active on #menu\` |
+| \`add\` | Add class/attribute/style | \`add .highlight to me\` |
+| \`remove\` | Remove class/attribute/element | \`remove .error from #form\` |
+| \`show\` | Show element | \`show #modal with *opacity\` |
+| \`hide\` | Hide element | \`hide me with *opacity\` |
+| \`put\` | Set element content | \`put "Hello" into #greeting\` |
+| \`append\` | Add to end | \`append "<li/>" to #list\` |
+| \`swap\` | Replace content | \`swap #target innerHTML\` |
+
+## Data Commands
+
+| Command | Usage | Example |
+|---------|-------|---------|
+| \`set\` | Set variable/property | \`set :count to 0\` |
+| \`get\` | Get value | \`get #input.value\` |
+| \`increment\` | Add 1 | \`increment :count\` |
+| \`decrement\` | Subtract 1 | \`decrement :count\` |
+
+## Events
+
+| Command | Usage | Example |
+|---------|-------|---------|
 | \`send\` | Dispatch event | \`send refresh to #list\` |
 | \`trigger\` | Trigger event | \`trigger submit on #form\` |
 
@@ -5923,6 +9627,170 @@ function getSetupGuide() {
     ]
   };
 }
+function getLSEProtocolSpec() {
+  return `# LokaScript Explicit Syntax (LSE) Quick Reference
+
+## Syntax
+
+\`\`\`
+[command role1:value1 role2:value2 +flag1 ~flag2]
+\`\`\`
+
+| Element | Syntax | Example |
+|---------|--------|---------|
+| Command | first token (lowercased) | \`toggle\`, \`fetch\`, \`add\` |
+| Role pair | \`name:value\` | \`patient:.active\` |
+| Enabled flag | \`+name\` | \`+primary-key\` |
+| Disabled flag | \`~name\` | \`~nullable\` |
+| String literal | \`"..."\` or \`'...'\` | \`patient:"hello world"\` |
+| Selector | \`#id\` \`.class\` \`[attr]\` \`@aria\` \`*wild\` | \`destination:#button\` |
+| Boolean | \`true\` / \`false\` | \`goal:true\` |
+| Number | digits with optional decimal | \`quantity:5\` |
+| Duration | number + suffix | \`delay:500ms\`, \`timeout:2s\` |
+| Reference | built-in name | \`destination:me\`, \`source:it\` |
+| Nested body | bracket command in value | \`body:[toggle patient:.active]\` |
+| Compound | chain operator between commands | \`[add ...] then [fetch ...]\` |
+
+## Value Classification Priority (first match wins)
+
+1. **Selector** \u2014 starts with \`#\`, \`.\`, \`[\`, \`@\`, \`*\`
+2. **String** \u2014 starts with \`"\` or \`'\`
+3. **Boolean** \u2014 exact: \`true\` or \`false\`
+4. **Reference** \u2014 \`me\`, \`you\`, \`it\`, \`result\`, \`event\`, \`target\`, \`body\`
+5. **Duration** \u2014 number + \`ms\`/\`s\`/\`m\`/\`h\`
+6. **Number** \u2014 integer or decimal
+7. **Plain** \u2014 fallback (any non-whitespace)
+
+## Node Kinds
+
+Every node has a \`kind\` field:
+
+| Kind | Required Fields | Description |
+|------|----------------|-------------|
+| \`command\` | \`kind\`, \`action\`, \`roles\` | Single command (also encodes conditionals and loops via v1.1 fields) |
+| \`event-handler\` | \`kind\`, \`action\`, \`roles\`, \`body\` | Event handler with body commands |
+| \`compound\` | \`kind\`, \`action\`, \`statements\` | Chained commands with \`chainType\` (\`then\`/\`and\`/\`async\`/\`sequential\`) |
+
+## Value Types
+
+| Type | JSON Shape | Notes |
+|------|-----------|-------|
+| \`selector\` | \`{ "type": "selector", "value": ".active", "selectorKind?": "class" }\` | \`selectorKind\`: id, class, attribute, element, complex (optional) |
+| \`literal\` | \`{ "type": "literal", "value": "hello", "dataType": "string" }\` | \`dataType\`: string, number, boolean, duration |
+| \`reference\` | \`{ "type": "reference", "value": "me" }\` | Built-in: me, you, it, result, event, target, body |
+| \`expression\` | \`{ "type": "expression", "raw": "x > 0" }\` | Nested syntax or raw expressions |
+| \`property-path\` | \`{ "type": "property-path", "value": "event.detail" }\` | Dotted property access |
+| \`flag\` | \`{ "type": "flag", "name": "primary-key", "enabled": true }\` | \`+flag\` = enabled, \`~flag\` = disabled |
+
+## JSON Wire Format \u2014 Full-Fidelity
+
+Lossless round-trip format with \`kind\` field. Used for tool-to-tool interchange.
+
+### Command
+\`\`\`json
+{
+  "kind": "command",
+  "action": "toggle",
+  "roles": {
+    "patient": { "type": "selector", "value": ".active" },
+    "destination": { "type": "selector", "value": "#button" }
+  }
+}
+\`\`\`
+
+### Event Handler
+\`\`\`json
+{
+  "kind": "event-handler",
+  "action": "on",
+  "roles": { "event": { "type": "literal", "value": "click", "dataType": "string" } },
+  "body": [
+    { "kind": "command", "action": "toggle", "roles": { "patient": { "type": "selector", "value": ".active" } } }
+  ]
+}
+\`\`\`
+
+### Compound
+\`\`\`json
+{
+  "kind": "compound",
+  "action": "compound",
+  "chainType": "then",
+  "statements": [
+    { "kind": "command", "action": "add", "roles": { "patient": { "type": "selector", "value": ".loading" } } },
+    { "kind": "command", "action": "fetch", "roles": { "source": { "type": "literal", "value": "/api/data", "dataType": "string" } } }
+  ]
+}
+\`\`\`
+
+## Control Flow (v1.1)
+
+### Conditional
+A command node with \`thenBranch\` and optional \`elseBranch\` arrays:
+\`\`\`
+[if condition:"x > 0" then:[toggle patient:.active] else:[remove patient:.active]]
+\`\`\`
+\`\`\`json
+{
+  "kind": "command",
+  "action": "if",
+  "roles": { "condition": { "type": "expression", "raw": "x > 0" } },
+  "thenBranch": [
+    { "kind": "command", "action": "toggle", "roles": { "patient": { "type": "selector", "value": ".active" } } }
+  ],
+  "elseBranch": [
+    { "kind": "command", "action": "remove", "roles": { "patient": { "type": "selector", "value": ".active" } } }
+  ]
+}
+\`\`\`
+
+### Loop
+A command node with \`loopVariant\`, \`loopBody\`, and optional \`loopVariable\`/\`indexVariable\`:
+\`\`\`
+[repeat source:#items loopVariant:for loopVariable:item body:[add patient:.active]]
+\`\`\`
+\`\`\`json
+{
+  "kind": "command",
+  "action": "repeat",
+  "roles": { "source": { "type": "selector", "value": "#items" } },
+  "loopVariant": "for",
+  "loopBody": [
+    { "kind": "command", "action": "add", "roles": { "patient": { "type": "selector", "value": ".active" } } }
+  ],
+  "loopVariable": "item"
+}
+\`\`\`
+
+Loop variants: \`forever\`, \`times\`, \`for\`, \`while\`, \`until\`.
+
+## JSON Wire Format \u2014 LLM-Simplified
+
+Compact format optimized for LLM generation. Omits \`kind\`, uses flat \`trigger\` for event handlers.
+
+\`\`\`json
+{
+  "action": "toggle",
+  "roles": { "patient": { "type": "selector", "value": ".active" } },
+  "trigger": { "event": "click" }
+}
+\`\`\`
+
+| Difference | Full-Fidelity | LLM-Simplified |
+|-----------|--------------|----------------|
+| \`kind\` field | Required | Absent |
+| Event handlers | \`event-handler\` kind with \`body\` | \`trigger\` field on command |
+| Compound | \`statements\` array | Not supported |
+| Expression values | \`{ "raw": "..." }\` | \`{ "value": "..." }\` |
+| Flag values | \`{ "name": "x", "enabled": true }\` | \`{ "value": true }\` |
+
+## Event Handlers (Bracket Syntax)
+
+\`\`\`
+[on event:click body:[toggle patient:.active]]
+\`\`\`
+`;
+}
 
 // src/resources/index.ts
 function listResources() {
@@ -5974,6 +9842,12 @@ function listResources() {
       name: "Setup Decision Guide",
       description: "Structured decision tree for choosing between LokaScript and original _hyperscript adapter, and selecting the right bundle.",
       mimeType: "application/json"
+    },
+    {
+      uri: "lse://protocol/spec",
+      name: "LSE Protocol Specification",
+      description: "Quick reference for LokaScript Explicit Syntax (LSE) \u2014 bracket syntax, value types, JSON wire format.",
+      mimeType: "text/markdown"
     }
   ];
 }
@@ -6015,12 +9889,15 @@ function readResource(uri) {
           }
         ]
       };
+    case "lse://protocol/spec":
+      return { contents: [{ uri, mimeType: "text/markdown", text: getLSEProtocolSpec() }] };
     default:
       throw new Error(`Unknown resource: ${uri}`);
   }
 }
 
 // src/index.ts
+var registry = createDomainRegistry();
 var server = new Server(
   {
     name: "@hyperfixi/mcp-server",
@@ -6029,7 +9906,8 @@ var server = new Server(
   {
     capabilities: {
       tools: {},
-      resources: {}
+      resources: {},
+      prompts: {}
     }
   }
 );
@@ -6042,7 +9920,17 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       ...lspBridgeTools,
       ...languageDocsTools,
       ...profileTools,
-      ...compilationTools
+      ...compilationTools,
+      ...routeTools,
+      ...registry.getToolDefinitions(),
+      ...samplingTools,
+      ...dispatcherTools,
+      ...irTools,
+      ...debugTools,
+      ...inventoryTools,
+      ...trainingDataTools,
+      ...feedbackTools,
+      ...lsePipelineTools
     ]
   };
 });
@@ -6069,6 +9957,44 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   if (name === "compile_hyperscript" || name === "validate_and_compile" || name === "translate_code" || name === "generate_tests" || name === "generate_component" || name === "diff_behaviors") {
     return handleCompilationTool(name, args);
   }
+  if (name === "detect_domain" || name === "parse_composite" || name === "compile_auto" || name === "compile_composite") {
+    return handleDispatcherTool(name, args, registry);
+  }
+  if (name === "convert_format" || name === "validate_explicit" || name === "validate_protocol" || name === "to_envelope" || name === "from_envelope") {
+    return handleIRTool(name, args);
+  }
+  if (registry.canHandle(name)) {
+    const typedArgs = args;
+    if (name.endsWith("_bdd") && isMultiStepBDD(typedArgs)) {
+      return handleBDDMultiStep(name, typedArgs);
+    }
+    if (name.endsWith("_behaviorspec") && isMultiLineBehaviorSpec(typedArgs)) {
+      return handleBehaviorSpecMultiLine(name, typedArgs);
+    }
+    const result = await registry.handleToolCall(name, typedArgs);
+    if (result) return result;
+  }
+  if (name === "extract_routes" || name === "generate_server_routes") {
+    return handleRouteTool(name, args);
+  }
+  if (name === "ask_claude" || name === "summarize_content" || name === "analyze_content" || name === "translate_content" || name === "execute_llm") {
+    return handleSamplingTool(name, args, server, registry);
+  }
+  if (name.startsWith("debug_")) {
+    return handleDebugTool(name, args);
+  }
+  if (name === "scan_inventory" || name === "query_inventory") {
+    return handleInventoryTool(name, args);
+  }
+  if (name === "generate_training_data") {
+    return handleTrainingDataTool(name, args);
+  }
+  if (name === "lse_validate_and_feedback" || name === "lse_pattern_stats") {
+    return handleFeedbackTool(name, args);
+  }
+  if (name === "lse_from_hyperscript" || name === "lse_to_hyperscript") {
+    return handleLsePipelineTool(name, args);
+  }
   if (name.startsWith("get_")) {
     return handlePatternTool(name, args);
   }
@@ -6077,6 +10003,26 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     isError: true
   };
 });
+server.setRequestHandler(ListPromptsRequestSchema, async () => {
+  return {
+    prompts: [
+      ...getLLMPromptDefinitions(),
+      ...getDebugPromptDefinitions(),
+      ...getLSEPromptDefinitions()
+    ]
+  };
+});
+server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+  const { name, arguments: promptArgs } = request.params;
+  const typedArgs = promptArgs ?? {};
+  if (isDebugPrompt(name)) {
+    return renderDebugPrompt(name, typedArgs);
+  }
+  if (isLSEPrompt(name)) {
+    return renderLSEPrompt(name, typedArgs);
+  }
+  return renderLLMPrompt(name, typedArgs);
+});
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
   return { resources: listResources() };
 });