@almadar/agent 1.0.14 → 1.1.1

package/dist/agent/index.js

@@ -1,4 +1,4 @@
-import { isOrbitalDefinition, getTraitName, isEntityReference, isPageReferenceString, isPageReferenceObject } from '@almadar/core/types';
+import { isOrbitalDefinition, isEntityReference, getTraitName } from '@almadar/core/types';
 import { FilesystemBackend, createDeepAgent } from 'deepagents';
 import { MemorySaver } from '@langchain/langgraph';
 export { Command } from '@langchain/langgraph';
@@ -10,17 +10,34 @@ import { exec, spawn } from 'child_process';
 import * as path from 'path';
 import { promisify } from 'util';
 import * as fs4 from 'fs/promises';
-import { getPatternDefinition } from '@almadar/patterns';
+import * as domain_language_star from '@almadar/core/domain-language';
 import * as fs3 from 'fs';
 import crypto, { randomUUID } from 'crypto';
-import { getFullOrbitalPrompt, getRequirementsTraitPrompt, getKeyBehaviorsReference, getSExprQuickRef, getCommonErrorsSection, getArchitectureSection } from '@almadar/skills';
+import { getFullOrbitalPrompt, generateKflowDesignSkill, getRequirementsTraitPrompt, getKeyBehaviorsReference, getSExprQuickRef, getCommonErrorsSection, getArchitectureSection } from '@almadar/skills';
+import { formatRecommendationsForPrompt, buildRecommendationContext, recommendPatterns } from '@almadar/patterns';
 import { GitHubIntegration } from '@almadar/integrations';
 import { BaseCheckpointSaver } from '@langchain/langgraph-checkpoint';
 
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget);
 function getInlineEntity(entity) {
   if (isEntityReference(entity)) {
     return null;
@@ -640,3042 +657,398 @@ function combineOrbitals(orbitals, options) {
     const validation = validate ? { valid: true, errors: [], warnings: [] } : void 0;
     return {
       success: true,
-      schema: orbitalSchema,
-      validation,
-      stats
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error),
-      stats
-    };
-  }
-}
-
-// src/orbitals/domain-language/tokens.ts
-var KEYWORDS = {
-  "a": "A" /* A */,
-  "an": "AN" /* AN */,
-  "is": "IS" /* IS */,
-  "it": "IT" /* IT */,
-  "has": "HAS" /* HAS */,
-  "belongs": "BELONGS" /* BELONGS */,
-  "to": "TO" /* TO */,
-  "many": "MANY" /* MANY */,
-  "one": "ONE" /* ONE */,
-  "as": "AS" /* AS */,
-  "can": "CAN" /* CAN */,
-  "be": "BE" /* BE */,
-  "starts": "STARTS" /* STARTS */,
-  "the": "THE" /* THE */,
-  "shows": "SHOWS" /* SHOWS */,
-  "entity": "ENTITY" /* ENTITY */,
-  "purpose": "PURPOSE" /* PURPOSE */,
-  "url": "URL" /* URL */,
-  "displays": "DISPLAYS" /* DISPLAYS */,
-  "users": "USERS" /* USERS */,
-  "when": "WHEN" /* WHEN */,
-  "on": "WHEN" /* WHEN */,
-  // "on EVENT" is equivalent to "when EVENT"
-  "accessed": "ACCESSED" /* ACCESSED */,
-  "lifecycle": "LIFECYCLE" /* LIFECYCLE */,
-  "behavior": "BEHAVIOR" /* BEHAVIOR */,
-  "states": "STATES" /* STATES */,
-  "initial": "INITIAL" /* INITIAL */,
-  "transitions": "TRANSITIONS" /* TRANSITIONS */,
-  "from": "FROM" /* FROM */,
-  "if": "IF" /* IF */,
-  "then": "THEN" /* THEN */,
-  "rules": "RULES" /* RULES */,
-  "every": "EVERY" /* EVERY */,
-  "check": "CHECK" /* CHECK */,
-  "and": "AND" /* AND */,
-  "or": "OR" /* OR */,
-  "not": "NOT" /* NOT */,
-  "provided": "PROVIDED" /* PROVIDED */,
-  "empty": "EMPTY" /* EMPTY */,
-  "user": "USER" /* USER */,
-  "owns": "OWNS" /* OWNS */,
-  "this": "THIS" /* THIS */,
-  "text": "TEXT" /* TEXT */,
-  "number": "NUMBER" /* NUMBER */,
-  "currency": "CURRENCY" /* CURRENCY */,
-  "date": "DATE" /* DATE */,
-  "timestamp": "TIMESTAMP" /* TIMESTAMP */,
-  "required": "REQUIRED" /* REQUIRED */,
-  "unique": "UNIQUE" /* UNIQUE */,
-  "auto": "AUTO" /* AUTO */,
-  "default": "DEFAULT" /* DEFAULT */,
-  "true": "BOOLEAN" /* BOOLEAN */,
-  "false": "BOOLEAN" /* BOOLEAN */
-};
-
-// src/orbitals/domain-language/lexer.ts
-var Lexer = class {
-  constructor(input) {
-    this.pos = 0;
-    this.line = 1;
-    this.column = 1;
-    this.indentStack = [0];
-    this.input = input;
-  }
-  /**
-   * Tokenize the entire input
-   */
-  tokenize() {
-    const tokens = [];
-    while (!this.isAtEnd()) {
-      const token = this.nextToken();
-      if (token) {
-        tokens.push(token);
-      }
-    }
-    while (this.indentStack.length > 1) {
-      this.indentStack.pop();
-      tokens.push(this.makeToken("DEDENT" /* DEDENT */, ""));
-    }
-    tokens.push(this.makeToken("EOF" /* EOF */, ""));
-    return tokens;
-  }
-  nextToken() {
-    if (this.column === 1) {
-      const indentToken = this.handleIndentation();
-      if (indentToken) {
-        return indentToken;
-      }
-    }
-    this.skipWhitespace();
-    if (this.isAtEnd()) {
-      return null;
-    }
-    const char = this.peek();
-    if (char === "\n") {
-      return this.consumeNewline();
-    }
-    if (char === "#") {
-      this.skipToEndOfLine();
-      return this.nextToken();
-    }
-    if (char === '"' || char === "'") {
-      return this.consumeString(char);
-    }
-    if (this.isDigit(char)) {
-      return this.consumeNumber();
-    }
-    switch (char) {
-      case ":":
-        return this.consumeChar("COLON" /* COLON */);
-      case ",":
-        return this.consumeChar("COMMA" /* COMMA */);
-      case "|":
-        return this.consumeChar("PIPE" /* PIPE */);
-      case ".":
-        return this.consumeChar("DOT" /* DOT */);
-      case "-":
-        return this.consumeChar("DASH" /* DASH */);
-      case "[":
-        return this.consumeChar("LBRACKET" /* LBRACKET */);
-      case "]":
-        return this.consumeChar("RBRACKET" /* RBRACKET */);
-      case "(":
-        return this.consumeChar("LPAREN" /* LPAREN */);
-      case ")":
-        return this.consumeChar("RPAREN" /* RPAREN */);
-      case ">":
-        if (this.peekNext() === "=") {
-          return this.consumeChars(2, "GREATER_EQUAL" /* GREATER_EQUAL */);
-        }
-        return this.consumeChar("GREATER_THAN" /* GREATER_THAN */);
-      case "<":
-        if (this.peekNext() === "=") {
-          return this.consumeChars(2, "LESS_EQUAL" /* LESS_EQUAL */);
-        }
-        return this.consumeChar("LESS_THAN" /* LESS_THAN */);
-      case "=":
-        if (this.peekNext() === "=") {
-          return this.consumeChars(2, "EQUALS" /* EQUALS */);
-        }
-        break;
-      case "!":
-        if (this.peekNext() === "=") {
-          return this.consumeChars(2, "NOT_EQUALS" /* NOT_EQUALS */);
-        }
-        break;
-    }
-    if (char === "{") {
-      return this.consumeTemplateVar();
-    }
-    if (this.isAlpha(char)) {
-      return this.consumeIdentifier();
-    }
-    this.advance();
-    return this.nextToken();
-  }
-  consumeTemplateVar() {
-    const start = this.pos;
-    this.advance();
-    let braceDepth = 1;
-    while (!this.isAtEnd() && braceDepth > 0 && this.peek() !== "\n") {
-      const ch = this.peek();
-      if (ch === "{") {
-        braceDepth++;
-      } else if (ch === "}") {
-        braceDepth--;
-        if (braceDepth === 0) {
-          this.advance();
-          break;
-        }
-      }
-      this.advance();
-    }
-    const value = this.input.substring(start, this.pos);
-    return this.makeToken("TEMPLATE_VAR" /* TEMPLATE_VAR */, value);
-  }
-  handleIndentation() {
-    if (this.isAtEnd() || this.peek() === "\n") {
-      return null;
-    }
-    let indent = 0;
-    while (this.peek() === " " || this.peek() === "	") {
-      indent += this.peek() === "	" ? 4 : 1;
-      this.advance();
-    }
-    if (this.peek() === "\n" || this.peek() === "#") {
-      return null;
-    }
-    const currentIndent = this.indentStack[this.indentStack.length - 1];
-    if (indent > currentIndent) {
-      this.indentStack.push(indent);
-      return this.makeToken("INDENT" /* INDENT */, "");
-    } else if (indent < currentIndent) {
-      while (this.indentStack.length > 1 && this.indentStack[this.indentStack.length - 1] > indent) {
-        this.indentStack.pop();
-      }
-      return this.makeToken("DEDENT" /* DEDENT */, "");
-    }
-    return null;
-  }
-  consumeNewline() {
-    const token = this.makeToken("NEWLINE" /* NEWLINE */, "\n");
-    this.advance();
-    this.line++;
-    this.column = 1;
-    return token;
-  }
-  consumeString(quote) {
-    const startLine = this.line;
-    const startColumn = this.column;
-    const startOffset = this.pos;
-    this.advance();
-    let value = "";
-    while (!this.isAtEnd() && this.peek() !== quote) {
-      if (this.peek() === "\\" && this.peekNext() === quote) {
-        this.advance();
-        value += quote;
-      } else if (this.peek() === "\n") {
-        break;
-      } else {
-        value += this.peek();
-      }
-      this.advance();
-    }
-    if (this.peek() === quote) {
-      this.advance();
-    }
-    return {
-      type: "STRING" /* STRING */,
-      value,
-      line: startLine,
-      column: startColumn,
-      offset: startOffset
-    };
-  }
-  consumeNumber() {
-    const startLine = this.line;
-    const startColumn = this.column;
-    const startOffset = this.pos;
-    let value = "";
-    while (this.isDigit(this.peek())) {
-      value += this.advance();
-    }
-    if (this.peek() === "." && this.isDigit(this.peekNext())) {
-      value += this.advance();
-      while (this.isDigit(this.peek())) {
-        value += this.advance();
-      }
-    }
-    return {
-      type: "NUMBER_LITERAL" /* NUMBER_LITERAL */,
-      value,
-      line: startLine,
-      column: startColumn,
-      offset: startOffset
-    };
-  }
-  consumeIdentifier() {
-    const startLine = this.line;
-    const startColumn = this.column;
-    const startOffset = this.pos;
-    let value = "";
-    while (this.isAlphaNumeric(this.peek()) || this.peek() === "_" || this.peek() === "/") {
-      value += this.advance();
-    }
-    const lowerValue = value.toLowerCase();
-    const keywordType = KEYWORDS[lowerValue];
-    return {
-      type: keywordType || "IDENTIFIER" /* IDENTIFIER */,
-      value,
-      line: startLine,
-      column: startColumn,
-      offset: startOffset
-    };
-  }
-  consumeChar(type) {
-    const token = this.makeToken(type, this.peek());
-    this.advance();
-    return token;
-  }
-  consumeChars(count, type) {
-    let value = "";
-    for (let i = 0; i < count; i++) {
-      value += this.advance();
-    }
-    return {
-      type,
-      value,
-      line: this.line,
-      column: this.column - count,
-      offset: this.pos - count
-    };
-  }
-  skipWhitespace() {
-    while (!this.isAtEnd() && (this.peek() === " " || this.peek() === "	")) {
-      this.advance();
-    }
-  }
-  skipToEndOfLine() {
-    while (!this.isAtEnd() && this.peek() !== "\n") {
-      this.advance();
-    }
-  }
-  makeToken(type, value) {
-    return {
-      type,
-      value,
-      line: this.line,
-      column: this.column,
-      offset: this.pos
-    };
-  }
-  peek() {
-    return this.input[this.pos] || "\0";
-  }
-  peekNext() {
-    return this.input[this.pos + 1] || "\0";
-  }
-  advance() {
-    const char = this.peek();
-    this.pos++;
-    this.column++;
-    return char;
-  }
-  isAtEnd() {
-    return this.pos >= this.input.length;
-  }
-  isDigit(char) {
-    return char >= "0" && char <= "9";
-  }
-  isAlpha(char) {
-    return char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char === "_";
-  }
-  isAlphaNumeric(char) {
-    return this.isAlpha(char) || this.isDigit(char);
-  }
-};
-
-// src/orbitals/domain-language/parsers/entity-parser.ts
-function parseEntity(text) {
-  const ctx = { errors: [], warnings: [] };
-  const lexer = new Lexer(text);
-  const tokens = lexer.tokenize();
-  let pos = 0;
-  const current = () => tokens[pos] || { type: "EOF" /* EOF */, value: "", line: 0, column: 0, offset: 0 };
-  const advance = () => tokens[pos++];
-  const isAtEnd = () => current().type === "EOF" /* EOF */;
-  const skip = (type) => {
-    while (current().type === type) advance();
-  };
-  skip("NEWLINE" /* NEWLINE */);
-  const entityHeader = parseEntityHeader();
-  if (!entityHeader) {
-    return {
-      success: false,
-      errors: ctx.errors.length > 0 ? ctx.errors : [{
-        message: 'Expected entity definition starting with "A [Name] is..."'
-      }],
-      warnings: []
-    };
-  }
-  const entity = {
-    type: "entity",
-    name: entityHeader.name,
-    description: entityHeader.description,
-    fields: [],
-    relationships: []
-  };
-  skip("NEWLINE" /* NEWLINE */);
-  while (!isAtEnd()) {
-    skip("NEWLINE" /* NEWLINE */);
-    if (isAtEnd()) break;
-    const sectionResult = parseSection(entity);
-    if (!sectionResult) {
-      advance();
-    }
-  }
-  return {
-    success: true,
-    data: entity,
-    errors: ctx.errors,
-    warnings: ctx.warnings
-  };
-  function isEntityName(token) {
-    if (token.type === "IDENTIFIER" /* IDENTIFIER */) return true;
-    const keywordEntityNames = [
-      "USER" /* USER */,
-      // "User"
-      "TEXT" /* TEXT */,
-      // "Text" (unlikely but possible)
-      "NUMBER" /* NUMBER */,
-      // "Number" (unlikely but possible)
-      "DATE" /* DATE */
-      // "Date" (unlikely but possible)
-    ];
-    return keywordEntityNames.includes(token.type);
-  }
-  function parseEntityHeader() {
-    if (current().type !== "A" /* A */ && current().type !== "AN" /* AN */) {
-      ctx.errors.push({ message: 'Expected "A" or "An" at start of entity definition' });
-      return null;
-    }
-    advance();
-    if (!isEntityName(current())) {
-      ctx.errors.push({ message: 'Expected entity name after "A"' });
-      return null;
-    }
-    const name = current().value;
-    advance();
-    if (current().type !== "IS" /* IS */) {
-      ctx.errors.push({ message: `Expected "is" after entity name "${name}"` });
-      return null;
-    }
-    advance();
-    const descParts = [];
-    while (!isAtEnd() && current().type !== "NEWLINE" /* NEWLINE */) {
-      descParts.push(current().value);
-      advance();
-    }
-    return {
-      name,
-      description: descParts.join(" ").trim()
-    };
-  }
-  function parseSection(entity2) {
-    const token = current();
-    if (token.type === "INDENT" /* INDENT */) {
-      advance();
-      parseIndentedFields(entity2);
-      return true;
-    }
-    if (token.type === "IT" /* IT */) {
-      advance();
-      if (current().type === "HAS" /* HAS */) {
-        advance();
-        skip("COLON" /* COLON */);
-        skip("NEWLINE" /* NEWLINE */);
-        parseFieldsSection(entity2);
-        return true;
-      }
-      if (current().type === "BELONGS" /* BELONGS */) {
-        advance();
-        if (current().type === "TO" /* TO */) {
-          advance();
-          parseRelationship(entity2, "belongs_to");
-          return true;
-        }
-      }
-      if (current().type === "CAN" /* CAN */) {
-        advance();
-        if (current().type === "BE" /* BE */) {
-          advance();
-          skip("COLON" /* COLON */);
-          parseStates(entity2);
-          return true;
-        }
-      }
-      if (current().type === "STARTS" /* STARTS */) {
-        advance();
-        if (current().type === "AS" /* AS */) {
-          advance();
-          parseInitialState(entity2);
-          return true;
-        }
-      }
-    }
-    if (token.type === "HAS" /* HAS */) {
-      advance();
-      if (current().type === "MANY" /* MANY */) {
-        advance();
-        parseRelationship(entity2, "has_many");
-        return true;
-      }
-      if (current().type === "ONE" /* ONE */) {
-        advance();
-        parseRelationship(entity2, "has_one");
-        return true;
-      }
-    }
-    return false;
-  }
-  function parseIndentedFields(entity2) {
-    while (!isAtEnd() && current().type !== "DEDENT" /* DEDENT */) {
-      skip("NEWLINE" /* NEWLINE */);
-      if (current().type === "DEDENT" /* DEDENT */) break;
-      if (current().type === "DASH" /* DASH */) {
-        advance();
-      }
-      if (current().type === "HAS" /* HAS */) {
-        advance();
-        if (current().type === "MANY" /* MANY */) {
-          advance();
-          parseRelationship(entity2, "has_many");
-          continue;
-        }
-        const field = parseHasFieldLine();
-        if (field) {
-          entity2.fields.push(field);
-        }
-        continue;
-      }
-      if (current().type === "BELONGS" /* BELONGS */) {
-        advance();
-        if (current().type === "TO" /* TO */) {
-          advance();
-          parseRelationship(entity2, "belongs_to");
-          continue;
-        }
-      }
-      while (!isAtEnd() && current().type !== "NEWLINE" /* NEWLINE */ && current().type !== "DEDENT" /* DEDENT */) {
-        advance();
-      }
-      skip("NEWLINE" /* NEWLINE */);
-    }
-    if (current().type === "DEDENT" /* DEDENT */) {
-      advance();
-    }
-  }
-  function parseHasFieldLine() {
-    if (current().type !== "IDENTIFIER" /* IDENTIFIER */) {
-      return null;
-    }
-    const fieldName = toCamelCase(current().value);
-    advance();
-    if (current().type !== "AS" /* AS */) {
-      while (!isAtEnd() && current().type !== "NEWLINE" /* NEWLINE */ && current().type !== "DEDENT" /* DEDENT */) {
-        advance();
-      }
-      return null;
-    }
-    advance();
-    const field = {
-      type: "field",
-      name: fieldName,
-      fieldType: "text",
-      required: false,
-      unique: false,
-      auto: false
-    };
-    const typeParts = [];
-    while (!isAtEnd() && current().type !== "NEWLINE" /* NEWLINE */ && current().type !== "DEDENT" /* DEDENT */ && current().type !== "LPAREN" /* LPAREN */ && current().value !== "with") {
-      typeParts.push(current().value);
-      advance();
-    }
-    const typeText = typeParts.join(" ").trim().toLowerCase();
-    if (typeText.includes("long text")) {
-      field.fieldType = "long text";
-    } else if (typeText === "text" || typeText === "string") {
-      field.fieldType = "text";
-    } else if (typeText === "number" || typeText === "integer") {
-      field.fieldType = "number";
-    } else if (typeText === "currency") {
-      field.fieldType = "currency";
-    } else if (typeText === "yes/no" || typeText === "boolean") {
-      field.fieldType = "yes/no";
-    } else if (typeText === "date") {
-      field.fieldType = "date";
-    } else if (typeText === "timestamp" || typeText === "datetime") {
-      field.fieldType = "timestamp";
-    } else if (typeText.startsWith("enum")) {
-      field.fieldType = "enum";
-      const enumMatch = typeText.match(/enum\s*\[([^\]]+)\]/);
-      if (enumMatch) {
-        field.enumValues = enumMatch[1].split(",").map((v) => v.trim());
-      }
-    } else if (typeText === "list" || typeText === "array") {
-      field.fieldType = "list";
-    } else if (typeText === "object") {
-      field.fieldType = "object";
-    } else {
-      field.fieldType = "text";
-    }
-    if (current().type === "LPAREN" /* LPAREN */) {
-      advance();
-      while (!isAtEnd() && current().type !== "RPAREN" /* RPAREN */ && current().type !== "NEWLINE" /* NEWLINE */) {
-        const constraint = current().value.toLowerCase();
-        if (constraint === "required") {
-          field.required = true;
-        } else if (constraint === "optional") {
-          field.required = false;
-        } else if (constraint === "unique") {
-          field.unique = true;
-        }
-        advance();
-      }
-      if (current().type === "RPAREN" /* RPAREN */) {
-        advance();
-      }
-    }
-    if (current().type === "IDENTIFIER" /* IDENTIFIER */ && current().value.toLowerCase() === "with") {
-      advance();
-      if (current().type === "DEFAULT" /* DEFAULT */) {
-        advance();
-        if (current().type === "STRING" /* STRING */) {
-          field.default = current().value;
-          advance();
-        } else if (current().type === "NUMBER_LITERAL" /* NUMBER_LITERAL */) {
-          field.default = parseFloat(current().value);
-          advance();
-        } else if (current().type === "BOOLEAN" /* BOOLEAN */) {
-          field.default = current().value === "true";
-          advance();
-        } else if (current().type === "IDENTIFIER" /* IDENTIFIER */) {
-          field.default = current().value;
-          advance();
-        }
-      }
-    }
-    return field;
-  }
-  function parseFieldsSection(entity2) {
-    if (current().type !== "INDENT" /* INDENT */) {
-      return;
-    }
-    advance();
-    while (!isAtEnd() && current().type !== "DEDENT" /* DEDENT */) {
-      skip("NEWLINE" /* NEWLINE */);
-      if (current().type === "DEDENT" /* DEDENT */) break;
-      const field = parseFieldLine();
-      if (field) {
-        entity2.fields.push(field);
-      }
-      skip("NEWLINE" /* NEWLINE */);
-    }
-    if (current().type === "DEDENT" /* DEDENT */) {
-      advance();
-    }
-  }
-  function parseFieldLine() {
-    if (current().type === "DASH" /* DASH */) {
-      advance();
-    }
-    const nameParts = [];
-    while (!isAtEnd() && current().type !== "COLON" /* COLON */ && current().type !== "NEWLINE" /* NEWLINE */) {
-      nameParts.push(current().value);
-      advance();
-    }
-    if (nameParts.length === 0) {
-      return null;
-    }
-    const fieldName = toCamelCase(nameParts.join(" "));
-    if (current().type !== "COLON" /* COLON */) {
-      ctx.errors.push({ message: `Expected ":" after field name "${fieldName}"` });
-      return null;
-    }
-    advance();
-    return parseFieldTypeAndConstraints(fieldName);
-  }
-  function parseFieldTypeAndConstraints(fieldName) {
-    const field = {
-      type: "field",
-      name: fieldName,
-      fieldType: "text",
-      required: false,
-      unique: false,
-      auto: false
-    };
-    const parts = [];
-    while (!isAtEnd() && current().type !== "NEWLINE" /* NEWLINE */) {
-      parts.push(current().value);
-      advance();
-    }
-    const content = parts.join(" ").trim();
-    if (content.includes("|")) {
-      field.fieldType = "enum";
-      field.enumValues = content.split("|").map((v) => v.trim()).filter((v) => v);
-      return field;
-    }
-    const segments = content.split(",").map((s) => s.trim().toLowerCase());
-    for (const segment of segments) {
-      if (segment === "text") field.fieldType = "text";
-      else if (segment === "long text") field.fieldType = "long text";
-      else if (segment === "number") field.fieldType = "number";
-      else if (segment === "currency") field.fieldType = "currency";
-      else if (segment === "date") field.fieldType = "date";
-      else if (segment === "timestamp") field.fieldType = "timestamp";
-      else if (segment === "datetime") field.fieldType = "datetime";
-      else if (segment === "yes/no" || segment === "boolean") field.fieldType = "yes/no";
-      else if (segment === "list") field.fieldType = "list";
-      else if (segment === "object") field.fieldType = "object";
-      else if (segment === "required") field.required = true;
-      else if (segment === "unique") field.unique = true;
-      else if (segment === "auto") field.auto = true;
-      else if (segment.startsWith("default ")) {
-        field.default = parseValue(segment.slice(8));
-      }
-    }
-    return field;
-  }
-  function parseRelationship(entity2, relType) {
-    if (current().type !== "IDENTIFIER" /* IDENTIFIER */) {
-      return;
-    }
-    const targetEntity = current().value;
-    advance();
-    let alias;
-    if (current().type === "AS" /* AS */) {
-      advance();
-      if (current().type === "IDENTIFIER" /* IDENTIFIER */) {
-        alias = current().value;
-        advance();
-      }
-    }
-    entity2.relationships.push({
-      type: "relationship",
-      relationshipType: relType,
-      targetEntity,
-      alias
-    });
-  }
-  function parseStates(entity2) {
-    const states = [];
-    while (!isAtEnd() && current().type !== "NEWLINE" /* NEWLINE */) {
-      if (current().type === "IDENTIFIER" /* IDENTIFIER */) {
-        states.push(current().value);
-      }
-      advance();
-    }
-    entity2.states = states;
-  }
-  function parseInitialState(entity2) {
-    if (current().type === "IDENTIFIER" /* IDENTIFIER */) {
-      entity2.initialState = current().value;
-      advance();
-    }
-  }
-}
-function formatEntityToSchema(entity) {
-  const fields = entity.fields.map((field) => ({
-    name: field.name,
-    type: mapFieldTypeToSchema(field.fieldType),
-    required: field.required || void 0,
-    unique: field.unique || void 0,
-    auto: field.auto || void 0,
-    values: field.enumValues,
-    // OrbitalSchema uses 'values' not 'enumValues'
-    default: field.default
-  }));
-  for (const rel of entity.relationships) {
-    if (rel.relationshipType === "belongs_to") {
-      const fieldName = rel.alias ? toCamelCase(rel.alias) + "Id" : toCamelCase(rel.targetEntity) + "Id";
-      fields.push({
-        name: fieldName,
-        type: "relation",
-        required: void 0,
-        unique: void 0,
-        auto: void 0,
-        values: void 0,
-        default: void 0,
-        relation: {
-          entity: rel.targetEntity,
-          type: "many-to-one"
-        }
-      });
-    }
-  }
-  return {
-    name: entity.name,
-    collection: toKebabCase(entity.name) + "s",
-    fields: fields.filter((f) => Object.keys(f).length > 0),
-    states: entity.states,
-    initialState: entity.initialState
-  };
-}
-function toCamelCase(text) {
-  return text.toLowerCase().split(/\s+/).map(
-    (word, index) => index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)
-  ).join("");
-}
-function toKebabCase(text) {
-  return text.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
-}
-function parseValue(text) {
-  text = text.trim();
-  if (text.toLowerCase() === "true") return true;
-  if (text.toLowerCase() === "false") return false;
-  const num = parseFloat(text);
-  if (!isNaN(num)) return num;
-  return text.replace(/^["']|["']$/g, "");
-}
-function mapFieldTypeToSchema(fieldType) {
-  const mapping = {
-    "text": "string",
-    "long text": "string",
-    "number": "number",
-    "currency": "number",
-    "date": "date",
-    "timestamp": "timestamp",
-    "datetime": "datetime",
-    "yes/no": "boolean",
-    "enum": "enum",
-    "list": "array",
-    "object": "object",
-    "relation": "relation"
-  };
-  return mapping[fieldType] || "string";
-}
-
-// src/orbitals/domain-language/parsers/page-parser.ts
-function parsePage(text) {
-  const ctx = { errors: [], warnings: [] };
-  const lexer = new Lexer(text);
-  const tokens = lexer.tokenize();
-  let pos = 0;
-  const current = () => tokens[pos] || { type: "EOF" /* EOF */, value: "", line: 0, column: 0, offset: 0 };
-  const advance = () => tokens[pos++];
-  const isAtEnd = () => current().type === "EOF" /* EOF */;
-  const skip = (type) => {
-    while (current().type === type) advance();
-  };
-  skip("NEWLINE" /* NEWLINE */);
-  const pageHeader = parsePageHeader();
-  if (!pageHeader) {
-    return {
-      success: false,
-      errors: ctx.errors.length > 0 ? ctx.errors : [{
-        message: 'Expected page definition starting with "The [PageName] shows..."'
-      }],
-      warnings: []
-    };
-  }
-  const page = {
-    type: "page",
-    name: pageHeader.name,
-    description: pageHeader.description,
-    purpose: "",
-    url: pageHeader.url || "",
-    primaryEntity: pageHeader.primaryEntity,
-    traitName: pageHeader.traitName,
-    sections: [],
-    actions: []
-  };
-  skip("NEWLINE" /* NEWLINE */);
-  while (!isAtEnd()) {
-    skip("NEWLINE" /* NEWLINE */);
-    if (isAtEnd()) break;
-    const parsed = parsePageSection(page);
-    if (!parsed) {
-      advance();
-    }
-  }
-  if (!page.url) {
-    page.url = "/" + toKebabCase2(page.name.replace(/Page$/i, ""));
-  }
-  return {
-    success: true,
-    data: page,
-    errors: ctx.errors,
-    warnings: ctx.warnings
-  };
-  function parsePageHeader() {
-    if (current().type === "IDENTIFIER" /* IDENTIFIER */) {
-      const firstToken = current().value;
-      advance();
-      const nameParts2 = [firstToken];
-      while (current().type === "IDENTIFIER" /* IDENTIFIER */ && current().value.toLowerCase() !== "at") {
-        nameParts2.push(current().value);
-        advance();
-      }
-      if (current().type === "IDENTIFIER" /* IDENTIFIER */ && current().value.toLowerCase() === "at") {
-        advance();
-        const pathParts = [];
-        while (!isAtEnd() && current().type !== "COLON" /* COLON */ && current().type !== "NEWLINE" /* NEWLINE */) {
-          pathParts.push(current().value);
-          advance();
-        }
-        const url = pathParts.join("");
-        if (current().type === "COLON" /* COLON */) {
-          advance();
-        }
-        let name2 = nameParts2.map((p) => toPascalCase(p)).join("");
-        if (!name2.toLowerCase().endsWith("page")) {
-          name2 += "Page";
-        }
-        skip("NEWLINE" /* NEWLINE */);
-        let primaryEntity;
-        let traitName;
-        if (current().type === "INDENT" /* INDENT */) {
-          advance();
-          while (!isAtEnd() && current().type !== "DEDENT" /* DEDENT */) {
-            skip("NEWLINE" /* NEWLINE */);
-            if (current().type === "DEDENT" /* DEDENT */) break;
-            if (current().type === "DASH" /* DASH */) {
-              advance();
-            }
-            if (current().type === "SHOWS" /* SHOWS */) {
-              advance();
-              if (current().type === "IDENTIFIER" /* IDENTIFIER */) {
-                primaryEntity = current().value;
-                advance();
-              }
-              if (current().type === "IDENTIFIER" /* IDENTIFIER */ && current().value.toLowerCase() === "using") {
-                advance();
-                if (current().type === "IDENTIFIER" /* IDENTIFIER */) {
-                  traitName = current().value;
-                  advance();
-                }
-              }
-            }
-            while (!isAtEnd() && current().type !== "NEWLINE" /* NEWLINE */ && current().type !== "DEDENT" /* DEDENT */) {
-              advance();
-            }
-            skip("NEWLINE" /* NEWLINE */);
-          }
-          if (current().type === "DEDENT" /* DEDENT */) {
-            advance();
-          }
-        }
-        return {
-          name: name2,
-          description: `Page at ${url}`,
-          url,
-          primaryEntity,
-          traitName
-        };
-      }
-    }
-    if (current().type !== "THE" /* THE */) {
-      ctx.errors.push({ message: 'Expected "The" at start of page definition' });
-      return null;
-    }
-    advance();
-    const nameParts = [];
-    while (current().type === "IDENTIFIER" /* IDENTIFIER */) {
-      nameParts.push(current().value);
-      advance();
-    }
-    if (nameParts.length === 0) {
-      ctx.errors.push({ message: 'Expected page name after "The"' });
-      return null;
-    }
-    let name = nameParts.map((p) => toPascalCase(p)).join("");
-    if (!name.toLowerCase().endsWith("page")) {
-      name += "Page";
-    }
-    if (current().type !== "SHOWS" /* SHOWS */) {
-      ctx.errors.push({ message: `Expected "shows" after page name "${name}"` });
-      return null;
-    }
-    advance();
-    const descParts = [];
-    while (!isAtEnd() && current().type !== "NEWLINE" /* NEWLINE */) {
-      descParts.push(current().value);
-      advance();
-    }
-    return {
-      name,
-      description: descParts.join(" ").trim()
-    };
-  }
-  function parsePageSection(page2) {
-    const token = current();
-    if (token.type === "ENTITY" /* ENTITY */) {
-      advance();
-      skip("COLON" /* COLON */);
-      page2.primaryEntity = collectUntilNewline();
-      return true;
-    }
-    if (token.type === "PURPOSE" /* PURPOSE */) {
-      advance();
-      skip("COLON" /* COLON */);
-      page2.purpose = collectUntilNewline();
-      return true;
-    }
-    if (token.type === "URL" /* URL */) {
-      advance();
-      skip("COLON" /* COLON */);
-      page2.url = collectUntilNewline();
-      return true;
-    }
-    if (token.type === "IT" /* IT */) {
-      advance();
-      if (current().type === "DISPLAYS" /* DISPLAYS */) {
-        advance();
-        skip("COLON" /* COLON */);
-        skip("NEWLINE" /* NEWLINE */);
-        parseDisplaysSection(page2);
-        return true;
-      }
-    }
-    if (token.type === "USERS" /* USERS */) {
-      advance();
-      if (current().type === "CAN" /* CAN */) {
-        advance();
-        skip("COLON" /* COLON */);
-        skip("NEWLINE" /* NEWLINE */);
-        parseActionsSection(page2);
-        return true;
-      }
-    }
-    if (token.type === "WHEN" /* WHEN */) {
-      advance();
-      if (current().type === "ACCESSED" /* ACCESSED */) {
-        advance();
-        skip("COLON" /* COLON */);
-        page2.onAccess = collectUntilNewline();
-        return true;
-      }
-    }
-    return false;
-  }
-  function parseDisplaysSection(page2) {
-    if (current().type !== "INDENT" /* INDENT */) {
-      return;
-    }
-    advance();
-    while (!isAtEnd() && current().type !== "DEDENT" /* DEDENT */) {
-      skip("NEWLINE" /* NEWLINE */);
-      if (current().type === "DEDENT" /* DEDENT */) break;
-      const section = parseSectionLine();
-      if (section) {
-        page2.sections.push(section);
-      }
-      skip("NEWLINE" /* NEWLINE */);
-    }
-    if (current().type === "DEDENT" /* DEDENT */) {
-      advance();
-    }
-  }
-  function parseSectionLine() {
-    if (current().type === "DASH" /* DASH */) {
-      advance();
-    }
-    const description = collectUntilNewline();
-    if (!description) {
-      return null;
-    }
-    return {
-      type: "page_section",
-      description
-    };
-  }
-  function parseActionsSection(page2) {
-    if (current().type !== "INDENT" /* INDENT */) {
-      return;
-    }
-    advance();
-    while (!isAtEnd() && current().type !== "DEDENT" /* DEDENT */) {
-      skip("NEWLINE" /* NEWLINE */);
-      if (current().type === "DEDENT" /* DEDENT */) break;
-      const action = parseActionLine();
-      if (action) {
-        page2.actions.push(action);
-      }
-      skip("NEWLINE" /* NEWLINE */);
-    }
-    if (current().type === "DEDENT" /* DEDENT */) {
-      advance();
-    }
-  }
-  function parseActionLine() {
-    if (current().type === "DASH" /* DASH */) {
-      advance();
-    }
-    const fullText = collectUntilNewline();
-    if (!fullText) {
-      return null;
-    }
-    const toIndex = fullText.toLowerCase().indexOf(" to ");
-    if (toIndex === -1) {
-      return {
-        type: "page_action",
-        trigger: fullText,
-        action: ""
-      };
-    }
-    return {
-      type: "page_action",
-      trigger: fullText.slice(0, toIndex).trim(),
-      action: fullText.slice(toIndex + 4).trim()
-    };
-  }
-  function collectUntilNewline() {
-    const parts = [];
-    while (!isAtEnd() && current().type !== "NEWLINE" /* NEWLINE */) {
-      parts.push(current().value);
-      advance();
-    }
-    return parts.join(" ").trim();
-  }
-}
-function formatPageToSchema(page) {
-  const viewType = inferViewTypeFromPageName(page.name);
-  const primaryEntity = page.primaryEntity;
-  return {
-    name: page.name,
-    path: page.url.startsWith("/") ? page.url : `/${page.url}`,
-    purpose: page.purpose || page.description,
-    sections: page.sections.map((section, index) => {
-      const pattern = inferPatternFromDescription(section.description);
-      const patternConfig = inferPatternConfigFromDescription(section.description, page.primaryEntity);
-      return {
-        id: `section-${index}`,
-        purpose: section.description,
-        order: index,
-        estimatedSize: "medium",
-        pattern: {
-          type: pattern,
-          ...patternConfig
-        }
-      };
-    }),
-    traits: [],
-    primaryEntity,
-    viewType,
-    isInitial: page.url === "/" || page.url === "/dashboard"
-  };
-}
-function inferViewTypeFromPageName(name) {
-  const lower = name.toLowerCase();
-  if (lower.includes("list") || lower.includes("index")) {
-    return "list";
-  }
-  if (lower.includes("detail") || lower.includes("view")) {
-    return "detail";
-  }
-  if (lower.includes("create") || lower.includes("new")) {
-    return "create";
-  }
-  if (lower.includes("edit")) {
-    return "edit";
-  }
-  if (lower.includes("dashboard")) {
-    return "dashboard";
-  }
-  return "list";
-}
-function inferPatternConfigFromDescription(description, primaryEntity) {
-  const lower = description.toLowerCase();
-  const entityName = primaryEntity || "Item";
-  if (lower.includes("header") || lower.includes("title")) {
-    const titleMatch = description.match(/title\s*["']?([^"']+)["']?/i) || description.match(/["']([^"']+)["']/);
-    return {
-      title: titleMatch ? titleMatch[1] : "Page Title"
-    };
-  }
-  if (lower.includes("list") || lower.includes("table")) {
-    return {
-      entity: entityName,
-      fieldNames: ["id", "name", "createdAt"]
-    };
-  }
-  if (lower.includes("detail")) {
-    return {
-      entity: entityName,
-      fieldNames: ["id", "name", "description", "createdAt"]
-    };
-  }
-  if (lower.includes("form")) {
-    return {
-      entity: entityName,
-      fields: [
-        { field: "name", label: "Name", type: "text", required: true },
-        { field: "description", label: "Description", type: "textarea" }
-      ]
-    };
-  }
-  if (lower.includes("stats") || lower.includes("statistics") || lower.includes("summary") || lower.includes("overview")) {
-    return {
-      entity: entityName,
-      fieldNames: ["id", "name", "value"]
-    };
-  }
-  return {
-    entity: entityName,
-    fieldNames: ["id", "name", "createdAt"]
-  };
-}
-function toPascalCase(text) {
-  if (/^[A-Z][a-zA-Z]*$/.test(text)) {
-    return text;
-  }
-  if (text.includes(" ")) {
-    return text.split(" ").map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
-  }
-  return text.charAt(0).toUpperCase() + text.slice(1);
-}
-function toKebabCase2(text) {
-  return text.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/\s+/g, "-").toLowerCase();
-}
-function inferPatternFromDescription(description) {
-  const lower = description.toLowerCase();
-  if (lower.includes("header")) {
-    return "page-header";
-  }
-  if (lower.includes("list") || lower.includes("table")) {
-    return "entity-list";
-  }
-  if (lower.includes("statistics") || lower.includes("stats") || lower.includes("summary") || lower.includes("overview")) {
-    return "entity-list";
-  }
-  if (lower.includes("form") || lower.includes("input") || lower.includes("edit")) {
-    return "form-section";
-  }
-  if (lower.includes("detail") || lower.includes("view")) {
-    return "entity-detail";
-  }
-  if (lower.includes("chart") || lower.includes("graph")) {
-    return "entity-list";
-  }
-  if (lower.includes("timeline") || lower.includes("history") || lower.includes("activity")) {
-    return "entity-list";
-  }
-  if (lower.includes("title")) {
-    return "page-header";
-  }
-  return "entity-list";
-}
-
-// src/orbitals/domain-language/parsers/guard-parser.ts
-function parseGuard(text, entityName) {
-  const ctx = { entityName, errors: [] };
-  let expression = text.trim();
-  if (expression.toLowerCase().startsWith("if ")) {
-    expression = expression.slice(3).trim();
-  }
-  const condition = parseCondition(expression, ctx);
-  if (!condition) {
-    return {
-      success: false,
-      errors: ctx.errors.length > 0 ? ctx.errors : [{
-        message: `Failed to parse guard expression: "${text}"`
-      }],
-      warnings: []
-    };
-  }
-  return {
-    success: true,
-    data: {
-      type: "guard",
-      condition,
-      raw: text
-    },
-    errors: [],
-    warnings: []
-  };
-}
-function parseCondition(text, ctx) {
-  text = text.trim();
-  const andMatch = splitAtTopLevel(text, " AND ");
-  if (andMatch) {
-    const left = parseCondition(andMatch.left, ctx);
-    const right = parseCondition(andMatch.right, ctx);
-    if (left && right) {
-      return {
-        type: "logical",
-        operator: "AND",
-        left,
-        right
-      };
-    }
-  }
-  const orMatch = splitAtTopLevel(text, " OR ");
-  if (orMatch) {
-    const left = parseCondition(orMatch.left, ctx);
-    const right = parseCondition(orMatch.right, ctx);
-    if (left && right) {
-      return {
-        type: "logical",
-        operator: "OR",
-        left,
-        right
-      };
-    }
-  }
-  return parseUserCheck(text) || parseFieldCheck(text, ctx) || parseComparison(text, ctx);
-}
-function parseUserCheck(text, ctx) {
-  const lowerText = text.toLowerCase();
-  const roleMatch = lowerText.match(/^user\s+is\s+(\w+)$/);
-  if (roleMatch) {
-    return {
-      type: "user_check",
-      check: "is_role",
-      role: roleMatch[1]
-    };
-  }
-  if (lowerText === "user owns this") {
-    return {
-      type: "user_check",
-      check: "owns_this",
-      ownerField: "ownerId"
-    };
-  }
-  return null;
-}
-function parseFieldCheck(text, ctx) {
-  text.toLowerCase();
-  const providedMatch = text.match(/^(.+?)\s+is\s+provided$/i);
-  if (providedMatch) {
-    const field = parseFieldReference(providedMatch[1], ctx);
-    if (field) {
-      return {
-        type: "field_check",
-        field,
-        check: "provided"
-      };
-    }
-  }
-  const emptyMatch = text.match(/^(.+?)\s+is\s+empty$/i);
-  if (emptyMatch) {
-    const field = parseFieldReference(emptyMatch[1], ctx);
-    if (field) {
-      return {
-        type: "field_check",
-        field,
-        check: "empty"
-      };
-    }
-  }
-  const notEqualsMatch = text.match(/^(.+?)\s+is\s+not\s+(.+)$/i);
-  if (notEqualsMatch) {
-    return null;
-  }
-  const equalsMatch = text.match(/^(.+?)\s+is\s+(.+)$/i);
-  if (equalsMatch) {
-    const fieldName = equalsMatch[1].trim();
-    const value = equalsMatch[2].trim();
-    if (["provided", "empty", "not"].includes(value.toLowerCase())) {
-      return null;
-    }
-    const field = parseFieldReference(fieldName, ctx);
-    if (field) {
-      return {
-        type: "field_check",
-        field,
-        check: "equals",
-        value: parseValue2(value)
-      };
-    }
-  }
-  return null;
-}
-function parseComparison(text, ctx) {
-  const operators = [
-    { pattern: /^(.+?)\s*>=\s*(.+)$/, operator: ">=" },
-    { pattern: /^(.+?)\s*<=\s*(.+)$/, operator: "<=" },
-    { pattern: /^(.+?)\s*!=\s*(.+)$/, operator: "!=" },
-    { pattern: /^(.+?)\s*==\s*(.+)$/, operator: "==" },
-    { pattern: /^(.+?)\s*>\s*(.+)$/, operator: ">" },
-    { pattern: /^(.+?)\s*<\s*(.+)$/, operator: "<" }
-  ];
-  const isNotMatch = text.match(/^(.+?)\s+is\s+not\s+(.+)$/i);
-  if (isNotMatch) {
-    const field = parseFieldReference(isNotMatch[1], ctx);
-    if (field) {
-      return {
-        type: "comparison",
-        field,
-        operator: "!=",
-        value: parseValue2(isNotMatch[2])
-      };
-    }
-  }
-  for (const { pattern, operator } of operators) {
-    const match = text.match(pattern);
-    if (match) {
-      const field = parseFieldReference(match[1], ctx);
-      if (field) {
-        return {
-          type: "comparison",
-          field,
-          operator,
-          value: parseValue2(match[2])
-        };
-      }
-    }
-  }
-  return null;
-}
-function parseFieldReference(text, ctx) {
-  text = text.trim();
-  const dotMatch = text.match(/^(\w+)\.(\w+)$/);
-  if (dotMatch) {
-    return {
-      type: "field_reference",
-      entityName: dotMatch[1],
-      fieldName: dotMatch[2]
-    };
-  }
-  const fieldName = toCamelCase2(text);
-  return {
-    type: "field_reference",
-    entityName: ctx.entityName,
-    fieldName
-  };
-}
-function parseValue2(text) {
-  text = text.trim();
-  if (text.startsWith('"') && text.endsWith('"') || text.startsWith("'") && text.endsWith("'")) {
-    return text.slice(1, -1);
-  }
-  if (text.toLowerCase() === "true") return true;
-  if (text.toLowerCase() === "false") return false;
-  const num = parseFloat(text);
-  if (!isNaN(num)) return num;
-  return text;
-}
-function toCamelCase2(text) {
-  return text.toLowerCase().split(/\s+/).map(
-    (word, index) => index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)
-  ).join("");
-}
-function splitAtTopLevel(text, separator) {
-  const separatorLower = separator.toLowerCase();
-  const textLower = text.toLowerCase();
-  let depth = 0;
-  for (let i = 0; i <= textLower.length - separatorLower.length; i++) {
-    const char = text[i];
-    if (char === "(") depth++;
-    else if (char === ")") depth--;
-    else if (depth === 0 && textLower.slice(i, i + separatorLower.length) === separatorLower) {
-      return {
-        left: text.slice(0, i),
-        right: text.slice(i + separator.length)
-      };
-    }
-  }
-  return null;
-}
-function isKnownPattern(pattern) {
-  return getPatternDefinition(pattern) !== null;
-}
-function parseDomainGuard(text, entityName) {
-  let expr = text.trim();
-  if (expr.toLowerCase().startsWith("if ")) {
-    expr = expr.slice(3).trim();
-  }
-  return parseExpression(expr);
-}
-function parseDomainEffect(text, entityName) {
-  let expr = text.trim();
-  if (expr.toLowerCase().startsWith("then ")) {
-    expr = expr.slice(5).trim();
-  }
-  return parseEffect(expr);
-}
-function isInlineSExpr(text) {
-  const trimmed = text.trim();
-  return trimmed.startsWith("[") || trimmed.startsWith("{") || trimmed.startsWith("(");
-}
-function parseInlineSExpr(text) {
-  const trimmed = text.trim();
-  if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
-    try {
-      return JSON.parse(trimmed);
-    } catch {
-      return parseRelaxedJson(trimmed);
-    }
-  }
-  if (trimmed.startsWith("(")) {
-    return parseLispSExpr(trimmed);
-  }
-  throw new Error(`Invalid inline S-Expression: ${text}`);
-}
-function parseRelaxedJson(text) {
-  let normalized = text;
-  normalized = normalized.replace(/'([^'\\]*(?:\\.[^'\\]*)*)'/g, '"$1"');
-  normalized = normalized.replace(/(\{|,)\s*(\w+)\s*:/g, '$1"$2":');
-  try {
-    return JSON.parse(normalized);
-  } catch (e) {
-    throw new Error(`Failed to parse relaxed JSON: ${text}`);
-  }
-}
-function parseLispSExpr(text) {
-  const trimmed = text.trim();
-  if (!trimmed.startsWith("(") || !trimmed.endsWith(")")) {
-    throw new Error(`Invalid Lisp S-Expression: ${text}`);
-  }
-  const inner = trimmed.slice(1, -1).trim();
-  const tokens = tokenizeLisp(inner);
-  if (tokens.length === 0) {
-    return [];
-  }
-  return tokens.map(parseLispToken);
-}
-function tokenizeLisp(text) {
-  const tokens = [];
-  let current = "";
-  let depth = 0;
-  let inString = false;
-  let stringChar = "";
-  for (let i = 0; i < text.length; i++) {
-    const char = text[i];
-    if (inString) {
-      current += char;
-      if (char === stringChar && text[i - 1] !== "\\") {
-        inString = false;
-      }
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      inString = true;
-      stringChar = char;
-      current += char;
-      continue;
-    }
-    if (char === "(" || char === "[" || char === "{") {
-      depth++;
-      current += char;
-      continue;
-    }
-    if (char === ")" || char === "]" || char === "}") {
-      depth--;
-      current += char;
-      continue;
-    }
-    if (char === " " || char === "	" || char === "\n") {
-      if (depth === 0 && current.trim()) {
-        tokens.push(current.trim());
-        current = "";
-      } else if (depth > 0) {
-        current += char;
-      }
-      continue;
-    }
-    current += char;
-  }
-  if (current.trim()) {
-    tokens.push(current.trim());
-  }
-  return tokens;
-}
-function parseLispToken(token) {
-  const trimmed = token.trim();
-  if (trimmed.startsWith("(")) {
-    return parseLispSExpr(trimmed);
-  }
-  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-    return parseRelaxedJson(trimmed);
-  }
-  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
-    return trimmed.slice(1, -1);
-  }
-  if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
-    return parseFloat(trimmed);
-  }
-  if (trimmed === "true") return true;
-  if (trimmed === "false") return false;
-  if (trimmed === "null") return null;
-  if (trimmed.startsWith("@")) {
-    return trimmed;
-  }
-  return trimmed;
-}
-function parseExpression(text, ctx) {
-  text = text.trim();
-  if (isInlineSExpr(text)) {
-    return parseInlineSExpr(text);
-  }
-  const andMatch = splitAtTopLevel2(text, " and ");
-  if (andMatch) {
-    const left = parseExpression(andMatch.left);
-    const right = parseExpression(andMatch.right);
-    return ["and", left, right];
-  }
-  const orMatch = splitAtTopLevel2(text, " or ");
-  if (orMatch) {
-    const left = parseExpression(orMatch.left);
-    const right = parseExpression(orMatch.right);
-    return ["or", left, right];
-  }
-  if (text.toLowerCase().startsWith("not ")) {
-    const inner = parseExpression(text.slice(4).trim());
-    return ["not", inner];
-  }
-  if (text.startsWith("(") && text.endsWith(")")) {
-    return parseExpression(text.slice(1, -1));
-  }
-  return parseComparison2(text);
-}
-function parseComparison2(text, ctx) {
-  const atLeastMatch = text.match(/^(.+?)\s+is\s+at\s+least\s+(.+)$/i);
-  if (atLeastMatch) {
-    const field = parseFieldRef(atLeastMatch[1]);
-    const value = parseValue3(atLeastMatch[2]);
-    return [">=", field, value];
-  }
-  const atMostMatch = text.match(/^(.+?)\s+is\s+at\s+most\s+(.+)$/i);
-  if (atMostMatch) {
-    const field = parseFieldRef(atMostMatch[1]);
-    const value = parseValue3(atMostMatch[2]);
-    return ["<=", field, value];
-  }
-  const greaterThanMatch = text.match(/^(.+?)\s+is\s+greater\s+than\s+(.+)$/i);
-  if (greaterThanMatch) {
-    const field = parseFieldRef(greaterThanMatch[1]);
-    const value = parseValue3(greaterThanMatch[2]);
-    return [">", field, value];
-  }
-  const lessThanMatch = text.match(/^(.+?)\s+is\s+less\s+than\s+(.+)$/i);
-  if (lessThanMatch) {
-    const field = parseFieldRef(lessThanMatch[1]);
-    const value = parseValue3(lessThanMatch[2]);
-    return ["<", field, value];
-  }
-  const isNotMatch = text.match(/^(.+?)\s+is\s+not\s+(.+)$/i);
-  if (isNotMatch) {
-    const field = parseFieldRef(isNotMatch[1]);
-    const value = parseValue3(isNotMatch[2]);
-    return ["!=", field, value];
-  }
-  const isMatch = text.match(/^(.+?)\s+is\s+(.+)$/i);
-  if (isMatch) {
-    const field = parseFieldRef(isMatch[1]);
-    const value = parseValue3(isMatch[2]);
-    return ["=", field, value];
-  }
-  const opPatterns = [
-    { pattern: /^(.+?)\s*>=\s*(.+)$/, op: ">=" },
-    { pattern: /^(.+?)\s*<=\s*(.+)$/, op: "<=" },
-    { pattern: /^(.+?)\s*!=\s*(.+)$/, op: "!=" },
-    { pattern: /^(.+?)\s*==\s*(.+)$/, op: "=" },
-    { pattern: /^(.+?)\s*>\s*(.+)$/, op: ">" },
-    { pattern: /^(.+?)\s*<\s*(.+)$/, op: "<" }
-  ];
-  for (const { pattern, op } of opPatterns) {
-    const match = text.match(pattern);
-    if (match) {
-      const left = parseFieldRef(match[1]);
-      const right = parseValue3(match[2]);
-      return [op, left, right];
-    }
-  }
-  return parseFieldRef(text);
-}
-function parseEffect(text, ctx) {
-  text = text.trim();
-  if (isInlineSExpr(text)) {
-    return parseInlineSExpr(text);
-  }
-  const updateMatch = text.match(/^update\s+(.+?)\s+to\s+(.+)$/i);
-  if (updateMatch) {
-    const field = parseFieldRef(updateMatch[1]);
-    const value = parseEffectValue(updateMatch[2]);
-    return ["set", field, value];
-  }
-  const emitWithMatch = text.match(/^emit\s+(\S+)\s+with\s+(.+)$/i);
-  if (emitWithMatch) {
-    const event = emitWithMatch[1];
-    const payload = parseEffectValue(emitWithMatch[2]);
-    return ["emit", event, payload];
-  }
-  const emitMatch = text.match(/^emit\s+(\S+)$/i);
-  if (emitMatch) {
-    return ["emit", emitMatch[1]];
-  }
-  const renderNullMatch = text.match(/^render\s+null\s+to\s+(\S+)$/i);
-  if (renderNullMatch) {
-    return ["render-ui", renderNullMatch[1], null];
-  }
-  const renderFullMatch = text.match(/^render\s+(\S+)\s+to\s+(\S+)\s+for\s+(\S+)\s+with\s+(.+)$/i);
-  if (renderFullMatch) {
-    const pattern = renderFullMatch[1];
-    const slot = renderFullMatch[2];
-    const entity = renderFullMatch[3];
-    const propsText = renderFullMatch[4];
-    const props = parseRenderProps(propsText);
-    validatePatternType(pattern);
-    return ["render-ui", slot, { type: pattern, entity, ...props }];
-  }
-  const renderEntityMatch = text.match(/^render\s+(\S+)\s+to\s+(\S+)\s+for\s+(\S+)$/i);
-  if (renderEntityMatch) {
-    const pattern = renderEntityMatch[1];
-    const slot = renderEntityMatch[2];
-    const entity = renderEntityMatch[3];
-    validatePatternType(pattern);
-    return ["render-ui", slot, { type: pattern, entity }];
-  }
-  const renderPropsMatch = text.match(/^render\s+(\S+)\s+to\s+(\S+)\s+with\s+(.+)$/i);
-  if (renderPropsMatch) {
-    const pattern = renderPropsMatch[1];
-    const slot = renderPropsMatch[2];
-    const propsText = renderPropsMatch[3];
-    const props = parseRenderProps(propsText);
-    validatePatternType(pattern);
-    return ["render-ui", slot, { type: pattern, ...props }];
-  }
-  const renderMatch = text.match(/^render\s+(\S+)\s+to\s+(\S+)$/i);
-  if (renderMatch) {
-    const pattern = renderMatch[1];
-    const slot = renderMatch[2];
-    validatePatternType(pattern);
-    return ["render-ui", slot, { type: pattern }];
-  }
-  const renderSlotMatch = text.match(/^render\s+to\s+(\S+)$/i);
-  if (renderSlotMatch) {
-    return ["render-ui", renderSlotMatch[1]];
-  }
-  const navWithMatch = text.match(/^navigate\s+to\s+(.+?)\s+with\s+(.+)$/i);
-  if (navWithMatch) {
-    const path6 = navWithMatch[1];
-    const params = parseEffectValue(navWithMatch[2]);
-    return ["navigate", path6, params];
-  }
-  const navMatch = text.match(/^navigate\s+to\s+(.+)$/i);
-  if (navMatch) {
-    return ["navigate", navMatch[1]];
-  }
-  const showNotifyMatch = text.match(/^show\s+(\w+)\s+notification\s+"(.+)"$/i);
-  if (showNotifyMatch) {
-    return ["notify", showNotifyMatch[2], showNotifyMatch[1]];
-  }
-  const notifyMatch = text.match(/^notify\s+"(.+)"$/i);
-  if (notifyMatch) {
-    return ["notify", notifyMatch[1]];
-  }
-  const persistWithMatch = text.match(/^persist\s+(\w+)\s+(.+)$/i);
-  if (persistWithMatch) {
-    const action = persistWithMatch[1];
-    const data = parseFieldRef(persistWithMatch[2]);
-    return ["persist", action, data];
-  }
-  const persistMatch = text.match(/^persist\s+(\w+)$/i);
-  if (persistMatch) {
-    return ["persist", persistMatch[1]];
-  }
-  const spawnWithMatch = text.match(/^spawn\s+(\S+)\s+with\s+(.+)$/i);
-  if (spawnWithMatch) {
-    const entityType = spawnWithMatch[1];
-    const props = parseEffectValue(spawnWithMatch[2]);
-    return ["spawn", entityType, props];
-  }
-  const spawnMatch = text.match(/^spawn\s+(\S+)$/i);
-  if (spawnMatch) {
-    return ["spawn", spawnMatch[1]];
-  }
-  const despawnIdMatch = text.match(/^despawn\s+(.+)$/i);
-  if (despawnIdMatch && despawnIdMatch[1] !== "this") {
-    return ["despawn", parseFieldRef(despawnIdMatch[1])];
-  }
-  if (text.toLowerCase() === "despawn" || text.toLowerCase() === "despawn this") {
-    return ["despawn"];
-  }
-  const callServiceMatch = text.match(/^call\s+(\w+)\.(\w+)$/i);
-  if (callServiceMatch) {
-    return ["call-service", callServiceMatch[1], callServiceMatch[2]];
-  }
-  const callMatch = text.match(/^call\s+(\S+)$/i);
-  if (callMatch) {
-    return ["call-service", callMatch[1]];
-  }
-  return text;
-}
-function parseFieldRef(text, ctx) {
-  text = text.trim();
-  if (text.startsWith("@")) {
-    return text;
-  }
-  if (text.toLowerCase() === "current state") {
-    return "@state";
-  }
-  if (text.toLowerCase() === "current time") {
-    return "@now";
-  }
-  if (text.toLowerCase() === "entity") {
-    return "@entity";
-  }
-  if (text.toLowerCase() === "payload") {
-    return "@payload";
-  }
-  if (text.toLowerCase().startsWith("incoming ")) {
-    const field = toCamelCase3(text.slice(9).trim());
-    return `@payload.${field}`;
-  }
-  const possessiveMatch = text.match(/^(\w+)'s\s+(.+)$/);
-  if (possessiveMatch) {
-    const entity = possessiveMatch[1];
-    const field = toCamelCase3(possessiveMatch[2]);
-    return `@${entity}.${field}`;
-  }
-  if (text.includes(".")) {
-    const parts = text.split(".");
-    if (parts[0] && /^[A-Z]/.test(parts[0])) {
-      return `@${text}`;
-    }
-    return `@entity.${text}`;
-  }
-  const fieldName = toCamelCase3(text);
-  return `@entity.${fieldName}`;
-}
-function parseValue3(text) {
-  text = text.trim();
-  if (text.startsWith('"') && text.endsWith('"') || text.startsWith("'") && text.endsWith("'")) {
-    return text.slice(1, -1);
-  }
-  if (text.toLowerCase() === "nothing" || text.toLowerCase() === "null") {
-    return null;
-  }
-  if (text.toLowerCase() === "true") return true;
-  if (text.toLowerCase() === "false") return false;
-  const num = parseFloat(text);
-  if (!isNaN(num) && text.match(/^-?\d+(\.\d+)?$/)) {
-    return num;
-  }
-  if (text.startsWith("@")) {
-    return text;
-  }
-  if (/^[a-zA-Z_]\w*$/.test(text)) {
-    return text;
-  }
-  return text;
-}
-function parseEffectValue(text, ctx) {
-  text = text.trim();
-  if (text.startsWith("{") && text.endsWith("}")) {
-    try {
-      const processed = text.replace(/@[\w.]+/g, (match) => `"${match}"`);
-      const obj = JSON.parse(processed);
-      return processBindingsInObject(obj);
-    } catch {
-      return text;
-    }
-  }
-  const arithmeticMatch = text.match(/^\((.+?)\s+(plus|minus|times|divided by)\s+(.+)\)$/i);
-  if (arithmeticMatch) {
-    const left = parseEffectValue(arithmeticMatch[1]);
-    const right = parseEffectValue(arithmeticMatch[3]);
-    const opMap = {
-      "plus": "+",
-      "minus": "-",
-      "times": "*",
-      "divided by": "/"
-    };
-    return [opMap[arithmeticMatch[2].toLowerCase()] || arithmeticMatch[2], left, right];
-  }
-  if (text.includes(".") || text.toLowerCase().startsWith("incoming ") || text.match(/^\w+'s\s+/) || /^[a-z]/.test(text)) {
-    return parseFieldRef(text);
-  }
-  return parseValue3(text);
-}
-function processBindingsInObject(obj) {
-  if (obj === null || obj === void 0) {
-    return null;
-  }
-  if (typeof obj === "string") {
-    if (obj.startsWith("@")) {
-      return obj;
-    }
-    return obj;
-  }
-  if (typeof obj !== "object") {
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return obj.map(processBindingsInObject);
-  }
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    result[key] = processBindingsInObject(value);
-  }
-  return result;
-}
-function splitAtTopLevel2(text, separator) {
-  const separatorLower = separator.toLowerCase();
-  const textLower = text.toLowerCase();
-  let depth = 0;
-  for (let i = 0; i <= textLower.length - separatorLower.length; i++) {
-    const char = text[i];
-    if (char === "(" || char === "[" || char === "{") depth++;
-    else if (char === ")" || char === "]" || char === "}") depth--;
-    else if (depth === 0 && textLower.slice(i, i + separatorLower.length) === separatorLower) {
-      return {
-        left: text.slice(0, i).trim(),
-        right: text.slice(i + separator.length).trim()
-      };
-    }
-  }
-  return null;
-}
-function toCamelCase3(text) {
-  const words = text.split(/\s+/);
-  if (words.length === 1) {
-    return words[0];
-  }
-  return words.map(
-    (word, index) => index === 0 ? word.toLowerCase() : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
-  ).join("");
-}
-function splitArrayItems(content) {
-  const items = [];
-  let current = "";
-  let inQuote = false;
-  let quoteChar = "";
-  for (let i = 0; i < content.length; i++) {
-    const char = content[i];
-    if ((char === "'" || char === '"') && (i === 0 || content[i - 1] !== "\\")) {
-      if (!inQuote) {
-        inQuote = true;
-        quoteChar = char;
-      } else if (char === quoteChar) {
-        inQuote = false;
-      }
-      current += char;
-    } else if (char === "," && !inQuote) {
-      if (current.trim()) {
-        items.push(current.trim());
-      }
-      current = "";
-    } else {
-      current += char;
-    }
-  }
-  if (current.trim()) {
-    items.push(current.trim());
-  }
-  return items;
-}
-function unquote(value) {
-  const trimmed = value.trim();
-  if (trimmed.startsWith("'") && trimmed.endsWith("'") || trimmed.startsWith('"') && trimmed.endsWith('"')) {
-    return trimmed.slice(1, -1);
-  }
-  return trimmed;
-}
-function parseArrayItem(item) {
-  const trimmed = item.trim();
-  const tabMatch = trimmed.match(/^(\w+):\s*['"]([^'"]+)['"]\s*->\s*(\w+)$/);
-  if (tabMatch) {
-    return { id: tabMatch[1], label: tabMatch[2], event: tabMatch[3] };
-  }
-  const actionVariantMatch = trimmed.match(/^([^->]+)\s*->\s*(\w+):(\w+)$/);
-  if (actionVariantMatch) {
-    return {
-      label: actionVariantMatch[1].trim(),
-      event: actionVariantMatch[2],
-      variant: actionVariantMatch[3]
-    };
-  }
-  const actionMatch = trimmed.match(/^(['"]?)([^'"->]+)\1\s*->\s*(\w+)$/);
-  if (actionMatch) {
-    return { label: actionMatch[2].trim(), event: actionMatch[3] };
-  }
-  const cellSpanMatch = trimmed.match(/^(\w+)\s*@\s*(\d+)x(\d+)$/);
-  if (cellSpanMatch) {
-    return {
-      section: cellSpanMatch[1],
-      colSpan: parseInt(cellSpanMatch[2], 10),
-      rowSpan: parseInt(cellSpanMatch[3], 10)
-    };
-  }
-  const cellMatch = trimmed.match(/^(\w+)\s*@\s*(\d+)$/);
-  if (cellMatch) {
-    return {
-      section: cellMatch[1],
-      colSpan: parseInt(cellMatch[2], 10)
-    };
-  }
-  const asMatch = trimmed.match(/^(\w+)\s+as\s+['"]([^'"]+)['"]$/);
-  if (asMatch) {
-    return { field: asMatch[1], label: asMatch[2] };
-  }
-  return unquote(trimmed);
-}
-function parseArrayProp(content) {
-  const items = splitArrayItems(content);
-  return items.map(parseArrayItem);
-}
-function hasComplexSyntax(content) {
-  return /\s+as\s+['"]/.test(content) || // "as" pattern
-  /->\s*\w+/.test(content) || // "->" pattern
-  /\w+\s*@\s*\d+/.test(content);
-}
-function parseRenderProps(text) {
-  const props = {};
-  const propsRegex = /(\w+)\s+(?:'([^']+)'|"([^"]+)"|\[([^\]]+)\]|(\S+))/g;
-  let match;
-  while ((match = propsRegex.exec(text)) !== null) {
-    const key = match[1];
-    const singleQuoted = match[2];
-    const doubleQuoted = match[3];
-    const arrayContent = match[4];
-    const bareValue = match[5];
-    if (singleQuoted !== void 0) {
-      props[key] = singleQuoted;
-    } else if (doubleQuoted !== void 0) {
-      props[key] = doubleQuoted;
-    } else if (arrayContent !== void 0) {
-      if (hasComplexSyntax(arrayContent)) {
-        props[key] = parseArrayProp(arrayContent);
-      } else {
-        props[key] = arrayContent.split(/\s*,\s*/).map((s) => s.trim());
-      }
-    } else if (bareValue !== void 0) {
-      if (bareValue === "true") props[key] = true;
-      else if (bareValue === "false") props[key] = false;
-      else if (/^\d+(\.\d+)?$/.test(bareValue)) props[key] = parseFloat(bareValue);
-      else props[key] = bareValue;
-    }
-  }
-  return props;
-}
-function validatePatternType(pattern) {
-  if (!isKnownPattern(pattern)) ;
-}
-
-// src/orbitals/domain-language/parsers/behavior-parser.ts
-function parseBehavior(text, entityName) {
-  const ctx = { entityName, errors: [], warnings: [] };
-  const lexer = new Lexer(text);
-  const tokens = lexer.tokenize();
-  let pos = 0;
-  const current = () => tokens[pos] || { type: "EOF" /* EOF */, value: "", line: 0, column: 0, offset: 0 };
-  const advance = () => tokens[pos++];
-  const isAtEnd = () => current().type === "EOF" /* EOF */;
-  const skip = (type) => {
-    while (current().type === type) advance();
-  };
-  skip("NEWLINE" /* NEWLINE */);
-  const behaviorName = parseBehaviorName();
-  if (!behaviorName) {
-    return {
-      success: false,
-      errors: ctx.errors.length > 0 ? ctx.errors : [{
-        message: "Expected behavior name at start of definition"
-      }],
-      warnings: []
-    };
-  }
-  const behavior = {
-    type: "behavior",
-    name: behaviorName,
-    entityName,
-    states: [],
-    initialState: "",
-    transitions: [],
-    ticks: [],
-    rules: []
-  };
-  skip("NEWLINE" /* NEWLINE */);
-  while (!isAtEnd()) {
-    skip("NEWLINE" /* NEWLINE */);
-    if (isAtEnd()) break;
-    const parsed = parseBehaviorSection(behavior);
-    if (!parsed) {
-      advance();
-    }
-  }
-  if (!behavior.initialState && behavior.states.length > 0) {
-    behavior.initialState = behavior.states[0];
-  }
-  return {
-    success: true,
-    data: behavior,
-    errors: ctx.errors,
-    warnings: ctx.warnings
-  };
-  function parseBehaviorName() {
-    const nameParts = [];
-    while (!isAtEnd() && current().type !== "NEWLINE" /* NEWLINE */) {
-      if (current().type === "IDENTIFIER" /* IDENTIFIER */ && current().value.toLowerCase() === "entity") {
-        advance();
-        if (current().type === "COLON" /* COLON */) {
-          advance();
-          if (current().type === "IDENTIFIER" /* IDENTIFIER */) {
-            ctx.entityName = current().value;
-            advance();
-          }
-        }
-        continue;
-      }
-      if (current().type === "LPAREN" /* LPAREN */ || current().type === "RPAREN" /* RPAREN */) {
-        advance();
-        continue;
-      }
-      if (current().type === "IDENTIFIER" /* IDENTIFIER */ || current().type === "LIFECYCLE" /* LIFECYCLE */ || current().type === "AUTO" /* AUTO */) {
-        nameParts.push(current().value);
-      }
-      advance();
-    }
-    if (nameParts.length === 0) {
-      return null;
-    }
-    return nameParts.join(" ");
-  }
-  function parseBehaviorSection(behavior2) {
-    const token = current();
-    if (token.type === "IDENTIFIER" /* IDENTIFIER */ && token.value.toLowerCase() === "entity") {
-      advance();
-      skip("COLON" /* COLON */);
-      if (current().type === "IDENTIFIER" /* IDENTIFIER */) {
-        ctx.entityName = current().value;
-        behavior2.entityName = current().value;
-        advance();
-      }
-      return true;
-    }
-    if (token.type === "STATES" /* STATES */) {
-      advance();
-      skip("COLON" /* COLON */);
-      parseStatesLine(behavior2);
-      return true;
-    }
-    if (token.type === "INITIAL" /* INITIAL */) {
-      advance();
-      skip("COLON" /* COLON */);
-      if (current().type === "IDENTIFIER" /* IDENTIFIER */) {
-        behavior2.initialState = current().value;
-        advance();
-      }
-      return true;
-    }
-    if (token.type === "TRANSITIONS" /* TRANSITIONS */) {
-      advance();
-      skip("COLON" /* COLON */);
-      skip("NEWLINE" /* NEWLINE */);
-      parseTransitionsSection(behavior2);
-      return true;
-    }
-    if (token.type === "RULES" /* RULES */) {
-      advance();
-      skip("COLON" /* COLON */);
-      skip("NEWLINE" /* NEWLINE */);
-      parseRulesSection(behavior2);
-      return true;
-    }
-    if (token.type === "EVERY" /* EVERY */) {
-      advance();
-      parseTick(behavior2);
-      return true;
-    }
-    if (token.type === "LIFECYCLE" /* LIFECYCLE */) {
-      advance();
-      return true;
-    }
-    return false;
-  }
-  function parseStatesLine(behavior2) {
-    const states = [];
-    while (!isAtEnd() && current().type !== "NEWLINE" /* NEWLINE */) {
-      if (current().type === "IDENTIFIER" /* IDENTIFIER */) {
-        states.push(current().value);
-      }
-      advance();
-    }
-    behavior2.states = states;
-  }
-  function parseTransitionsSection(behavior2) {
-    if (current().type === "INDENT" /* INDENT */) {
-      advance();
-      while (!isAtEnd() && current().type !== "DEDENT" /* DEDENT */) {
-        skip("NEWLINE" /* NEWLINE */);
-        if (current().type === "DEDENT" /* DEDENT */) break;
-        if (current().type === "DASH" /* DASH */ || current().type === "FROM" /* FROM */) {
-          const transition = parseTransitionLine();
-          if (transition) {
-            behavior2.transitions.push(transition);
-          }
-        } else {
-          while (!isAtEnd() && current().type !== "NEWLINE" /* NEWLINE */ && current().type !== "DEDENT" /* DEDENT */) {
-            advance();
-          }
-        }
-      }
-      if (current().type === "DEDENT" /* DEDENT */) {
-        advance();
-      }
-    } else {
-      while (!isAtEnd() && current().type !== "RULES" /* RULES */ && current().type !== "EVERY" /* EVERY */) {
-        skip("NEWLINE" /* NEWLINE */);
-        if (current().type === "RULES" /* RULES */ || current().type === "EVERY" /* EVERY */ || isAtEnd()) break;
-        if (current().type === "DASH" /* DASH */ || current().type === "FROM" /* FROM */) {
-          const transition = parseTransitionLine();
-          if (transition) {
-            behavior2.transitions.push(transition);
-          }
-        } else {
-          advance();
-        }
-      }
-    }
-  }
-  function parseTransitionLine() {
-    if (current().type === "DASH" /* DASH */) {
-      advance();
-    }
-    if (current().type !== "FROM" /* FROM */) {
-      return null;
-    }
-    advance();
-    let fromState = "";
-    if (current().type === "IDENTIFIER" /* IDENTIFIER */) {
-      fromState = current().value;
-      advance();
-    }
-    if (fromState.toLowerCase() === "any") {
-      fromState = "*";
-    }
-    if (current().type !== "TO" /* TO */) {
-      ctx.errors.push({ message: `Expected "to" in transition from "${fromState}"` });
-      return null;
-    }
-    advance();
-    let toState = "";
-    if (current().type === "IDENTIFIER" /* IDENTIFIER */) {
-      toState = current().value;
-      advance();
-    }
-    let event = "";
-    if (current().type === "WHEN" /* WHEN */) {
-      advance();
-      if (current().type === "IDENTIFIER" /* IDENTIFIER */) {
-        event = current().value;
-        advance();
-      }
-    }
-    const transition = {
-      type: "transition",
-      fromState,
-      toState,
-      event: event.toUpperCase(),
-      guards: [],
-      effects: []
-    };
-    skip("NEWLINE" /* NEWLINE */);
-    if (current().type === "INDENT" /* INDENT */) {
-      advance();
-      while (!isAtEnd() && current().type !== "DEDENT" /* DEDENT */) {
-        skip("NEWLINE" /* NEWLINE */);
-        if (current().type === "DEDENT" /* DEDENT */) break;
-        if (current().type === "IF" /* IF */) {
-          const guardText = collectLine();
-          const guardResult = parseGuard(guardText, entityName);
-          if (guardResult.success && guardResult.data) {
-            transition.guards.push(guardResult.data);
-          }
-          continue;
-        }
-        if (current().type === "THEN" /* THEN */) {
-          advance();
-          const effectText = collectUntilNewline();
-          const effect = parseEffectText(effectText);
-          if (effect) {
-            transition.effects.push(effect);
-          }
-          continue;
-        }
-        if (current().type !== "NEWLINE" /* NEWLINE */ && current().type !== "DEDENT" /* DEDENT */) {
-          advance();
-        }
-        skip("NEWLINE" /* NEWLINE */);
-      }
-      if (current().type === "DEDENT" /* DEDENT */) {
-        advance();
-      }
-    } else {
-      if (current().type === "IF" /* IF */) {
-        const guardText = collectLine();
-        const guardResult = parseGuard(guardText, entityName);
-        if (guardResult.success && guardResult.data) {
-          transition.guards.push(guardResult.data);
-        }
-      }
-    }
-    return transition;
-  }
-  function parseRulesSection(behavior2) {
-    if (current().type === "INDENT" /* INDENT */) {
-      advance();
-      while (!isAtEnd() && current().type !== "DEDENT" /* DEDENT */) {
-        skip("NEWLINE" /* NEWLINE */);
-        if (current().type === "DEDENT" /* DEDENT */) break;
-        if (current().type === "DASH" /* DASH */) {
-          advance();
-        }
-        const rule = collectUntilNewline();
-        if (rule) {
-          behavior2.rules.push(rule);
-        }
-        skip("NEWLINE" /* NEWLINE */);
-      }
-      if (current().type === "DEDENT" /* DEDENT */) {
-        advance();
-      }
-    }
-  }
-  function parseTick(behavior2) {
-    const intervalParts = [];
-    while (!isAtEnd() && current().type !== "COLON" /* COLON */ && current().type !== "NEWLINE" /* NEWLINE */) {
-      intervalParts.push(current().value);
-      advance();
-    }
-    const interval = intervalParts.join(" ");
-    skip("COLON" /* COLON */);
-    skip("NEWLINE" /* NEWLINE */);
-    const tick = {
-      type: "tick",
-      name: `tick_${interval.replace(/\s+/g, "_").toLowerCase()}`,
-      interval,
-      intervalMs: parseInterval(interval),
-      effects: []
-    };
-    if (current().type === "INDENT" /* INDENT */) {
-      advance();
-      while (!isAtEnd() && current().type !== "DEDENT" /* DEDENT */) {
-        skip("NEWLINE" /* NEWLINE */);
-        if (current().type === "DEDENT" /* DEDENT */) break;
-        if (current().type === "IF" /* IF */) {
-          const guardText = collectLine();
-          const guardResult = parseGuard(guardText, entityName);
-          if (guardResult.success && guardResult.data) {
-            tick.guard = guardResult.data;
-          }
-        }
-        if (current().type === "THEN" /* THEN */) {
-          advance();
-        }
-        if (current().type === "DASH" /* DASH */) {
-          advance();
-        }
-        const effectText = collectUntilNewline();
-        if (effectText && current().type !== "IF" /* IF */) {
-          const effect = parseEffectText(effectText);
-          if (effect) {
-            tick.effects.push(effect);
-          }
-        }
-        skip("NEWLINE" /* NEWLINE */);
-      }
-      if (current().type === "DEDENT" /* DEDENT */) {
-        advance();
-      }
-    }
-    behavior2.ticks.push(tick);
-  }
-  function collectLine() {
-    return collectTokensSmartJoin();
-  }
-  function collectUntilNewline() {
-    return collectTokensSmartJoin();
-  }
-  function collectTokensSmartJoin() {
-    const parts = [];
-    while (!isAtEnd() && current().type !== "NEWLINE" /* NEWLINE */) {
-      parts.push({ value: current().value, type: current().type });
-      advance();
-    }
-    const startsWithBracket = parts.length > 0 && parts[0].type === "LBRACKET" /* LBRACKET */;
-    let result = "";
-    for (let i = 0; i < parts.length; i++) {
-      const part = parts[i];
-      const prev = parts[i - 1];
-      const noSpaceBefore = part.type === "DASH" /* DASH */ || part.type === "DOT" /* DOT */ || part.type === "COMMA" /* COMMA */ || part.type === "COLON" /* COLON */ || part.type === "RBRACKET" /* RBRACKET */ || part.type === "RPAREN" /* RPAREN */;
-      const prevNoSpaceAfter = prev && (prev.type === "DASH" /* DASH */ || prev.type === "DOT" /* DOT */ || prev.type === "LBRACKET" /* LBRACKET */ || prev.type === "LPAREN" /* LPAREN */);
-      if (i > 0 && !noSpaceBefore && !prevNoSpaceAfter) {
-        result += " ";
-      }
-      if (startsWithBracket && part.type === "STRING" /* STRING */) {
-        result += `"${part.value}"`;
-      } else {
-        result += part.value;
-      }
-    }
-    return result.trim();
-  }
-  function parseEffectText(text2) {
-    const trimmed = text2.trim();
-    const lower = trimmed.toLowerCase();
-    if (trimmed.startsWith("[")) {
-      try {
-        const parsed = JSON.parse(trimmed);
-        if (Array.isArray(parsed) && parsed.length > 0) {
-          const effectOp = String(parsed[0]);
-          return {
-            type: "effect",
-            effectType: effectOp,
-            description: trimmed,
-            config: { _rawSExpr: parsed }
-            // Store parsed S-expression
-          };
-        }
-      } catch {
-      }
-    }
-    const persistMatch = text2.match(/^persist\s+(\w+)(?:\s+(\w+))?$/i);
-    if (persistMatch) {
-      return {
-        type: "effect",
-        effectType: "persist",
-        description: text2,
-        config: {
-          dataAction: persistMatch[1].toLowerCase(),
-          entity: persistMatch[2] || void 0
-        }
-      };
-    }
-    const sendInAppMatch = text2.match(/^send_in_app\s+to\s+(.+?)\s+title\s+"([^"]+)"\s+message\s+"([^"]+)"(?:\s+type\s+(\w+))?$/i);
-    if (sendInAppMatch) {
-      return {
-        type: "effect",
-        effectType: "notify",
-        description: text2,
-        config: {
-          userId: sendInAppMatch[1],
-          title: sendInAppMatch[2],
-          message: sendInAppMatch[3],
-          type: sendInAppMatch[4] || "info"
-        }
-      };
-    }
-    const jsonMatch = text2.match(/^(\w+):(\{.+\})$/);
-    if (jsonMatch) {
-      try {
-        const config = JSON.parse(jsonMatch[2]);
-        return {
-          type: "effect",
-          effectType: jsonMatch[1],
-          description: text2,
-          config
-        };
-      } catch {
-      }
-    }
-    const notifyWithRecipientMatch = text2.match(/^notify\s+(\S+)\s+"([^"]+)"$/i);
-    if (notifyWithRecipientMatch) {
-      return {
-        type: "effect",
-        effectType: "notify",
-        description: text2,
-        config: {
-          recipient: notifyWithRecipientMatch[1],
-          message: notifyWithRecipientMatch[2]
-        }
-      };
-    }
-    if (lower.startsWith("notify")) {
-      const remaining = text2.slice(6).trim();
-      const quotedMatch = remaining.match(/^"([^"]+)"$/);
-      return {
-        type: "effect",
-        effectType: "notify",
-        description: text2,
-        config: {
-          message: quotedMatch ? quotedMatch[1] : remaining
-        }
-      };
-    }
-    const updateMatch = text2.match(/^update\s+(.+?)\s+to\s+(.+)$/i);
-    if (updateMatch) {
-      return {
-        type: "effect",
-        effectType: "set",
-        description: text2,
-        config: {
-          field: preserveTemplateVars(updateMatch[1]),
-          value: updateMatch[2]
-        }
-      };
-    }
-    const navMatch = text2.match(/^navigate\s+to\s+(.+)$/i);
-    if (navMatch) {
-      return {
-        type: "effect",
-        effectType: "navigate",
-        description: text2,
-        config: {
-          path: navMatch[1]
-        }
-      };
-    }
-    const emitMatch = text2.match(/^emit\s+(.+)$/i);
-    if (emitMatch) {
-      return {
-        type: "effect",
-        effectType: "emit",
-        description: text2,
-        config: {
-          eventKey: emitMatch[1].toUpperCase().replace(/\s+/g, "_")
-        }
-      };
-    }
-    const callMatch = text2.match(/^call\s+(.+)$/i);
-    if (callMatch) {
-      return {
-        type: "effect",
-        effectType: "call-service",
-        description: text2,
-        config: {
-          service: callMatch[1]
-        }
-      };
-    }
-    if (lower.startsWith("render ")) {
-      try {
-        const result = parseDomainEffect(text2);
-        if (Array.isArray(result) && result[0] === "render-ui") {
-          return {
-            type: "effect",
-            effectType: "render-ui",
-            description: text2,
-            config: {
-              slot: result[1],
-              pattern: result[2]
-            }
-          };
-        }
-      } catch {
-      }
-    }
-    ctx.warnings.push({
-      message: `Unknown effect syntax: "${text2}". Effect will be ignored. Use a valid effect format like "update X to Y", "emit EVENT", "navigate to /path", "notify 'message'", or "render pattern to slot".`
-    });
-    return null;
-  }
-  function parseInterval(text2) {
-    const lower = text2.toLowerCase();
-    const match = lower.match(/(\d+)\s*(second|minute|hour|day|week)s?/);
-    if (match) {
-      const value = parseInt(match[1], 10);
-      const unit = match[2];
-      switch (unit) {
-        case "second":
-          return value * 1e3;
-        case "minute":
-          return value * 60 * 1e3;
-        case "hour":
-          return value * 60 * 60 * 1e3;
-        case "day":
-          return value * 24 * 60 * 60 * 1e3;
-        case "week":
-          return value * 7 * 24 * 60 * 60 * 1e3;
-      }
-    }
-    return 60 * 60 * 1e3;
-  }
-}
-function formatBehaviorToSchema(behavior) {
-  const trait = {
-    // Just remove spaces, preserve the casing from the source
-    // Trust the LLM/author to use consistent PascalCase naming
-    name: behavior.name.replace(/\s+/g, ""),
-    description: behavior.name
-  };
-  if (behavior.states.length > 0) {
-    trait.stateMachine = {
-      states: behavior.states.map((state, index) => ({
-        name: state,
-        isInitial: state === behavior.initialState || index === 0 && !behavior.initialState
-      })),
-      events: extractEventsFromTransitions(behavior.transitions),
-      transitions: behavior.transitions.map((t) => {
-        const transition = {
-          from: t.fromState,
-          to: t.toState,
-          event: t.event
-        };
-        if (t.guards.length > 0) {
-          const guardExprs = t.guards.map((g) => {
-            if (g.raw) {
-              return parseDomainGuard(g.raw, behavior.entityName);
-            }
-            return parseDomainGuard(formatGuardToCondition(g), behavior.entityName);
-          });
-          transition.guard = guardExprs.length === 1 ? guardExprs[0] : ["and", ...guardExprs];
-        }
-        if (t.effects.length > 0) {
-          transition.effects = t.effects.map((e) => {
-            if (e.config && "_rawSExpr" in e.config && Array.isArray(e.config._rawSExpr)) {
-              return e.config._rawSExpr;
-            }
-            return parseDomainEffect(e.description, behavior.entityName);
-          });
-        }
-        return transition;
-      })
-    };
-  }
-  if (behavior.ticks.length > 0) {
-    trait.ticks = behavior.ticks.map((t) => ({
-      name: toPascalCase2(t.name.replace(/\s+/g, "")),
-      interval: t.intervalMs,
-      // Direct number in ms
-      guard: t.guard ? parseDomainGuard(t.guard.raw || formatGuardToCondition(t.guard), behavior.entityName) : void 0,
-      effects: t.effects.map((e) => {
-        if (e.config && "_rawSExpr" in e.config && Array.isArray(e.config._rawSExpr)) {
-          return e.config._rawSExpr;
-        }
-        return parseDomainEffect(e.description, behavior.entityName);
-      })
-    }));
-  }
-  return trait;
-}
-function toCamelCase4(text) {
-  return text.toLowerCase().split(/\s+/).map(
-    (word, index) => index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)
-  ).join("");
-}
-function toPascalCase2(text) {
-  if (!text.includes(" ")) {
-    return text.charAt(0).toUpperCase() + text.slice(1);
-  }
-  return text.split(/\s+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
-}
-function extractEventsFromTransitions(transitions) {
-  const events = /* @__PURE__ */ new Map();
-  for (const t of transitions) {
-    if (t.event && !events.has(t.event)) {
-      events.set(t.event, toTitleCase(t.event.replace(/_/g, " ")));
-    }
-  }
-  return Array.from(events.entries()).map(([key, name]) => ({ key, name }));
-}
-function toTitleCase(text) {
-  return text.toLowerCase().split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-}
-function formatGuardToCondition(guard) {
-  if (guard.raw) {
-    return guard.raw.replace(/^if\s+/i, "");
-  }
-  return "true";
-}
-function preserveTemplateVars(text) {
-  if (text.includes("{") && text.includes("}")) {
-    return text.replace(/\s*\.\s*/g, ".");
-  }
-  const cleanedText = text.replace(/\s*\.\s*/g, ".");
-  if (cleanedText.includes(".")) {
-    return cleanedText;
-  }
-  return toCamelCase4(text);
-}
-function getPageName(page) {
-  if (isPageReferenceString(page)) {
-    const parts = page.split(".");
-    return parts[parts.length - 1];
-  }
-  if (isPageReferenceObject(page)) {
-    const parts = page.ref.split(".");
-    return parts[parts.length - 1];
-  }
-  return page.name;
-}
-function convertDomainToSchema(domainText, baseSchema) {
-  const errors = [];
-  const warnings = [];
-  const mappings = [];
-  const schema = baseSchema ? {
-    ...baseSchema,
-    orbitals: [...baseSchema.orbitals || []]
-  } : {
-    name: "Application",
-    orbitals: []
-  };
-  const sections = splitDomainDocument(domainText);
-  const parsedEntities = [];
-  const parsedPages = [];
-  const parsedTraits = [];
-  for (const text of sections.entities) {
-    const result = parseEntity(text);
-    if (result.success && result.data) {
-      const entityRecord = formatEntityToSchema(result.data);
-      const entity = {
-        name: entityRecord.name,
-        fields: entityRecord.fields || [],
-        persistence: "persistent"
-      };
-      parsedEntities.push({
-        name: result.data.name,
-        entity,
-        text
-      });
-    } else {
-      errors.push(...result.errors);
-    }
-    warnings.push(...result.warnings);
-  }
-  for (const text of sections.pages) {
-    const result = parsePage(text);
-    if (result.success && result.data) {
-      const pageRecord = formatPageToSchema(result.data);
-      const page = {
-        name: pageRecord.name,
-        path: pageRecord.path || "/",
-        primaryEntity: pageRecord.primaryEntity
-      };
-      if (result.data.traitName) {
-        page.traits = [{
-          ref: result.data.traitName,
-          linkedEntity: result.data.primaryEntity
-        }];
-      }
-      const forEntity = result.data.primaryEntity || page.primaryEntity;
-      parsedPages.push({
-        name: result.data.name,
-        page,
-        forEntity,
-        text
-      });
-    } else {
-      errors.push(...result.errors);
-    }
-    warnings.push(...result.warnings);
-  }
-  for (const text of sections.behaviors) {
-    if (text.trim().toLowerCase().startsWith("every")) {
-      parseTickFromDomain(text);
-      continue;
-    }
-    const result = parseBehavior(text, "");
-    if (result.success && result.data) {
-      const traitRecord = formatBehaviorToSchema(result.data);
-      const trait = {
-        name: traitRecord.name,
-        stateMachine: traitRecord.stateMachine
-      };
-      const forEntity = result.data.entityName || void 0;
-      parsedTraits.push({
-        name: result.data.name,
-        trait,
-        forEntity,
-        text
-      });
-    } else {
-      errors.push(...result.errors);
-    }
-    warnings.push(...result.warnings);
-  }
-  console.log(`[DomainToSchema] Parsed: ${parsedEntities.length} entities, ${parsedPages.length} pages, ${parsedTraits.length} traits`);
-  if (parsedEntities.length > 0) {
-    console.log(`[DomainToSchema] Entities: ${parsedEntities.map((e) => e.name).join(", ")}`);
-  }
-  if (parsedTraits.length > 0) {
-    console.log(`[DomainToSchema] Traits: ${parsedTraits.map((t) => t.name).join(", ")}`);
-  }
-  const traitToEntityMap = /* @__PURE__ */ new Map();
-  for (const { page } of parsedPages) {
-    if (page.traits && page.primaryEntity) {
-      for (const traitRef of page.traits) {
-        if (traitRef.ref) {
-          const linkedEntity = traitRef.linkedEntity || page.primaryEntity;
-          if (linkedEntity) {
-            traitToEntityMap.set(traitRef.ref.toLowerCase(), linkedEntity);
-          }
-        }
-      }
-    }
-  }
-  if (traitToEntityMap.size > 0) {
-    console.log(`[DomainToSchema] Page trait references: ${Array.from(traitToEntityMap.entries()).map(([t, e]) => `${t}\u2192${e}`).join(", ")}`);
-  } else {
-    console.log(`[DomainToSchema] No page trait references found (pages may be missing primaryEntity or traits)`);
-  }
-  const orbitals = [];
-  for (let i = 0; i < parsedEntities.length; i++) {
-    const { name, entity, text } = parsedEntities[i];
-    const entityPages = parsedPages.filter((p) => p.forEntity === name || p.page.primaryEntity === name).map((p) => p.page);
-    const entityTraits = parsedTraits.filter((t) => {
-      const traitNameLower = t.name.toLowerCase();
-      if (t.forEntity === name) {
-        console.log(`[DomainToSchema] \u2713 Trait "${t.name}" \u2192 Entity "${name}" (explicit Entity: syntax)`);
-        return true;
-      }
-      const linkedEntity = traitToEntityMap.get(traitNameLower);
-      if (linkedEntity === name) {
-        console.log(`[DomainToSchema] \u2713 Trait "${t.name}" \u2192 Entity "${name}" (page trait reference)`);
-        return true;
-      }
-      return false;
-    }).map((t) => t.trait.name);
-    const orbital = {
-      name,
-      entity,
-      traits: entityTraits,
-      pages: entityPages
-    };
-    orbitals.push(orbital);
-    mappings.push({
-      sectionId: `entity_${name}`,
-      sectionType: "entity",
-      schemaPath: `orbitals[${i}].entity`,
-      domainText: text
-    });
-  }
-  for (const { name, forEntity, text } of parsedPages) {
-    const orbitalIndex = parsedEntities.findIndex((e) => e.name === forEntity);
-    const pageIndex = orbitalIndex >= 0 ? orbitals[orbitalIndex].pages.findIndex((p) => getPageName(p) === name) : -1;
-    mappings.push({
-      sectionId: `page_${name}`,
-      sectionType: "page",
-      schemaPath: orbitalIndex >= 0 && pageIndex >= 0 ? `orbitals[${orbitalIndex}].pages[${pageIndex}]` : `orphanedPages`,
-      domainText: text
-    });
-  }
-  for (const { name, forEntity, text } of parsedTraits) {
-    const orbitalIndex = parsedEntities.findIndex((e) => e.name === forEntity);
-    const traitIndex = orbitalIndex >= 0 ? orbitals[orbitalIndex].traits.findIndex((t) => getTraitName(t) === name) : -1;
-    mappings.push({
-      sectionId: `behavior_${name}`,
-      sectionType: "behavior",
-      schemaPath: orbitalIndex >= 0 && traitIndex >= 0 ? `orbitals[${orbitalIndex}].traits[${traitIndex}]` : `traits`,
-      domainText: text
-    });
-  }
-  const assignedTraitNames = /* @__PURE__ */ new Set();
-  for (const orbital of orbitals) {
-    for (const traitRef of orbital.traits) {
-      const traitName = getTraitName(traitRef);
-      assignedTraitNames.add(traitName.toLowerCase());
-    }
-  }
-  console.log(`[DomainToSchema] ${parsedTraits.length} traits parsed, ${assignedTraitNames.size} assigned to orbitals`);
-  for (const orbital of orbitals) {
-    if (orbital.traits.length > 0) {
-      console.log(`[DomainToSchema] Orbital ${orbital.name}: ${orbital.traits.length} traits - ${orbital.traits.join(", ")}`);
-    }
-  }
-  schema.orbitals = orbitals;
-  return {
-    success: errors.length === 0,
-    schema,
-    errors,
-    warnings,
-    mappings
-  };
-}
-function splitDomainDocument(text) {
-  const result = {
-    entities: [],
-    pages: [],
-    behaviors: []
-  };
-  const normalizedText = text.replace(/\r\n/g, "\n");
-  let currentSection = null;
-  let currentContent = [];
-  const lines = normalizedText.split("\n");
-  for (const line of lines) {
-    const trimmed = line.trim().toLowerCase();
-    if (trimmed === "# entities" || trimmed === "#entities") {
-      flushSection();
-      currentSection = "entities";
-      continue;
-    }
-    if (trimmed === "# pages" || trimmed === "#pages") {
-      flushSection();
-      currentSection = "pages";
-      continue;
-    }
-    if (trimmed === "# behaviors" || trimmed === "#behaviors" || trimmed === "# traits" || trimmed === "#traits") {
-      flushSection();
-      currentSection = "behaviors";
-      continue;
-    }
-    currentContent.push(line);
-  }
-  flushSection();
-  if (result.entities.length === 0 && result.pages.length === 0 && result.behaviors.length === 0) {
-    return autoDetectSections(normalizedText);
-  }
-  return result;
-  function flushSection() {
-    if (!currentSection || currentContent.length === 0) {
-      currentContent = [];
-      return;
-    }
-    const content = currentContent.join("\n").trim();
-    if (content) {
-      let items = content.split(/\n---\n/).map((s) => s.trim()).filter((s) => s);
-      if (currentSection === "entities") {
-        items = splitEntitiesByPattern(items);
-      } else if (currentSection === "pages") {
-        items = splitPagesByPattern(items);
-      } else if (currentSection === "behaviors") {
-        items = splitBehaviorsByPattern(items);
-      }
-      result[currentSection].push(...items);
-    }
-    currentContent = [];
-  }
-}
-function splitEntitiesByPattern(items) {
-  const result = [];
-  for (const item of items) {
-    const lines = item.split("\n");
-    let currentEntity = [];
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (/^an?\s+\w+\s+is\s/i.test(trimmed) && currentEntity.length > 0) {
-        result.push(currentEntity.join("\n").trim());
-        currentEntity = [line];
-      } else {
-        currentEntity.push(line);
-      }
-    }
-    if (currentEntity.length > 0) {
-      result.push(currentEntity.join("\n").trim());
-    }
-  }
-  return result.filter((s) => s);
-}
-function splitPagesByPattern(items) {
-  const result = [];
-  for (const item of items) {
-    const lines = item.split("\n");
-    let currentPage = [];
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (/^\w+(?:page)?\s+at\s+\//i.test(trimmed) && currentPage.length > 0) {
-        result.push(currentPage.join("\n").trim());
-        currentPage = [line];
-      } else {
-        currentPage.push(line);
-      }
-    }
-    if (currentPage.length > 0) {
-      result.push(currentPage.join("\n").trim());
-    }
-  }
-  return result.filter((s) => s);
-}
-function splitBehaviorsByPattern(items) {
-  const result = [];
-  for (const item of items) {
-    const lines = item.split("\n");
-    let currentBehavior = [];
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if ((/^\w+\s+behavior:?$/i.test(trimmed) || /^every\s+/i.test(trimmed)) && currentBehavior.length > 0) {
-        result.push(currentBehavior.join("\n").trim());
-        currentBehavior = [line];
-      } else {
-        currentBehavior.push(line);
-      }
-    }
-    if (currentBehavior.length > 0) {
-      result.push(currentBehavior.join("\n").trim());
-    }
-  }
-  return result.filter((s) => s);
-}
-function autoDetectSections(text) {
-  const result = {
-    entities: [],
-    pages: [],
-    behaviors: []
-  };
-  const sections = text.split(/\n---\n/).map((s) => s.trim()).filter((s) => s);
-  for (const section of sections) {
-    const firstLine = section.split("\n")[0].toLowerCase();
-    if (firstLine.match(/^an?\s+\w+\s+is/)) {
-      result.entities.push(section);
-    } else if (firstLine.match(/^the\s+\w+.*shows/)) {
-      result.pages.push(section);
-    } else if (firstLine.match(/^every\s+/)) {
-      result.behaviors.push(section);
-    } else if (section.toLowerCase().includes("states:") || section.toLowerCase().includes("transitions:")) {
-      result.behaviors.push(section);
-    } else if (section.toLowerCase().includes("it has:")) {
-      result.entities.push(section);
-    } else if (section.toLowerCase().includes("it displays:")) {
-      result.pages.push(section);
-    } else {
-      result.entities.push(section);
-    }
-  }
-  return result;
-}
-function parseTickFromDomain(text) {
-  const lines = text.trim().split("\n");
-  if (lines.length === 0) return null;
-  const firstLine = lines[0].trim();
-  const intervalMatch = firstLine.match(/^every\s+(.+?):?$/i);
-  if (!intervalMatch) return null;
-  const intervalStr = intervalMatch[1];
-  const intervalMs = parseIntervalToMs(intervalStr);
-  const tickName = intervalStr.split(/\s+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
-  const tick = {
-    name: tickName,
-    interval: intervalMs,
-    effects: []
-    // S-Expression arrays
-  };
-  for (let i = 1; i < lines.length; i++) {
-    const line = lines[i].trim();
-    if (line.toLowerCase().startsWith("if ")) {
-      tick.guard = line.slice(3).trim();
-    } else if (line.startsWith("-")) {
-      const effectText = line.slice(1).trim();
-      const effect = parseEffectFromText(effectText);
-      if (effect) {
-        tick.effects.push(effect);
-      }
-    }
-  }
-  return tick;
-}
-function parseIntervalToMs(text) {
-  const lower = text.toLowerCase();
-  const match = lower.match(/(\d+)\s*(second|minute|hour|day|week)s?/);
-  if (match) {
-    const value = parseInt(match[1], 10);
-    const unit = match[2];
-    switch (unit) {
-      case "second":
-        return value * 1e3;
-      case "minute":
-        return value * 60 * 1e3;
-      case "hour":
-        return value * 60 * 60 * 1e3;
-      case "day":
-        return value * 24 * 60 * 60 * 1e3;
-      case "week":
-        return value * 7 * 24 * 60 * 60 * 1e3;
-    }
-  }
-  return 60 * 60 * 1e3;
-}
-function parseEffectFromText(text) {
-  try {
-    const result = parseDomainEffect(text);
-    if (Array.isArray(result)) {
-      return result;
-    }
-    return null;
-  } catch {
-    return null;
+      schema: orbitalSchema,
+      validation,
+      stats
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+      stats
+    };
   }
 }
 
