@hyperfixi/mcp-server 2.3.1 → 2.4.0

package/dist/index.js

@@ -1,4 +1,8 @@
 #!/usr/bin/env node
+import {
+  feedbackTools,
+  handleFeedbackTool
+} from "./chunk-P76KH42G.js";
 
 // src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -1164,7 +1168,32 @@ var cachedAnalyzer = null;
 function getSemanticAnalyzer() {
   if (!semanticPackage) return null;
   if (!cachedAnalyzer) {
-    cachedAnalyzer = semanticPackage.createSemanticAnalyzer();
+    cachedAnalyzer = {
+      analyze(code, language) {
+        if (!semanticPackage.isLanguageRegistered(language)) {
+          return {
+            confidence: 0,
+            errors: [`Language '${language}' is not supported for semantic parsing`]
+          };
+        }
+        const result = semanticPackage.parseSemantic(code, language);
+        const out = {
+          confidence: result.confidence
+        };
+        if (result.tokensConsumed !== void 0) out.tokensConsumed = result.tokensConsumed;
+        if (result.node) {
+          out.command = { name: result.node.action, roles: result.node.roles };
+        }
+        if (result.error) out.errors = [result.error];
+        return out;
+      },
+      supportsLanguage(language) {
+        return semanticPackage.isLanguageRegistered(language);
+      },
+      supportedLanguages() {
+        return semanticPackage.getRegisteredLanguages();
+      }
+    };
   }
   return cachedAnalyzer;
 }
