@hyperfixi/mcp-server 2.3.0 → 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-LUPOYJFX.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 ──────────────────────────────────────
@@ -8903,6 +8560,835 @@ async function handleTranslateLse(args) {
   }
 }
 
+// src/tools/grail-yaml-loader.ts
+import { readFileSync } from "fs";
+import { parse as parseYaml } from "yaml";
+function resolveTemplate(template, context) {
+  return template.replace(/\{(\w+)\}/g, (match, key) => {
+    return key in context ? context[key] : match;
+  });
+}
+function loadGrailConfig(yamlPath) {
+  const raw = readFileSync(yamlPath, "utf-8");
+  const doc = parseYaml(raw);
+  if (!doc || typeof doc !== "object") {
+    throw new Error(`grail: invalid YAML at ${yamlPath}`);
+  }
+  const version = doc.version ?? "1.0";
+  const domain = doc.domain ?? { name: "unknown" };
+  const conditions = (doc.conditions ?? []).map(
+    (c) => ({
+      name: c.name,
+      description: c.description ?? "",
+      eval: c.eval
+    })
+  );
+  const affordances = (doc.affordances ?? []).map(
+    (a) => ({
+      name: a.name,
+      title: a.title ?? a.name,
+      preconditions: a.preconditions ?? [],
+      effects: a.effects ?? [],
+      cost: a.cost ?? 1,
+      preferred: a.preferred ?? false,
+      confirm: a.confirm ?? "",
+      action: a.action
+    })
+  );
+  return { version, domain, conditions, affordances };
+}
+function findGrailYaml(cwd) {
+  return process.env.GRAIL_YAML ?? `${cwd}/grail.yaml`;
+}
+
+// src/tools/grail-registry.ts
+import { exec } from "child_process";
+var MAX_OUTPUT = 500;
+function truncate(s) {
+  return s.length > MAX_OUTPUT ? s.slice(0, MAX_OUTPUT) + "\u2026" : s;
+}
+function execShell(cmd, cwd, timeout) {
+  return new Promise((resolve) => {
+    const start = Date.now();
+    exec(cmd, { cwd, timeout: timeout * 1e3 }, (error, stdout, stderr) => {
+      const duration_ms = Date.now() - start;
+      const output = truncate((stdout ?? "") + (stderr ?? "")).trim();
+      const timedOut = !!(error && "killed" in error && error.killed);
+      const exitCode = error ? error.code ?? 1 : 0;
+      resolve({
+        exitCode,
+        output: timedOut ? `Timed out after ${timeout}s` : output,
+        duration_ms,
+        timedOut
+      });
+    });
+  });
+}
+var GrailRegistry = class {
+  conditions = /* @__PURE__ */ new Map();
+  affordances = /* @__PURE__ */ new Map();
+  _cwd;
+  constructor(config, cwd) {
+    this._cwd = cwd;
+    for (const c of config.conditions) {
+      this.conditions.set(c.name, c);
+    }
+    for (const a of config.affordances) {
+      this.affordances.set(a.name, a);
+    }
+  }
+  _context() {
+    return { cwd: this._cwd };
+  }
+  // ---------- Condition evaluation ----------
+  async evaluate(name) {
+    const cond = this.conditions.get(name);
+    if (!cond) {
+      return {
+        passing: false,
+        output: `Unknown condition: ${name}`,
+        duration_ms: 0,
+        error: "unknown"
+      };
+    }
+    const ctx = this._context();
+    const cmd = resolveTemplate(cond.eval.cmd, ctx);
+    const evalCwd = cond.eval.cwd ? resolveTemplate(cond.eval.cwd, ctx) : this._cwd;
+    const timeout = cond.eval.timeout ?? 30;
+    try {
+      const { exitCode, output, duration_ms } = await execShell(cmd, evalCwd, timeout);
+      return { passing: exitCode === 0, output, duration_ms };
+    } catch (err) {
+      return {
+        passing: false,
+        output: "",
+        duration_ms: 0,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async evaluateAll() {
+    const names = [...this.conditions.keys()];
+    const results = {};
+    const chunks = [];
+    for (let i = 0; i < names.length; i += 8) {
+      chunks.push(names.slice(i, i + 8));
+    }
+    for (const chunk of chunks) {
+      const chunkResults = await Promise.all(
+        chunk.map(async (name) => ({ name, result: await this.evaluate(name) }))
+      );
+      for (const { name, result } of chunkResults) {
+        results[name] = result;
+      }
+    }
+    return results;
+  }
+  // ---------- Affordance checks ----------
+  checkPreconditions(affordanceName, truth) {
+    const aff = this.affordances.get(affordanceName);
+    if (!aff) return { met: false, unmet: [`unknown affordance: ${affordanceName}`] };
+    const unmet = (aff.preconditions ?? []).filter((p) => !truth[p]);
+    return { met: unmet.length === 0, unmet };
+  }
+  // ---------- Affordance execution ----------
+  async run(affordanceName) {
+    const aff = this.affordances.get(affordanceName);
+    if (!aff) {
+      return {
+        success: false,
+        exitCode: -1,
+        output: `Unknown affordance: ${affordanceName}`,
+        duration_ms: 0,
+        cmd: ""
+      };
+    }
+    if (!aff.action) {
+      return {
+        success: false,
+        exitCode: -1,
+        output: `Affordance ${affordanceName} has no action defined`,
+        duration_ms: 0,
+        cmd: ""
+      };
+    }
+    const ctx = this._context();
+    const cmd = resolveTemplate(aff.action.cmd, ctx);
+    const actionCwd = aff.action.cwd ? resolveTemplate(aff.action.cwd, ctx) : this._cwd;
+    const timeout = aff.action.timeout ?? 120;
+    const { exitCode, output, duration_ms } = await execShell(cmd, actionCwd, timeout);
+    return { success: exitCode === 0, exitCode, output, duration_ms, cmd };
+  }
+  // ---------- Introspection ----------
+  conditionMap() {
+    const result = {};
+    for (const [name, cond] of this.conditions) {
+      const producedBy = [];
+      const requiredBy = [];
+      for (const [affName, aff] of this.affordances) {
+        if ((aff.effects ?? []).some(
+          (e) => e === name || e.includes("{") && this._templateMatches(e, name)
+        )) {
+          producedBy.push(affName);
+        }
+        if ((aff.preconditions ?? []).includes(name)) {
+          requiredBy.push(affName);
+        }
+      }
+      result[name] = { description: cond.description, producedBy, requiredBy };
+    }
+    return result;
+  }
+  enablesGraph() {
+    const graph = {};
+    for (const [affName, aff] of this.affordances) {
+      const enables = [];
+      for (const effect of aff.effects ?? []) {
+        for (const [otherName, other] of this.affordances) {
+          if (otherName === affName) continue;
+          if ((other.preconditions ?? []).includes(effect) && !enables.includes(otherName)) {
+            enables.push(otherName);
+          }
+        }
+      }
+      if (enables.length > 0) {
+        graph[affName] = enables;
+      }
+    }
+    return graph;
+  }
+  _templateMatches(template, condition) {
+    const braceIdx = template.indexOf("{");
+    if (braceIdx === -1) return template === condition;
+    const prefix = template.slice(0, braceIdx);
+    return condition.startsWith(prefix);
+  }
+};
+
+// src/tools/grail-tools.ts
+import {
+  parseConditionMap,
+  plan as bfsPlan,
+  applyEffects
+} from "@lokascript/planner";
+var grailTools = [
+  {
+    name: "grail_check",
+    description: "Evaluate GRAIL conditions and show available/blocked affordances. Returns passing conditions, failing conditions (with diagnostic output), available actions (preconditions met), and blocked actions (with unmet conditions).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        only: {
+          type: "string",
+          description: "Comma-separated condition names to evaluate (default: all)"
+        }
+      }
+    }
+  },
+  {
+    name: "grail_plan",
+    description: "Compute a dependency-ordered plan to make a goal affordance feasible. Returns ordered steps with phases, costs, and blocked-by links. Pass truth from a prior grail_check to skip re-evaluation.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        goal: {
+          type: "string",
+          description: 'The affordance name to plan for (e.g., "release-publish")'
+        },
+        truth: {
+          type: "object",
+          description: "Pre-evaluated truth vector from grail_check response (condition name \u2192 boolean). If omitted, evaluates all conditions (slow)."
+        }
+      },
+      required: ["goal"]
+    }
+  },
+  {
+    name: "grail_run",
+    description: "Execute a GRAIL affordance. Checks preconditions first \u2014 blocks if unmet. Respects confirmation gates. Use dry_run=true to preview without executing. Pass truth from a prior grail_check to skip re-evaluation of preconditions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          description: 'The affordance name to execute (e.g., "run-lint")'
+        },
+        dry_run: {
+          type: "boolean",
+          description: "Preview the action without executing (default: false)"
+        },
+        confirmed: {
+          type: "boolean",
+          description: "Confirm execution for actions with confirmation gates (default: false)"
+        },
+        truth: {
+          type: "object",
+          description: "Pre-evaluated truth vector from grail_check response (condition name \u2192 boolean). If omitted, evaluates all conditions to check preconditions (slow)."
+        }
+      },
+      required: ["action"]
+    }
+  },
+  {
+    name: "grail_info",
+    description: "Return the full GRAIL workflow graph: conditions with descriptions, affordances with preconditions/effects/cost, and the enables graph.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "grail_list",
+    description: "List all condition names and affordance names in the GRAIL configuration.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  }
+];
+var _registry = null;
+var _cwd = null;
+function getRegistry() {
+  const cwd = process.env.GRAIL_CWD ?? process.cwd();
+  if (_registry && _cwd === cwd) return _registry;
+  const yamlPath = findGrailYaml(cwd);
+  const config = loadGrailConfig(yamlPath);
+  _registry = new GrailRegistry(config, cwd);
+  _cwd = cwd;
+  return _registry;
+}
+async function handleCheck(args) {
+  const registry2 = getRegistry();
+  const only = getString(args, "only");
+  const results = await registry2.evaluateAll();
+  const cwd = process.env.GRAIL_CWD ?? process.cwd();
+  const conditionNames = only ? only.split(",").map((s) => s.trim()).filter(Boolean) : Object.keys(results);
+  const passing = [];
+  const failing = [];
+  const errors = [];
+  for (const name of conditionNames) {
+    const result = results[name];
+    if (!result) continue;
+    const cond = registry2.conditions.get(name);
+    const desc = cond?.description ?? "";
+    if (result.error) {
+      errors.push({ name, description: desc, error: result.error });
+    } else if (result.passing) {
+      passing.push({ name, description: desc });
+    } else {
+      failing.push({ name, description: desc, output: result.output });
+    }
+  }
+  const truth = {};
+  for (const [name, result] of Object.entries(results)) {
+    truth[name] = result.passing;
+  }
+  const available = [];
+  const blocked = [];
+  for (const [name, aff] of registry2.affordances) {
+    const check = registry2.checkPreconditions(name, truth);
+    if (check.met) {
+      available.push({ name, title: aff.title ?? name, cost: aff.cost ?? 1 });
+    } else {
+      blocked.push({ name, title: aff.title ?? name, unmet: check.unmet });
+    }
+  }
+  return jsonResponse({
+    cwd,
+    passing,
+    failing,
+    errors: errors.length > 0 ? errors : void 0,
+    summary: `${passing.length} passing, ${failing.length} failing`,
+    available,
+    blocked,
+    truth
+  });
+}
+async function handlePlan(args) {
+  const goal = getString(args, "goal");
+  if (!goal) return errorResponse("Missing required parameter: goal");
+  const registry2 = getRegistry();
+  const aff = registry2.affordances.get(goal);
+  if (!aff) {
+    return jsonResponse({
+      goal,
+      feasible: false,
+      reason: "unknown affordance",
+      unsatisfiable: [],
+      steps: []
+    });
+  }
+  let truth;
+  const suppliedTruth = args.truth;
+  if (suppliedTruth && typeof suppliedTruth === "object") {
+    truth = suppliedTruth;
+  } else {
+    const results = await registry2.evaluateAll();
+    truth = {};
+    for (const [name, result] of Object.entries(results)) {
+      truth[name] = result.passing;
+    }
+  }
+  const check = registry2.checkPreconditions(goal, truth);
+  if (check.met) {
+    const cmd = aff.action?.cmd ?? "";
+    return jsonResponse({
+      goal,
+      feasible: true,
+      phases: 1,
+      totalCost: aff.cost ?? 1,
+      currentConditions: truth,
+      steps: [
+        {
+          action: goal,
+          cmd,
+          resolves: aff.effects ?? [],
+          phase: 0,
+          cost: aff.cost ?? 1,
+          blocked_by: []
+        }
+      ]
+    });
+  }
+  const conditionMap = registry2.conditionMap();
+  const { defs, conditionNames, mutexPrefixes } = parseConditionMap(conditionMap);
+  const goalDef = defs.find((d) => d.name === goal);
+  if (!goalDef) {
+    return jsonResponse({
+      goal,
+      feasible: false,
+      reason: "unknown affordance in condition map",
+      unsatisfiable: [],
+      steps: []
+    });
+  }
+  const startState = /* @__PURE__ */ new Set();
+  for (const [name, passing] of Object.entries(truth)) {
+    if (passing) startState.add(name);
+  }
+  const unmet = goalDef.preconditions.filter((p) => !startState.has(p));
+  const planSteps = [];
+  const usedKeys = /* @__PURE__ */ new Set();
+  let currentState = startState;
+  for (const precond of unmet) {
+    if (currentState.has(precond)) continue;
+    const paths = bfsPlan(currentState, precond, defs, mutexPrefixes);
+    if (paths.length === 0) {
+      return jsonResponse({
+        goal,
+        feasible: false,
+        reason: "unsatisfiable conditions",
+        unsatisfiable: [precond],
+        currentConditions: truth,
+        steps: []
+      });
+    }
+    for (const step of paths[0]) {
+      if (usedKeys.has(step.key())) continue;
+      usedKeys.add(step.key());
+      planSteps.push({ name: step.name, params: { ...step.params } });
+      const affDef = defs.find((d) => d.name === step.name);
+      if (affDef) currentState = applyEffects(currentState, affDef, step.params, mutexPrefixes);
+    }
+  }
+  planSteps.push({ name: goal, params: {} });
+  const steps = planSteps.map((ps) => {
+    const stepAff = registry2.affordances.get(ps.name);
+    return {
+      action: ps.name,
+      cmd: stepAff?.action?.cmd ?? "",
+      resolves: stepAff?.effects ?? [],
+      phase: 0,
+      cost: stepAff?.cost ?? 1,
+      blocked_by: []
+    };
+  });
+  const condProducer = /* @__PURE__ */ new Map();
+  for (let i = 0; i < steps.length; i++) {
+    for (const effect of steps[i].resolves) {
+      condProducer.set(effect, i);
+    }
+  }
+  for (let i = 0; i < steps.length; i++) {
+    let depPhase = -1;
+    const stepAff = registry2.affordances.get(steps[i].action);
+    for (const precond of stepAff?.preconditions ?? []) {
+      const producerIdx = condProducer.get(precond);
+      if (producerIdx !== void 0 && producerIdx !== i) {
+        depPhase = Math.max(depPhase, steps[producerIdx].phase);
+      }
+    }
+    steps[i].phase = depPhase + 1;
+  }
+  for (let i = 0; i < steps.length; i++) {
+    for (const condition of steps[i].resolves) {
+      for (let j = i + 1; j < steps.length; j++) {
+        const laterAff = registry2.affordances.get(steps[j].action);
+        if ((laterAff?.preconditions ?? []).includes(condition)) {
+          steps[i].blocked_by.push({ condition, needed_by: steps[j].action });
+        }
+      }
+    }
+  }
+  const totalCost = steps.reduce((sum, s) => sum + s.cost, 0);
+  const phases = Math.max(...steps.map((s) => s.phase)) + 1;
+  return jsonResponse({
+    goal,
+    feasible: true,
+    phases,
+    totalCost,
+    currentConditions: truth,
+    steps
+  });
+}
+async function handleRun(args) {
+  const action = getString(args, "action");
+  if (!action) return errorResponse("Missing required parameter: action");
+  const dryRun = getBoolean(args, "dry_run");
+  const confirmed = getBoolean(args, "confirmed");
+  const registry2 = getRegistry();
+  const aff = registry2.affordances.get(action);
+  if (!aff) return errorResponse(`Unknown affordance: ${action}`);
+  let truth;
+  const suppliedTruth = args.truth;
+  if (suppliedTruth && typeof suppliedTruth === "object") {
+    truth = suppliedTruth;
+  } else if ((aff.preconditions ?? []).length === 0) {
+    truth = {};
+  } else {
+    const results = await registry2.evaluateAll();
+    truth = {};
+    for (const [name, result2] of Object.entries(results)) {
+      truth[name] = result2.passing;
+    }
+  }
+  const check = registry2.checkPreconditions(action, truth);
+  if (!check.met) {
+    return jsonResponse({
+      action,
+      blocked: true,
+      unmet: check.unmet,
+      hint: `Run grail_plan('${action}') to see what's needed`,
+      cmd: aff.action?.cmd ?? ""
+    });
+  }
+  if (aff.confirm && !confirmed) {
+    return jsonResponse({
+      action,
+      needsConfirmation: true,
+      message: aff.confirm === "true" || aff.confirm === true ? `Are you sure you want to run ${action}?` : aff.confirm,
+      hint: `Re-run with confirmed=true to proceed: grail_run('${action}', confirmed=true)`,
+      cmd: aff.action?.cmd ?? "",
+      effects: aff.effects ?? []
+    });
+  }
+  if (dryRun) {
+    return jsonResponse({
+      action,
+      dry_run: true,
+      preconditions_met: true,
+      cmd: aff.action?.cmd ?? "",
+      effects: aff.effects ?? []
+    });
+  }
+  const result = await registry2.run(action);
+  const driftWarnings = [];
+  if (result.success && (aff.effects?.length ?? 0) > 0) {
+    const postResults = await registry2.evaluateAll();
+    for (const effect of aff.effects ?? []) {
+      if (!effect.includes("{") && postResults[effect] && !postResults[effect].passing) {
+        driftWarnings.push(`Effect '${effect}' declared but not true after execution`);
+      }
+    }
+  }
+  return jsonResponse({
+    action,
+    success: result.success,
+    cmd: result.cmd,
+    exitCode: result.exitCode,
+    duration_ms: result.duration_ms,
+    output: result.output,
+    effects: aff.effects ?? [],
+    driftWarnings: driftWarnings.length > 0 ? driftWarnings : void 0
+  });
+}
+function handleInfo() {
+  const registry2 = getRegistry();
+  const conditions = {};
+  for (const [name, cond] of registry2.conditions) {
+    conditions[name] = { description: cond.description };
+  }
+  const affordances = {};
+  for (const [name, aff] of registry2.affordances) {
+    affordances[name] = {
+      title: aff.title ?? name,
+      preconditions: aff.preconditions ?? [],
+      effects: aff.effects ?? [],
+      cost: aff.cost ?? 1,
+      cmd: aff.action?.cmd ?? ""
+    };
+  }
+  return jsonResponse({
+    domain: { name: "hyperfixi" },
+    conditions,
+    affordances,
+    enablesGraph: registry2.enablesGraph()
+  });
+}
+function handleList() {
+  const registry2 = getRegistry();
+  return jsonResponse({
+    conditions: [...registry2.conditions.keys()],
+    affordances: [...registry2.affordances.keys()]
+  });
+}
+async function handleGrailTool(name, args) {
+  try {
+    switch (name) {
+      case "grail_check":
+        return await handleCheck(args);
+      case "grail_plan":
+        return await handlePlan(args);
+      case "grail_run":
+        return await handleRun(args);
+      case "grail_info":
+        return handleInfo();
+      case "grail_list":
+        return handleList();
+      default:
+        return errorResponse(`Unknown GRAIL tool: ${name}`);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return errorResponse(`GRAIL tool error: ${message}`);
+  }
+}
+
+// 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
@@ -9930,7 +10416,9 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       ...inventoryTools,
       ...trainingDataTools,
       ...feedbackTools,
-      ...lsePipelineTools
+      ...lsePipelineTools,
+      ...grailTools,
+      ...lseCorrectionTools
     ]
   };
 });
@@ -9995,6 +10483,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   if (name === "lse_from_hyperscript" || name === "lse_to_hyperscript") {
     return handleLsePipelineTool(name, args);
   }
+  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);
   }