+// src/orbitals/domain-language/index.ts
+var domain_language_exports = {};
+__export(domain_language_exports, {
+  ODL_EXAMPLES: () => ODL_EXAMPLES,
+  ODL_PATTERNS: () => ODL_PATTERNS,
+  ODL_SYNTAX_REFERENCE: () => ODL_SYNTAX_REFERENCE,
+  ODL_TO_SCHEMA_MAPPING: () => ODL_TO_SCHEMA_MAPPING
+});
+__reExport(domain_language_exports, domain_language_star);
+
+// src/orbitals/domain-language/prompts/odl-syntax.ts
+var ODL_SYNTAX_REFERENCE = `
+## Domain Language Syntax
+
+### Entity Definition
+
+\`\`\`
+A [EntityName] is a [persistence] entity that:
+  - has [fieldName] as [type] (required|optional)
+  - has [fieldName] as [type] with default [value]
+  - belongs to [RelatedEntity]
+  - belongs to [RelatedEntity] as [alias]
+  - has many [RelatedEntity]s
+\`\`\`
+
+**Persistence types:**
+- \`persistent\` - Stored in database (default)
+- \`runtime\` - Memory only, for games/UI state
+- \`singleton\` - Single instance, for config
+
+**Field types:**
+- \`text\` / \`long text\` - String fields
+- \`number\` / \`currency\` - Numeric fields
+- \`yes/no\` - Boolean fields
+- \`date\` / \`timestamp\` / \`datetime\` - Date fields
+- \`enum [val1, val2]\` - Enumeration
+- \`list\` / \`object\` - Complex types
+
+### Page Definition
+
+\`\`\`
+[PageName] at /[path]:
+  - shows [Entity] using [TraitName]
+  - view type: [list|detail|create|edit|dashboard]
+  - is initial page
+\`\`\`
+
+### Behavior Definition
+
+\`\`\`
+[BehaviorName] behavior:
+  States: [State1], [State2], [State3]
+  Initial: [State1]
+
+  Transitions:
+    - From [State1] to [State2] on [EVENT_NAME]
+      if [guard condition]
+      then [effect1]
+      then [effect2]
+\`\`\`
+
+### Section Headers
+
+Domain Language text is organized into sections:
+
+\`\`\`
+# Entities
+[entity definitions]
+
+# Pages
+[page definitions]
+
+# Behaviors
+[behavior/trait definitions]
+\`\`\`
+`;
+
+// src/orbitals/domain-language/prompts/odl-examples.ts
+var ODL_EXAMPLES = `
+## Complete Example
+
+### Entity
+
+\`\`\`
+A Task is a persistent entity that:
+  - has title as text (required)
+  - has description as long text
+  - has status as enum [todo, in_progress, done] with default "todo"
+  - has dueDate as date
+  - belongs to User as assignee
+  - belongs to Project
+\`\`\`
+
+### Page
+
+\`\`\`
+TasksPage at /tasks:
+  - shows Task using TaskManagement
+  - view type: list
+  - is initial page
+\`\`\`
+
+### Behavior
+
+\`\`\`
+TaskManagement behavior:
+  States: Viewing, Editing, Creating
+  Initial: Viewing
+
+  Transitions:
+    - From Viewing to Viewing on INIT
+      then render page-header to main with title 'Tasks'
+      then render entity-table to center for Task
+
+    - From Viewing to Editing on EDIT_TASK
+      then render form-section to modal for Task
+
+    - From Editing to Viewing on SAVE_TASK
+      then persist update Task
+      then render null to modal
+      then emit TASK_UPDATED
+\`\`\`
+
+## Multi-Entity Example
+
+\`\`\`
+# Entities
+
+A User is a persistent entity that:
+  - has name as text (required)
+  - has email as text (required)
+  - has role as enum [admin, user, guest] with default "user"
+
+A Project is a persistent entity that:
+  - has name as text (required)
+  - has description as long text
+  - has status as enum [active, archived] with default "active"
+  - belongs to User as owner
+
+A Task is a persistent entity that:
+  - has title as text (required)
+  - has status as enum [todo, in_progress, done] with default "todo"
+  - has priority as number with default 0
+  - belongs to Project
+  - belongs to User as assignee
+
+# Pages
+
+ProjectsPage at /projects:
+  - shows Project using ProjectManagement
+  - view type: list
+  - is initial page
+
+TasksPage at /projects/:projectId/tasks:
+  - shows Task using TaskManagement
+  - view type: list
+
+# Behaviors
+
+ProjectManagement behavior:
+  States: List, Detail
+  Initial: List
+
+  Transitions:
+    - From List to List on INIT
+      then render entity-table to main for Project
+
+    - From List to Detail on VIEW_PROJECT
+      then render entity-detail to drawer for Project
+
+TaskManagement behavior:
+  States: Viewing, Editing
+  Initial: Viewing
+
+  Transitions:
+    - From Viewing to Viewing on INIT
+      then ["render-ui", "main", {"type": "entity-table", "entity": "Task", "itemActions": [{"label": "Edit", "event": "EDIT_TASK"}, {"label": "Delete", "event": "DELETE_TASK", "variant": "danger"}]}]
+
+    - From Viewing to Editing on EDIT_TASK
+      then render form-section to modal for Task
+
+    - From Editing to Viewing on SAVE_TASK
+      then persist update Task
+      then render null to modal
+\`\`\`
+
+## Dashboard Example (Complex Patterns)
+
+\`\`\`
+Dashboard behavior:
+  States: Viewing
+  Initial: Viewing
+
+  Transitions:
+    - From Viewing to Viewing on INIT
+      then render page-header to main with title 'Dashboard'
+      then ["render-ui", "center", {"type": "stats", "metrics": [{"field": "totalTasks", "label": "Total Tasks"}, {"field": "completedTasks", "label": "Completed"}, {"field": "overdueTasks", "label": "Overdue"}]}]
+      then ["render-ui", "bottom", {"type": "tabs", "tabs": [{"id": "overview", "label": "Overview", "event": "VIEW_OVERVIEW"}, {"id": "recent", "label": "Recent Activity", "event": "VIEW_RECENT"}]}]
+\`\`\`
+
+**Note**: Use inline JSON for \`render-ui\` effects with complex props (metrics, tabs, itemActions, cells).
+`;
+
+// src/orbitals/domain-language/prompts/odl-patterns.ts
+var ODL_PATTERNS = `
+## Common Patterns
+
+### CRUD Pattern
+
+\`\`\`
+[Entity]Management behavior:
+  States: List, Detail, Create, Edit
+  Initial: List
+
+  Transitions:
+    - From List to List on INIT
+      then render entity-table to main for [Entity]
+
+    - From List to Create on CREATE_[ENTITY]
+      then render form-section to modal for [Entity]
+
+    - From Create to List on SUBMIT_CREATE
+      then persist create [Entity]
+      then render null to modal
+
+    - From List to Detail on VIEW_[ENTITY]
+      then render entity-detail to drawer for [Entity]
+
+    - From Detail to Edit on EDIT_[ENTITY]
+      then render form-section to modal for [Entity]
+
+    - From Edit to Detail on SUBMIT_EDIT
+      then persist update [Entity]
+      then render null to modal
+
+    - From Detail to List on DELETE_[ENTITY]
+      then persist delete [Entity]
+      then render null to drawer
+\`\`\`
+
+### Game Health Pattern
+
+\`\`\`
+Health behavior:
+  States: Healthy, Wounded, Critical, Dead
+  Initial: Healthy
+
+  Transitions:
+    - From Healthy to Wounded on TAKE_DAMAGE
+      if health >= 30 and health < 70
+      then update status to 'wounded'
+
+    - From Wounded to Critical on TAKE_DAMAGE
+      if health < 30
+      then update status to 'critical'
+
+    - From Critical to Dead on TAKE_DAMAGE
+      if health <= 0
+      then update isAlive to false
+      then emit ENTITY_DIED
+\`\`\`
+
+### Approval Workflow Pattern
+
+\`\`\`
+ApprovalWorkflow behavior:
+  States: Draft, Pending, Approved, Rejected
+  Initial: Draft
+
+  Transitions:
+    - From Draft to Pending on SUBMIT
+      then update status to 'pending'
+      then emit APPROVAL_REQUESTED
+
+    - From Pending to Approved on APPROVE
+      then update status to 'approved'
+      then update approvedAt to now
+      then emit APPROVAL_GRANTED
+
+    - From Pending to Rejected on REJECT
+      then update status to 'rejected'
+      then emit APPROVAL_DENIED
+
+    - From Rejected to Draft on REVISE
+      then update status to 'draft'
+\`\`\`
+
+### Form Validation Pattern
+
+\`\`\`
+FormValidation behavior:
+  States: Idle, Validating, Valid, Invalid
+  Initial: Idle
+
+  Transitions:
+    - From Idle to Validating on VALIDATE
+      then update isValidating to true
+
+    - From Validating to Valid on VALIDATION_SUCCESS
+      then update isValidating to false
+      then update errors to null
+
+    - From Validating to Invalid on VALIDATION_FAILED
+      then update isValidating to false
+
+    - From Invalid to Validating on VALIDATE
+      then update isValidating to true
+
+    - From Valid to Idle on RESET
+      then update errors to null
+\`\`\`
+
+### Dashboard Pattern
+
+\`\`\`
+DashboardView behavior:
+  States: Loading, Ready
+  Initial: Loading
+
+  Transitions:
+    - From Loading to Ready on DATA_LOADED
+      then render stats to main
+      then render entity-cards to center
+
+    - From Ready to Loading on REFRESH
+      then emit FETCH_DASHBOARD_DATA
+\`\`\`
+`;
+
+// src/orbitals/domain-language/prompts/odl-to-schema.ts
+var ODL_TO_SCHEMA_MAPPING = `
+## Domain Language -> OrbitalSchema Mapping
+
+| Domain Language | OrbitalSchema |
+|-----------------|---------------|
+| "A Task is..." | \`{ "entity": { "name": "Task", ... } }\` |
+| "persistent entity" | \`"persistence": "persistent"\` |
+| "runtime entity" | \`"persistence": "runtime"\` |
+| "singleton entity" | \`"persistence": "singleton"\` |
+| "has X as text" | \`{ "name": "X", "type": "string" }\` |
+| "has X as number" | \`{ "name": "X", "type": "number" }\` |
+| "has X as yes/no" | \`{ "name": "X", "type": "boolean" }\` |
+| "has X as enum [a, b]" | \`{ "name": "X", "type": "enum", "values": ["a", "b"] }\` |
+| "belongs to Y" | \`{ "type": "relation", "relation": { "entity": "Y" } }\` |
+| "belongs to Y as alias" | \`{ "name": "alias", "type": "relation", "relation": { "entity": "Y" } }\` |
+| "States: A, B" | \`"states": [{ "name": "A" }, { "name": "B" }]\` |
+| "Initial: A" | \`{ "name": "A", "isInitial": true }\` |
+| "From X to Y on Z" | \`{ "from": "X", "to": "Y", "event": "Z" }\` |
+| "if health >= 0" | \`"guard": [">=", "@entity.health", 0]\` |
+| "then update status to 'done'" | \`"effects": [["set", "@entity.status", "done"]]\` |
+| "then emit EVENT" | \`"effects": [["emit", "EVENT"]]\` |
+| "then render X to slot" | \`"effects": [["render-ui", "slot", { "type": "X" }]]\` |
+| "then persist create Task" | \`"effects": [["persist", "create", "Task"]]\` |
+| "then navigate to /path" | \`"effects": [["navigate", "/path"]]\` |
+
+## Conversion Process
+
+1. **Parse Domain Language** - Split into sections (Entities, Pages, Behaviors)
+2. **Extract entities** - Parse "A X is..." definitions
+3. **Extract pages** - Parse "[Name] at /path" definitions
+4. **Extract behaviors** - Parse "[Name] behavior:" definitions
+5. **Parse guards** - Convert human-readable conditions to S-expressions
+6. **Parse effects** - Convert human-readable effects to S-expressions
+7. **Assemble schema** - Build OrbitalSchema JSON structure
+
+## CLI Commands
+
+\`\`\`bash
+# Convert Domain Language to OrbitalSchema
+npx kflow domain:to-schema input.txt -o output.orb
+
+# Convert OrbitalSchema to Domain Language
+npx kflow domain:to-text input.orb -o output.txt
+
+# Validate round-trip conversion
+npx kflow domain:validate input.orb --verbose
+\`\`\`
+`;
+
 // src/tools/finish-task.ts
 var execAsync2 = promisify(exec);
 async function collectOrbitalsFromDir(workDir) {
@@ -3752,7 +1125,7 @@ function createFinishTaskTool(workDir) {
             if (domainText.trim()) {
               source = "domain";
               const appName = input.summary?.match(/Generated \d+ orbitals?:?\s*(.+)/)?.[1] || "Application";
-              const domainResult = convertDomainToSchema(domainText, {
+              const domainResult = (0, domain_language_exports.convertDomainToSchema)(domainText, {
                 name: appName,
                 orbitals: []
               });
@@ -4207,7 +1580,7 @@ function createConstructCombinedDomainTool(options = {}) {
           role: "assistant",
           isComplete: false
         });
-        const schemaResult = convertDomainToSchema(domainText, {
+        const schemaResult = (0, domain_language_exports.convertDomainToSchema)(domainText, {
           name: appName,
           orbitals: []
         });
@@ -4955,6 +2328,273 @@ function createSchemaChunkingTools(workDir) {
     applyChunk: createApplyChunkTool(workDir)
   };
 }
+var designCache = /* @__PURE__ */ new Map();
+var CACHE_TTL_MS2 = 24 * 60 * 60 * 1e3;
+var CACHE_VERSION2 = 1;
+function generateFingerprint2(input) {
+  const normalized = JSON.stringify({
+    version: CACHE_VERSION2,
+    ...input
+  });
+  return crypto.createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+}
+function getCached2(fingerprint) {
+  const entry = designCache.get(fingerprint);
+  if (!entry) return null;
+  if (Date.now() - entry.timestamp > CACHE_TTL_MS2) {
+    designCache.delete(fingerprint);
+    return null;
+  }
+  return entry;
+}
+var STATIC_DESIGN_PROMPT = null;
+function getDesignSystemPrompt() {
+  if (!STATIC_DESIGN_PROMPT) {
+    const skill = generateKflowDesignSkill();
+    STATIC_DESIGN_PROMPT = skill.content;
+  }
+  return STATIC_DESIGN_PROMPT;
+}
+function getPatternRecommendations(input) {
+  const recContext = buildRecommendationContext({
+    state: input.from,
+    event: input.event,
+    slot: input.slot,
+    domainCategory: input.domainCategory,
+    entityFields: input.entityFields
+  });
+  return recommendPatterns(recContext, 8);
+}
+function buildDesignUserPrompt(input) {
+  const fieldList = input.entityFields.map((f) => {
+    let desc = `  - ${f.name}: ${f.type}`;
+    if (f.values) desc += ` (values: ${f.values.join(", ")})`;
+    return desc;
+  }).join("\n");
+  const hints = [];
+  if (input.designStyle) hints.push(`Style: ${input.designStyle}`);
+  if (input.flowPattern) hints.push(`Flow: ${input.flowPattern}`);
+  if (input.listPattern) hints.push(`List: ${input.listPattern}`);
+  if (input.formPattern) hints.push(`Form: ${input.formPattern}`);
+  if (input.detailPattern) hints.push(`Detail: ${input.detailPattern}`);
+  const vocab = input.vocabulary ? Object.entries(input.vocabulary).map(([k, v]) => `  ${k} \u2192 "${v}"`).join("\n") : "";
+  return `Design render-ui effects for this transition:
+
+## Transition
+- **From**: ${input.from}
+- **To**: ${input.to}
+- **Event**: ${input.event}
+- **Slot**: ${input.slot}
+
+## Entity: ${input.entityName}
+${fieldList}
+
+## Domain
+- **Category**: ${input.domainCategory || "business"}
+${vocab ? `- **Vocabulary**:
+${vocab}` : ""}
+${hints.length > 0 ? `- **Design Hints**: ${hints.join(", ")}` : ""}
+
+${input.recommendationsSection || ""}
+
+${input.existingEffects ? `## Existing Effects (enhance these)
+\`\`\`json
+${JSON.stringify(input.existingEffects, null, 2)}
+\`\`\`` : ""}
+
+Return ONLY the JSON array of render-ui effect tuples.`;
+}
+var DesignTransitionSchema = z.object({
+  from: z.string().describe('Source state name (e.g., "Browsing")'),
+  to: z.string().describe('Target state name (e.g., "Browsing" for self-loop, "Creating" for transition)'),
+  event: z.string().describe('Event name (e.g., "INIT", "CREATE", "VIEW", "EDIT", "DELETE", "SAVE", "CANCEL")'),
+  slot: z.string().describe('UI slot to render into: "main", "modal", "drawer", "sidebar", "overlay"'),
+  entityName: z.string().describe('Entity name (e.g., "Task", "Order")'),
+  entityFields: z.array(z.object({
+    name: z.string(),
+    type: z.string(),
+    values: z.array(z.string()).optional()
+  })).describe("Entity fields with types and optional enum values"),
+  domainCategory: z.enum(["business", "game", "dashboard", "form", "content", "social", "e-commerce", "workflow"]).optional().describe("Domain category for pattern selection"),
+  vocabulary: z.record(z.string(), z.string()).optional().describe('Domain vocabulary mapping (e.g., { "create": "Place Order", "item": "Order" })'),
+  designStyle: z.enum(["minimal", "modern", "playful", "data-driven", "immersive"]).optional().describe("Visual style hint"),
+  flowPattern: z.enum(["hub-spoke", "master-detail", "crud-cycle", "linear", "role-based"]).optional().describe("Application flow pattern"),
+  listPattern: z.enum(["entity-table", "entity-cards", "entity-list"]).optional().describe("Preferred list pattern"),
+  formPattern: z.enum(["modal", "drawer", "page"]).optional().describe("Preferred form pattern"),
+  detailPattern: z.enum(["drawer", "page", "split"]).optional().describe("Preferred detail view pattern"),
+  existingEffects: z.array(z.any()).optional().describe("Existing render-ui effects to enhance (for refinement passes)")
+});
+function createDesignTransitionTool(options = {}) {
+  let eventCallback = options.onEvent;
+  const setEventCallback = (callback) => {
+    eventCallback = callback;
+  };
+  const emitEvent = (transitionId, type, data) => {
+    if (eventCallback) {
+      eventCallback(transitionId, {
+        type,
+        data,
+        timestamp: Date.now()
+      });
+    }
+  };
+  const designTransitionTool = tool(
+    async (input) => {
+      const transitionId = `${input.entityName}:${input.from}->${input.to}:${input.event}`;
+      const fingerprint = generateFingerprint2({
+        from: input.from,
+        to: input.to,
+        event: input.event,
+        slot: input.slot,
+        entityName: input.entityName,
+        entityFields: input.entityFields,
+        domainCategory: input.domainCategory,
+        designStyle: input.designStyle,
+        flowPattern: input.flowPattern,
+        listPattern: input.listPattern
+      });
+      try {
+        emitEvent(transitionId, "message", {
+          content: `Designing UI for ${transitionId}`,
+          role: "assistant",
+          isComplete: false
+        });
+        const cached = getCached2(fingerprint);
+        if (cached) {
+          emitEvent(transitionId, "generation_log", {
+            level: "info",
+            message: `Design cache HIT for ${transitionId}`,
+            data: { fingerprint }
+          });
+          return JSON.stringify({
+            success: true,
+            transitionId,
+            effects: cached.effects,
+            cached: true,
+            usage: cached.usage
+          });
+        }
+        const recommendations = getPatternRecommendations(input);
+        const recommendationsSection = formatRecommendationsForPrompt(recommendations);
+        const systemPrompt = getDesignSystemPrompt();
+        const userPrompt = buildDesignUserPrompt({
+          ...input,
+          recommendationsSection
+        });
+        emitEvent(transitionId, "tool_call", {
+          tool: "llm_design_transition",
+          args: {
+            transition: transitionId,
+            slot: input.slot,
+            domain: input.domainCategory
+          }
+        });
+        const client = new LLMClient({
+          provider: "anthropic",
+          model: "claude-sonnet-4-20250514",
+          temperature: 0.1
+          // Slight creativity for design
+        });
+        const response = await client.callWithCache({
+          systemPrompt: "",
+          systemBlocks: [{
+            type: "text",
+            text: systemPrompt,
+            cache_control: { type: "ephemeral" }
+          }],
+          userPrompt,
+          maxTokens: 4096,
+          rawText: true
+        });
+        const rawText = (response.raw || String(response.data) || "").trim();
+        let effects;
+        try {
+          const jsonText = rawText.replace(/^```(?:json)?\n?/m, "").replace(/\n?```$/m, "").trim();
+          effects = JSON.parse(jsonText);
+          if (!Array.isArray(effects)) {
+            effects = [effects];
+          }
+        } catch {
+          return JSON.stringify({
+            success: false,
+            transitionId,
+            error: "Failed to parse design output as JSON",
+            rawOutput: rawText
+          });
+        }
+        const usage = {
+          inputTokens: response.usage?.promptTokens || 0,
+          outputTokens: response.usage?.completionTokens || 0,
+          totalTokens: response.usage?.totalTokens || 0
+        };
+        designCache.set(fingerprint, {
+          effects,
+          timestamp: Date.now(),
+          usage
+        });
+        emitEvent(transitionId, "tool_result", {
+          tool: "llm_design_transition",
+          result: { fingerprint, effectCount: effects.length, usage },
+          success: true
+        });
+        emitEvent(transitionId, "message", {
+          content: `Designed ${effects.length} effect(s) for ${transitionId} (${usage.totalTokens} tokens)`,
+          role: "assistant",
+          isComplete: true
+        });
+        return JSON.stringify({
+          success: true,
+          transitionId,
+          effects,
+          cached: false,
+          usage,
+          recommendedPatterns: recommendations.map((r) => r.pattern)
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        emitEvent(transitionId, "error", {
+          error: errorMessage,
+          code: "DESIGN_TRANSITION_ERROR"
+        });
+        return JSON.stringify({
+          success: false,
+          transitionId,
+          error: errorMessage
+        });
+      }
+    },
+    {
+      name: "design_transition",
+      description: `Design rich render-ui effects for a single orbital transition.
+
+Takes the transition context (from/to state, event, entity, domain) and produces
+polished render-ui effects using the full pattern catalog.
+
+USE THIS TOOL WHEN:
+- Generating INIT transitions (always compose header + stats + content)
+- Generating CREATE/EDIT transitions (form with proper fields)
+- Generating VIEW transitions (detail with tabs for related entities)
+- Enhancing existing render-ui effects that are too basic
+
+The tool uses a specialized design skill with pattern catalog, layout composition,
+and domain-aware pattern selection to produce rich UI.
+
+RETURNS: { success, effects: [["render-ui", slot, config], ...], transitionId, usage }
+
+The effects array contains ONLY render-ui tuples. Non-UI effects (persist, emit, set)
+are NOT included \u2014 you must preserve those from the original transition.
+
+INTEGRATION: After calling this tool, use extract_chunk to get the orbital,
+replace the render-ui effects in the target transition (keep persist/emit/set effects),
+then apply_chunk to merge back into schema.json.`,
+      schema: DesignTransitionSchema
+    }
+  );
+  return {
+    tool: designTransitionTool,
+    setEventCallback
+  };
+}
 function createGitHubTools(config) {
   const { token, owner = "", repo = "", workDir } = config;
   const integrationConfig = {
@@ -5926,6 +3566,11 @@ ${skillContents}`;
       console.log(`[SkillAgent] Domain orbital tools enabled for ${primarySkill.name} skill`);
     }
   }
+  const needsDesignTool = isDesignSkill || ORBITAL_SKILLS.includes(primarySkill.name);
+  const designTool = needsDesignTool ? createDesignTransitionTool() : null;
+  if (designTool && verbose) {
+    console.log(`[SkillAgent] Design transition tool enabled for ${primarySkill.name} skill`);
+  }
   const githubTools = options.githubConfig ? createGitHubToolsArray({
     token: options.githubConfig.token,
     owner: options.githubConfig.owner,
@@ -5949,6 +3594,7 @@ ${skillContents}`;
       chunkingTools.extractChunk,
       chunkingTools.applyChunk
     ] : [],
+    ...designTool ? [designTool.tool] : [],
     ...githubTools || []
   ];
   const checkpointer = sessions.getCheckpointer(threadId);