@@ -1462,7 +1491,7 @@ function getValidCommandsForLanguage(language) {
     return englishCommands;
   }
   try {
-    const profile = semanticPackage.getProfile(language);
+    const profile = semanticPackage.tryGetProfile(language);
     if (profile && profile.keywords) {
       const commands = [...englishCommands];
       for (const [, translation] of Object.entries(profile.keywords)) {
@@ -1486,7 +1515,7 @@ function getEventHandlerKeywords(language) {
     return variants;
   }
   try {
-    const profile = semanticPackage.getProfile(language);
+    const profile = semanticPackage.tryGetProfile(language);
     if (profile && profile.keywords && profile.keywords["on"]) {
       const trans = profile.keywords["on"];
       if (trans.primary) {
@@ -1619,7 +1648,7 @@ function validateHyperscript(code, language) {
   const endVariants = ["end"];
   if (semanticPackage && language !== "en") {
     try {
-      const profile = semanticPackage.getProfile(language);
+      const profile = semanticPackage.tryGetProfile(language);
       if (profile?.keywords?.["if"]?.primary) {
         ifVariants.push(profile.keywords["if"].primary);
       }
@@ -1709,7 +1738,7 @@ function validateHyperscript(code, language) {
     const toggleVariants = ["toggle"];
     if (semanticPackage && language !== "en") {
       try {
-        const profile = semanticPackage.getProfile(language);
+        const profile = semanticPackage.tryGetProfile(language);
         if (profile?.keywords?.toggle?.primary) {
           toggleVariants.push(profile.keywords.toggle.primary);
         }
@@ -1902,7 +1931,7 @@ function translateSuggestion(suggestion, language) {
     return suggestion;
   }
   try {
-    const profile = semanticPackage.getProfile(language);
+    const profile = semanticPackage.tryGetProfile(language);
     if (profile && profile.keywords && profile.keywords[suggestion.command]) {
       const trans = profile.keywords[suggestion.command];
       if (trans.primary) {
@@ -2457,7 +2486,7 @@ function explainInLanguage(code, sourceLanguage, targetLanguage, includeTranslat
       throw new Error("Semantic analyzer not available");
     }
     const parseResult = analyzer.analyze(code, sourceLanguage);
-    const profile = semanticPackage.getProfile(targetLanguage);
+    const profile = semanticPackage.tryGetProfile(targetLanguage);
     const explanation = {
       code,
       sourceLanguage,
@@ -2698,7 +2727,28 @@ var cachedAnalyzer2 = null;
 function getSemanticAnalyzer2() {
   if (!semanticPackage2) return null;
   if (!cachedAnalyzer2) {
-    cachedAnalyzer2 = semanticPackage2.createSemanticAnalyzer();
+    cachedAnalyzer2 = {
+      analyze(code, language) {
+        if (!semanticPackage2.isLanguageRegistered(language)) {
+          return {
+            confidence: 0,
+            errors: [`Language '${language}' is not supported for semantic parsing`]
+          };
+        }
+        const result = semanticPackage2.parseSemantic(code, language);
+        const out = {
+          confidence: result.confidence
+        };
+        if (result.node) {
+          out.command = { name: result.node.action, roles: result.node.roles };
+        }
+        if (result.error) out.errors = [result.error];
+        return out;
+      },
+      supportsLanguage(language) {
+        return semanticPackage2.isLanguageRegistered(language);
+      }
+    };
   }
   return cachedAnalyzer2;
 }
@@ -2986,7 +3036,7 @@ function getValidCommandsForLanguage2(language) {
     return englishCommands;
   }
   try {
-    const profile = semanticPackage2.getProfile(language);
+    const profile = semanticPackage2.tryGetProfile(language);
     if (profile && profile.keywords) {
       const commands = [...englishCommands];
       for (const [engCommand, translation] of Object.entries(profile.keywords)) {
@@ -3177,7 +3227,7 @@ function getKeywordTranslation(command, language) {
     return { label: command };
   }
   try {
-    const profile = semanticPackage2.getProfile(language);
+    const profile = semanticPackage2.tryGetProfile(language);
     if (profile && profile.keywords && profile.keywords[command]) {
       const trans = profile.keywords[command];
       if (trans.primary) {
@@ -3193,7 +3243,7 @@ function getReferenceTranslation(ref, language) {
     return { label: ref };
   }
   try {
-    const profile = semanticPackage2.getProfile(language);
+    const profile = semanticPackage2.tryGetProfile(language);
     if (profile && profile.references && profile.references[ref]) {
       return { label: profile.references[ref], englishLabel: ref };
     }
@@ -3378,7 +3428,7 @@ function normalizeToEnglish(word, language) {
     return wordLower;
   }
   try {
-    const profile = semanticPackage2.getProfile(language);
+    const profile = semanticPackage2.tryGetProfile(language);
     if (profile && profile.keywords) {
       for (const [engKey, translation] of Object.entries(profile.keywords)) {
         const trans = translation;
@@ -3466,7 +3516,7 @@ function getKeywordVariants(engKeyword, language) {
     return variants;
   }
   try {
-    const profile = semanticPackage2.getProfile(language);
+    const profile = semanticPackage2.tryGetProfile(language);
     if (profile && profile.keywords && profile.keywords[engKeyword]) {
       const trans = profile.keywords[engKeyword];
       if (trans.primary) {
@@ -4767,9 +4817,9 @@ function handleSearchLanguageElements(args) {
       }
     }
   }
-  if (searchTypes.includes("keyword") && semanticPackage3?.languageProfiles) {
+  if (searchTypes.includes("keyword") && semanticPackage3?.KNOWN_PROFILES) {
     const seenKeywords = /* @__PURE__ */ new Set();
-    for (const [lang, profile] of Object.entries(semanticPackage3.languageProfiles)) {
+    for (const [lang, profile] of Object.entries(semanticPackage3.KNOWN_PROFILES)) {
       if (!profile.keywords) continue;
       for (const [keyword, trans] of Object.entries(profile.keywords)) {
         const primary = (trans?.primary || "").toLowerCase();
@@ -5741,159 +5791,7 @@ async function generateServerRoutes(args) {
 }
 
 // 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 {
-      }
-    })
-  );
-}
+import { createDomainRegistry } from "@lokascript/domain-config";
 
 // src/tools/bdd-extras.ts
 var bddScenarioParser = null;
@@ -6891,15 +6789,13 @@ async function handleExecuteLLM(args, server2, registry2) {
 
 // src/tools/dispatcher.ts
 import { CrossDomainDispatcher } from "@lokascript/framework";
+import { DOMAIN_PRIORITY } from "@lokascript/domain-config";
 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"]
+      priority: DOMAIN_PRIORITY
     });
   }
   return dispatcher;
@@ -8077,7 +7973,7 @@ function createInlineExtractor() {
     const fs = await import("fs");
     const path = await import("path");
     const crypto = await import("crypto");
-    const { glob } = await import("./esm-UBAMNMQH.js");
+    const { glob } = await import("./esm-RQFF6QRX.js");
     const globs = [
       "**/*.html",
       "**/*.htm",
@@ -8298,245 +8194,6 @@ async function loadDomainSchemas(domain) {
   }
 }
 
-// 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 ──────────────────────────────────────
@@ -9507,6 +9164,231 @@ async function handleGrailTool(name, args) {
   }
 }
 
+// src/tools/lse-correction.ts
+var lseCorrectionTools = [
+  {
+    name: "lse_generate_with_correction",
+    description: "Stateless LSE generation helper. Without an attempt, returns a generation prompt and schema context for producing LSE protocol JSON. With an attempt, validates it and returns either the valid node or structured feedback + corrected example + a refined prompt. Call repeatedly (up to maxRounds) to converge on valid LSE. Supports bracket syntax ([command role:value ...]) or raw protocol JSON.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        task: {
+          type: "string",
+          description: 'Natural language description of the UI interaction to generate. E.g. "A button that toggles .active on #sidebar when clicked".'
+        },
+        attempt: {
+          type: "string",
+          description: "Your current LSE attempt \u2014 bracket syntax or JSON string. Omit on round 0 to get a generation prompt."
+        },
+        domain: {
+          type: "string",
+          description: "Optional command domain for schema validation: hyperscript, flow, sql, bdd, voice, etc."
+        },
+        round: {
+          type: "number",
+          description: "Current correction round (0-based, default 0)."
+        },
+        maxRounds: {
+          type: "number",
+          description: "Maximum rounds before giving up (default 3)."
+        }
+      },
+      required: ["task"]
+    }
+  }
+];
+async function handleLseCorrectionTool(name, args) {
+  if (name !== "lse_generate_with_correction") {
+    return errorResponse(`Unknown correction tool: ${name}`);
+  }
+  const task = args.task;
+  if (!task || typeof task !== "string") {
+    return errorResponse("Missing required parameter: task");
+  }
+  const attempt = typeof args.attempt === "string" ? args.attempt.trim() : void 0;
+  const domain = typeof args.domain === "string" ? args.domain : void 0;
+  const round = typeof args.round === "number" ? args.round : 0;
+  const maxRounds = typeof args.maxRounds === "number" ? args.maxRounds : 3;
+  if (!attempt) {
+    return handleGenerationPrompt(task, domain);
+  }
+  if (round >= maxRounds) {
+    return jsonResponse({
+      ok: false,
+      exhausted: true,
+      round,
+      maxRounds,
+      message: `Maximum correction rounds (${maxRounds}) reached without valid LSE. Review the task description and try a simpler interaction pattern.`
+    });
+  }
+  return handleValidateAttempt(task, attempt, domain, round, maxRounds);
+}
+async function handleGenerationPrompt(task, domain) {
+  const schemaContext = await buildSchemaContext(domain);
+  const systemContext = [
+    "## LSE (LokaScript Explicit Syntax) Generation",
+    "",
+    "LSE uses bracket syntax: `[command role:value role:value ...]`",
+    "",
+    "### Value types",
+    "- Selector: `.class`, `#id`, `element`, or complex selectors \u2192 `patient:.active`",
+    '- Literal: quoted strings or numbers \u2192 `source:"/api/data"`, `count:3`',
+    "- Reference: built-in refs (me, it, you, body, window, document) \u2192 `destination:me`",
+    "- Flag: boolean flag \u2192 `+async` (enabled), `~async` (disabled)",
+    "",
+    "### Common patterns",
+    "- Toggle class: `[toggle patient:.active]`",
+    "- Add/remove class: `[add patient:.highlight destination:#target]`",
+    '- Set value: `[set patient:#input value:"hello"]`',
+    '- Fetch data: `[fetch source:"/api/data" target:#results]`',
+    "- Show/hide: `[show patient:#modal]` / `[hide patient:#modal]`",
+    "",
+    "### Protocol JSON (alternative format)",
+    "```json",
+    '{"action":"toggle","roles":{"patient":{"type":"selector","value":".active"}}}',
+    "```"
+  ];
+  if (schemaContext) {
+    systemContext.push("", "### Available commands for this domain", schemaContext);
+  }
+  const nextPrompt = [
+    `Task: ${task}`,
+    "",
+    "Generate LSE bracket syntax or protocol JSON for the above task.",
+    "Return ONLY the LSE \u2014 no explanation, no markdown fences.",
+    "If using bracket syntax: `[command role:value ...]`",
+    'If using JSON: `{"action":"...","roles":{...}}`'
+  ].join("\n");
+  return jsonResponse({
+    ok: false,
+    needsAttempt: true,
+    round: 0,
+    systemContext: systemContext.join("\n"),
+    nextPrompt,
+    instructions: "Use systemContext as your system prompt and nextPrompt as your user message. Pass the response back as `attempt` in the next call."
+  });
+}
+async function handleValidateAttempt(task, attempt, domain, round, maxRounds) {
+  const { parseExplicit: parseExplicit2, renderExplicit: renderExplicit2, toProtocolJSON: toProtocolJSON2, validateProtocolJSON: validateProtocolJSON2, fromProtocolJSON: fromProtocolJSON2 } = await import("@lokascript/framework");
+  let node = null;
+  const diagnostics = [];
+  const isJSON = attempt.trimStart().startsWith("{");
+  if (isJSON) {
+    let parsed;
+    try {
+      parsed = JSON.parse(attempt);
+    } catch {
+      diagnostics.push({
+        severity: "error",
+        code: "INVALID_JSON",
+        message: "Attempt is not valid JSON"
+      });
+    }
+    if (parsed) {
+      const protoDiags = validateProtocolJSON2(parsed);
+      for (const d of protoDiags) diagnostics.push(d);
+      if (!protoDiags.some((d) => d.severity === "error")) {
+        try {
+          node = fromProtocolJSON2(parsed);
+        } catch (e) {
+          diagnostics.push({
+            severity: "error",
+            code: "DESERIALIZE_ERROR",
+            message: e instanceof Error ? e.message : String(e)
+          });
+        }
+      }
+    }
+  } else {
+    try {
+      node = parseExplicit2(attempt);
+    } catch (e) {
+      diagnostics.push({
+        severity: "error",
+        code: "PARSE_ERROR",
+        message: e instanceof Error ? e.message : String(e)
+      });
+    }
+  }
+  const hasErrors = diagnostics.some((d) => d.severity === "error");
+  if (!hasErrors && node) {
+    const lse = renderExplicit2(node);
+    const protocol = toProtocolJSON2(node);
+    return jsonResponse({
+      ok: true,
+      round,
+      lse,
+      protocol,
+      diagnostics,
+      message: round === 0 ? "Valid LSE on first attempt." : `Valid LSE after ${round} correction round${round === 1 ? "" : "s"}.`
+    });
+  }
+  const correctedExample = buildCorrectedExample(attempt, diagnostics);
+  const remaining = maxRounds - round - 1;
+  let nextPrompt;
+  if (remaining > 0) {
+    nextPrompt = [
+      `Task: ${task}`,
+      "",
+      "Your previous attempt had errors:",
+      ...diagnostics.filter((d) => d.severity === "error").map((d) => `  \u2022 [${d.code}] ${d.message}`),
+      "",
+      correctedExample ? `Corrected example:
+${correctedExample}` : "",
+      "",
+      "Generate a corrected LSE. Return ONLY the LSE \u2014 no explanation."
+    ].filter(Boolean).join("\n");
+  } else {
+    nextPrompt = [
+      `Task: ${task}`,
+      "",
+      "Final attempt. Your previous LSE had these errors:",
+      ...diagnostics.filter((d) => d.severity === "error").map((d) => `  \u2022 [${d.code}] ${d.message}`),
+      "",
+      "Produce the simplest valid LSE you can for this task."
+    ].join("\n");
+  }
+  return jsonResponse({
+    ok: false,
+    round,
+    remainingRounds: remaining,
+    diagnostics,
+    correctedExample,
+    nextPrompt,
+    instructions: remaining > 0 ? `Use nextPrompt to generate a corrected attempt, then call again with round: ${round + 1}.` : "Last correction round \u2014 generate the simplest valid LSE you can."
+  });
+}
+function buildCorrectedExample(attempt, diagnostics) {
+  const bracketMatch = attempt.match(/^\[\s*(\w+)/);
+  const jsonMatch = attempt.match(/"action"\s*:\s*"(\w+)"/);
+  const action = bracketMatch?.[1] ?? jsonMatch?.[1];
+  if (!action) return null;
+  const missingRoles = diagnostics.filter((d) => d.code === "MISSING_REQUIRED_ROLE").map((d) => {
+    const m = d.message.match(/role "(\w+)"/);
+    return m?.[1];
+  }).filter(Boolean);
+  if (missingRoles.length > 0) {
+    const roleParts = missingRoles.map((r) => `${r}:.<value>`).join(" ");
+    return `[${action} ${roleParts}]`;
+  }
+  return `[${action} patient:.<selector>]`;
+}
+async function buildSchemaContext(domain) {
+  if (!domain) return null;
+  try {
+    const { loadDomainSchemas: loadDomainSchemas2 } = await import("./feedback-tools-S6VDG6F5.js");
+    if (typeof loadDomainSchemas2 !== "function") return null;
+    const schemas = await loadDomainSchemas2(domain);
+    if (!schemas || schemas.length === 0) return null;
+    return schemas.map((s) => {
+      const roles = (s.roles ?? []).map((r) => `${r.role}${r.required ? "" : "?"}`).join(", ");
+      return `- \`${s.action}\`${roles ? ` (${roles})` : ""}${s.description ? ": " + s.description : ""}`;
+    }).join("\n");
+  } catch {
+    return null;
+  }
+}
+
 // src/resources/content.ts
 function getCommandsReference() {
   return `# Hyperscript Commands Reference
@@ -10535,7 +10417,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       ...trainingDataTools,
       ...feedbackTools,
       ...lsePipelineTools,
-      ...grailTools
+      ...grailTools,
+      ...lseCorrectionTools
     ]
   };
 });
@@ -10603,6 +10486,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   if (name.startsWith("grail_")) {
     return handleGrailTool(name, args);
   }
+  if (name === "lse_generate_with_correction") {
+    return handleLseCorrectionTool(name, args);
+  }
   if (name.startsWith("get_")) {
     return handlePatternTool(name, args);
   }