@almadar/agent 3.2.0 → 3.5.1

package/dist/gates/index.js

@@ -0,0 +1,2034 @@
+import fs4 from 'fs';
+import path4 from 'path';
+import { extractJsonFromText, createDeepSeekClient, createOpenRouterClient } from '@almadar/llm';
+import { getAllBehaviors } from '@almadar/std';
+import { execSync } from 'child_process';
+import { getDecompositionCompact, getBindingsCompact, getBindingContextRules, getOrbRenderUIGuide } from '@almadar/skills';
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+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 });
+};
+
+// src/gates/gate05-behavior-match.ts
+var gate05_behavior_match_exports = {};
+__export(gate05_behavior_match_exports, {
+  loadGoldenOrbByName: () => loadGoldenOrb,
+  runGate05: () => runGate05
+});
+function getBehaviorCatalog() {
+  if (cachedCatalog) return cachedCatalog;
+  const all = getAllBehaviors();
+  const lines = all.map((b) => {
+    const name = String(b.name || "");
+    const desc = String(b.description || "");
+    const states = Array.isArray(b.states) ? b.states.length : 0;
+    const events = Array.isArray(b.events) ? b.events.length : 0;
+    return `- ${name}: ${desc} (${states} states, ${events} events)`;
+  });
+  cachedCatalog = lines.join("\n");
+  return cachedCatalog;
+}
+function findExportsDir() {
+  const monorepoPath = path4.resolve(
+    path4.dirname(new URL(import.meta.url).pathname),
+    "../../../almadar-std/behaviors/exports"
+  );
+  if (fs4.existsSync(monorepoPath)) return monorepoPath;
+  try {
+    const stdPkg = path4.dirname(__require.resolve("@almadar/std/package.json"));
+    const nmPath = path4.join(stdPkg, "behaviors", "exports");
+    if (fs4.existsSync(nmPath)) return nmPath;
+  } catch {
+  }
+  return null;
+}
+function loadGoldenOrb(behaviorName) {
+  const exportsDir = findExportsDir();
+  if (!exportsDir) {
+    console.warn("[Gate 0.5] Cannot find behaviors/exports/ directory");
+    return null;
+  }
+  const orbPath = path4.join(exportsDir, `${behaviorName}.orb`);
+  if (!fs4.existsSync(orbPath)) {
+    console.warn(`[Gate 0.5] .orb file not found: ${orbPath}`);
+    return null;
+  }
+  const content = fs4.readFileSync(orbPath, "utf-8");
+  return JSON.parse(content);
+}
+function buildMatchSystemPrompt() {
+  return `You are a behavior matching assistant. Given an application description and its orbital structure, select the most relevant golden behavior from the catalog below.
+
+The catalog contains 107 standard behaviors. Each behavior is a proven, production-quality .orb program that handles a specific interaction pattern (CRUD lists, forms, search, cart, booking, etc.).
+
+Your task: pick the ONE behavior that best matches the application's primary interaction pattern. If no behavior is a close match, respond with "none".
+
+Respond with ONLY valid JSON: { "match": "std-behavior-name" } or { "match": "none" }
+No markdown, no explanation.`;
+}
+function buildMatchUserPrompt(prompt, orb) {
+  const orbitalNames = orb.orbitals.map((o) => {
+    const name = o.name;
+    return name;
+  });
+  return `Application: ${prompt}
+
+Orbitals produced by Gate 0: ${orbitalNames.join(", ")}
+
+Behavior catalog:
+${getBehaviorCatalog()}`;
+}
+async function runGate05(client, prompt, orb, opts = {}) {
+  const systemPrompt = buildMatchSystemPrompt();
+  const userPrompt = buildMatchUserPrompt(prompt, orb);
+  const raw = await client.callRaw({
+    systemPrompt,
+    userPrompt,
+    maxTokens: opts.maxTokens ?? 256
+  });
+  const parsed = extractJsonFromText(raw);
+  if (!parsed) {
+    console.warn("[Gate 0.5] Failed to parse match response, falling back to pure mode");
+    return { matchedName: null, goldenOrb: null };
+  }
+  const obj = JSON.parse(parsed);
+  const matchName = String(obj.match || "none");
+  if (matchName === "none") {
+    console.log("[Gate 0.5] No behavior match found, using pure mode");
+    return { matchedName: null, goldenOrb: null };
+  }
+  const goldenOrb = loadGoldenOrb(matchName);
+  if (!goldenOrb) {
+    console.warn(`[Gate 0.5] Matched "${matchName}" but could not load .orb file`);
+    return { matchedName: matchName, goldenOrb: null };
+  }
+  console.log(`[Gate 0.5] Matched behavior: ${matchName}`);
+  return { matchedName: matchName, goldenOrb };
+}
+var cachedCatalog;
+var init_gate05_behavior_match = __esm({
+  "src/gates/gate05-behavior-match.ts"() {
+    cachedCatalog = null;
+  }
+});
+var ORBITAL_BINARY = "/home/osamah/bin/orbital";
+function validateWithOrbitalCLI(schema, workDir) {
+  if (!fs4.existsSync(ORBITAL_BINARY)) {
+    return {
+      valid: false,
+      errors: [{ code: "CLI_NOT_FOUND", path: "", message: `orbital binary not found at ${ORBITAL_BINARY}` }]
+    };
+  }
+  const schemaStr = typeof schema === "string" ? schema : JSON.stringify(schema, null, 2);
+  const tempPath = path4.join(workDir, `_eval_validate_${Date.now()}.orb`);
+  try {
+    fs4.writeFileSync(tempPath, schemaStr);
+    const output = execSync(`${ORBITAL_BINARY} validate --json "${tempPath}"`, {
+      encoding: "utf-8",
+      timeout: 3e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const result = JSON.parse(extractJson(output));
+    return result;
+  } catch (error) {
+    const err = error;
+    if (err.stdout) {
+      try {
+        return JSON.parse(extractJson(err.stdout));
+      } catch {
+      }
+    }
+    return {
+      valid: false,
+      errors: [{
+        code: "CLI_ERROR",
+        path: "",
+        message: err.stderr?.trim() || err.message || "Unknown CLI error"
+      }]
+    };
+  } finally {
+    try {
+      fs4.unlinkSync(tempPath);
+    } catch {
+    }
+  }
+}
+function extractJson(raw) {
+  const objects = [];
+  let i = 0;
+  while (i < raw.length) {
+    if (raw[i] === "{") {
+      let depth = 0;
+      let inString = false;
+      let escape = false;
+      const start = i;
+      for (; i < raw.length; i++) {
+        const ch = raw[i];
+        if (escape) {
+          escape = false;
+          continue;
+        }
+        if (ch === "\\" && inString) {
+          escape = true;
+          continue;
+        }
+        if (ch === '"') {
+          inString = !inString;
+          continue;
+        }
+        if (inString) continue;
+        if (ch === "{") depth++;
+        if (ch === "}") {
+          depth--;
+          if (depth === 0) {
+            objects.push(raw.slice(start, i + 1));
+            i++;
+            break;
+          }
+        }
+      }
+    } else {
+      i++;
+    }
+  }
+  for (const obj of objects) {
+    if (obj.includes('"valid"')) return obj;
+  }
+  if (objects.length > 0) return objects[objects.length - 1];
+  return raw.trim();
+}
+function buildGate0SystemPrompt() {
+  const decomposition = getDecompositionCompact();
+  return `You are an application architect. Given a natural language description, produce a shell .orb JSON schema.
+
+${decomposition}
+
+Your output must be a JSON object with:
+- name: PascalCase application name
+- version: "1.0.0"
+- orbitals: array of orbital shells
+
+Each orbital shell:
+- name: PascalCase ending in "Orbital" (e.g., "TaskOrbital")
+- entity: { name: PascalCase singular noun, fields: [{ name: "id", type: "string", required: true }] }
+- traits: [{ name: PascalCase, linkedEntity: entityName, category: "interaction", stateMachine: { states: [{ name: "idle", isInitial: true }], events: [], transitions: [] } }]
+- pages: [{ name: PascalCase, path: "/lowercase", traits: [{ ref: "TraitName" }] }]
+
+Rules:
+- ONE orbital per entity type
+- Every orbital must have at least one trait
+- Keep it minimal: only the orbitals truly needed
+- Do NOT fill in entity fields (Gate 1 does that)
+- Do NOT fill in state machines (Gate 2 does that)
+
+Respond with ONLY valid JSON. No markdown, no explanation.`;
+}
+function buildGate0UserPrompt(prompt, guidedData) {
+  let userPrompt = `Decompose this application into an .orb schema:
+
+${prompt}`;
+  if (guidedData) {
+    userPrompt += `
+
+Reference structure (use as guide):
+- ${guidedData.orbitalCount} orbital(s)
+- Entities: ${guidedData.entityNames.join(", ")}
+- Traits: ${guidedData.traitNames.join(", ")}`;
+  }
+  return userPrompt;
+}
+function buildGate1SystemPrompt() {
+  return `You are an entity designer. Given an orbital shell, enrich it with full entity fields, persistence, and page details. Do NOT modify the state machine (Gate 2 fills that).
+
+Your output must be a JSON object with:
+- name: keep unchanged
+- entity:
+  - name: keep unchanged
+  - persistence: "persistent" (survives sessions, needs collection), "runtime" (transient), or "singleton" (app-wide config)
+  - collection: snake_case plural (only for persistent entities, e.g., "cart_items")
+  - fields: array of { name, type, required?, default? }
+    - First field MUST be { name: "id", type: "string", required: true }
+    - Valid types: "string", "number", "boolean", "object", "array"
+    - Include ALL fields the entity needs (status, timestamps, amounts, references, etc.)
+- traits: keep unchanged (shell state machine, Gate 2 fills it)
+- pages: [{ name: PascalCase, path: "/lowercase", isInitial?, traits: [{ ref: "TraitName" }] }]
+  - EVERY page MUST have a traits array binding it to the orbital's trait(s)
+  - Without traits, the page renders blank (runtime doesn't know which trait to activate)
+
+Rules:
+- Think about what fields this entity genuinely needs for its domain
+- Include status fields (e.g., "status": "string") for entities with lifecycle states
+- Include amount/count fields (e.g., "total": "number") for entities with calculations
+- Include timestamp fields (e.g., "createdAt": "string") for auditable entities
+- Do NOT touch the stateMachine. Return it exactly as received.
+
+Respond with ONLY valid JSON. No markdown, no explanation.`;
+}
+function buildGate1UserPrompt(orbital, allOrbitals, guidedOrbital) {
+  let userPrompt = `Enrich this orbital with full entity fields and pages:
+${JSON.stringify(orbital, null, 2)}
+
+Other orbitals in this application (for cross-orbital context):
+${JSON.stringify(allOrbitals.filter((o) => o.name !== orbital.name), null, 2)}`;
+  if (guidedOrbital) {
+    userPrompt += `
+
+Reference (use as guide):
+${JSON.stringify(guidedOrbital, null, 2)}`;
+  }
+  return userPrompt;
+}
+function buildGate2SystemPrompt() {
+  return `You are a state machine designer. Given a trait and its entity, design the state machine topology and assign UI slot presentations per state.
+
+Your output must be a JSON object with:
+- name: keep unchanged
+- linkedEntity: keep unchanged
+- category: "interaction"
+- stateMachine:
+  - states: [{ name: camelCase, isInitial?: true }]
+  - events: [{ key: "UPPER_SNAKE_CASE", name: "Human Label", payloadSchema?: [{ name, type }] }]
+  - transitions: [{ from, event, to, effects: [] }]
+- ui: { "stateName": { "presentation": "inline" | "modal" }, ... }
+
+State Machine Rules:
+- Exactly ONE state must have isInitial: true (typically "idle" or "browsing")
+- Every state must be reachable from the initial state
+- Every event must be used in at least one transition
+- The initial state MUST have an INIT self-loop transition (idle->INIT->idle or browsing->INIT->browsing)
+- Leave effects as empty arrays (Gate 3 fills these)
+
+UI Slot Assignment Rules:
+- Assign "inline" to primary view states (idle, browsing, listing, viewing)
+- Assign "modal" to overlay action states (creating, editing, deleting, confirming)
+- Every state MUST have an assignment in the ui object
+- Every "modal" state MUST have BOTH a CLOSE and CANCEL transition back to an "inline" state
+
+Typical CRUD state machine pattern:
+- idle/browsing (inline): main list view, INIT self-loop
+- creating (modal): opened by CREATE event, closed by SAVE/CANCEL/CLOSE
+- editing (modal): opened by EDIT event, closed by SAVE/CANCEL/CLOSE
+- deleting (modal): opened by DELETE event, closed by CONFIRM_DELETE/CANCEL/CLOSE
+
+Respond with ONLY valid JSON. No markdown, no explanation.`;
+}
+function buildGate2UserPrompt(trait, entity, orbitalDescription, guidedTrait) {
+  let userPrompt = `Design the state machine for trait:
+${JSON.stringify(trait, null, 2)}
+
+Entity it manages:
+${JSON.stringify(entity, null, 2)}
+
+Orbital context: ${orbitalDescription}`;
+  if (guidedTrait) {
+    userPrompt += `
+
+Reference (use as guide):
+${JSON.stringify(guidedTrait, null, 2)}`;
+  }
+  return userPrompt;
+}
+function buildGate3SystemPrompt() {
+  const bindingsCompact = getBindingsCompact();
+  const bindingContextRules = getBindingContextRules();
+  return `You are a transition effect designer. Given a transition, add guards and data effects.
+
+${bindingsCompact}
+
+${bindingContextRules}
+
+Your output must be a JSON object with:
+- from: keep unchanged
+- event: keep unchanged
+- to: keep unchanged
+- guard: s-expression array or null
+  Example: ["and", ["not", ["eq", "@entity.status", "locked"]], ["gt", "@entity.count", 0]]
+- effects: array of effect tuples
+
+Effect types (use ONLY these four):
+- ["set", "@entity.fieldName", value] - Set entity field. Value: "@payload.field", "@now", or literal.
+- ["fetch", "EntityName"] - Load entity data. Use in INIT transitions.
+- ["persist", "create"|"update"|"delete", "EntityName", "@payload.data"] - CRUD entity records.
+- ["notify", "message", "success"|"error"|"info"] - Show a notification.
+
+BANNED effects: call-service, emit, log, navigate.
+
+Rules:
+- Guards are optional. Only add when the transition genuinely needs a precondition.
+- INIT transitions: include ["fetch", "EntityName"]
+- SAVE transitions (from creating): include ["persist", "create", "EntityName", "@payload.data"]
+- SAVE transitions (from editing): include ["persist", "update", "EntityName", "@payload.data"]
+- CONFIRM_DELETE transitions: include ["persist", "delete", "EntityName", "@payload.data"]
+- set target MUST start with @entity (never @payload)
+- Do NOT include render-ui effects (Gate 4 handles those)
+
+Respond with ONLY valid JSON. No markdown, no explanation.`;
+}
+function buildGate3UserPrompt(transition, entity, sm, guidedTransition) {
+  let userPrompt = `Design effects for transition:
+${transition.from} --[${transition.event}]--> ${transition.to}
+
+Entity: ${JSON.stringify(entity, null, 2)}
+All states: ${sm.states.map((s) => s.name).join(", ")}
+All events: ${JSON.stringify(sm.events, null, 2)}`;
+  if (guidedTransition) {
+    userPrompt += `
+
+Reference (use as guide):
+${JSON.stringify(guidedTransition, null, 2)}`;
+  }
+  return userPrompt;
+}
+function buildGate4SystemPrompt() {
+  const orbGuide = getOrbRenderUIGuide();
+  return `You are a UI designer. Given a transition with its effects, produce the render-ui pattern tree.
+
+${orbGuide}
+
+Your output must be a JSON object with:
+- renderEffects: [{ slot, tree }]
+  - slot: "main" or "modal" (determined by the state's slot assignment shown in the user prompt)
+  - tree: pattern composition object, or null (to clear a slot)
+
+Slot Rules:
+- Use the slot shown in the user prompt for the target state (main or modal)
+- When exiting a modal state (the user prompt will say so), you MUST include:
+  1. { "slot": "modal", "tree": null } to clear the modal
+  2. { "slot": "main", "tree": { ... } } to render the main view
+
+Binding Rules:
+- Bindings are ONLY paths: @entity.name, @entity.price (NO expressions like @entity.x <= 0)
+- Each prop value must contain at most ONE binding. NEVER concatenate: "@entity.price @entity.currency" is INVALID
+- For combined display, use separate typography elements or static labels
+- button event props must match state machine event keys
+
+Pattern Rules:
+- Use ONLY props that exist on the pattern. Do NOT invent props.
+- data-list: entity, itemActions, emptyState (NOT emptyIcon, emptyTitle)
+- button: label, variant, event, icon, size (NOT disabled)
+- card: children (NOT padding, bg, border, use box for those)
+
+Respond with ONLY valid JSON. No markdown, no explanation.`;
+}
+function buildGate4UserPrompt(transition, entity, targetStateName, sm, slotContext, guidedRenderEffects) {
+  const targetSlot = slotContext.stateSlots[targetStateName] || "main";
+  const fromSlot = slotContext.stateSlots[transition.from] || "main";
+  let userPrompt = `Design the UI for state "${targetStateName}" (renders to "${targetSlot}" slot):
+
+Transition: ${transition.from} (${fromSlot}) --[${transition.event}]--> ${transition.to} (${targetSlot})
+Current effects: ${JSON.stringify(transition.effects || [], null, 2)}
+Entity: ${JSON.stringify(entity, null, 2)}
+All states with slots: ${Object.entries(slotContext.stateSlots).map(([s, slot]) => `${s}(${slot})`).join(", ")}`;
+  if (slotContext.exitsModal) {
+    userPrompt += `
+
+IMPORTANT: This transition exits a modal state. You MUST include:
+1. { "slot": "modal", "tree": null } to clear the modal overlay
+2. { "slot": "main", "tree": { ... } } to render the main view`;
+  }
+  if (guidedRenderEffects) {
+    userPrompt += `
+
+Reference render-ui (use as guide):
+${JSON.stringify(guidedRenderEffects, null, 2)}`;
+  }
+  return userPrompt;
+}
+
+// src/gates/gate0-application.ts
+var DEFAULT_THEME = {
+  name: "default",
+  tokens: {
+    colors: {
+      primary: "#6366f1",
+      "primary-hover": "#4f46e5",
+      "primary-foreground": "#ffffff",
+      accent: "#ec4899",
+      "accent-foreground": "#ffffff",
+      success: "#22c55e",
+      warning: "#f59e0b",
+      error: "#ef4444"
+    }
+  }
+};
+function normalizeOrbital(raw) {
+  const name = String(raw.name || "Orbital");
+  const entityRaw = raw.entity || {};
+  const entityName = String(entityRaw.name || name.replace(/Orbital$/i, ""));
+  const fields = Array.isArray(entityRaw.fields) ? entityRaw.fields : [];
+  const hasId = fields.some((f) => f.name === "id");
+  const entity = {
+    name: entityName,
+    fields: hasId ? fields.map((f) => ({
+      name: String(f.name),
+      type: String(f.type || "string"),
+      ...f.required ? { required: true } : {}
+    })) : [
+      { name: "id", type: "string", required: true },
+      ...fields.map((f) => ({
+        name: String(f.name),
+        type: String(f.type || "string"),
+        ...f.required ? { required: true } : {}
+      }))
+    ]
+  };
+  const traitsRaw = Array.isArray(raw.traits) ? raw.traits : [];
+  const traits = traitsRaw.length > 0 ? traitsRaw.map((t) => ({
+    name: String(t.name || `${entityName}Control`),
+    linkedEntity: String(t.linkedEntity || entityName),
+    category: "interaction",
+    stateMachine: {
+      states: [{ name: "idle", isInitial: true }],
+      events: [],
+      transitions: []
+    }
+  })) : [{
+    name: `${entityName}Control`,
+    linkedEntity: entityName,
+    category: "interaction",
+    stateMachine: {
+      states: [{ name: "idle", isInitial: true }],
+      events: [],
+      transitions: []
+    }
+  }];
+  const traitNames = traits.map((t) => t.name);
+  const pagesRaw = Array.isArray(raw.pages) ? raw.pages : [];
+  const defaultTraits = traitNames.map((n) => ({ ref: n }));
+  const pages = pagesRaw.length > 0 ? pagesRaw.map((p) => ({
+    name: String(p.name || name.replace(/Orbital$/i, "")),
+    path: String(p.path || p.route || `/${name.toLowerCase().replace(/orbital$/i, "")}`),
+    ...p.isInitial ? { isInitial: true } : {},
+    traits: Array.isArray(p.traits) ? p.traits : defaultTraits
+  })) : [{
+    name: name.replace(/Orbital$/i, ""),
+    path: `/${name.toLowerCase().replace(/orbital$/i, "")}`,
+    traits: defaultTraits
+  }];
+  return { name, entity, traits, pages };
+}
+function parseGate0Response(raw) {
+  const parsed = extractJsonFromText(raw);
+  if (!parsed) {
+    throw new Error(`Gate 0: failed to parse JSON from response: ${raw.slice(0, 200)}`);
+  }
+  const obj = JSON.parse(parsed);
+  const appName = String(obj.name || obj.appName || "App");
+  const version = String(obj.version || "1.0.0");
+  const orbitalsRaw = Array.isArray(obj.orbitals) ? obj.orbitals : [];
+  return {
+    name: appName,
+    version,
+    design: { theme: DEFAULT_THEME },
+    orbitals: orbitalsRaw.map((o) => normalizeOrbital(o))
+  };
+}
+async function runGate0(client, prompt, opts = {}, behaviorData) {
+  const systemPrompt = buildGate0SystemPrompt();
+  const userPrompt = buildGate0UserPrompt(
+    prompt,
+    behaviorData?.appLevel
+  );
+  const raw = await client.callRaw({
+    systemPrompt,
+    userPrompt,
+    maxTokens: opts.maxTokens ?? 4096
+  });
+  return parseGate0Response(raw);
+}
+
+// src/gates/orchestrator.ts
+init_gate05_behavior_match();
+
+// src/gates/merge.ts
+function deepCloneOrb(orb) {
+  return structuredClone(orb);
+}
+function replaceOrbital(orb, name, enriched) {
+  const clone = deepCloneOrb(orb);
+  const idx = clone.orbitals.findIndex(
+    (o) => o.name === name
+  );
+  if (idx >= 0) {
+    clone.orbitals[idx] = enriched;
+  }
+  return clone;
+}
+function replaceTrait(orb, orbName, traitName, enriched) {
+  const clone = deepCloneOrb(orb);
+  const orbital = clone.orbitals.find(
+    (o) => o.name === orbName
+  );
+  if (!orbital) return clone;
+  const traits = orbital.traits;
+  const idx = traits.findIndex((t) => {
+    if (typeof t === "string") return t === traitName;
+    if ("ref" in t) return t.ref === traitName;
+    return t.name === traitName;
+  });
+  if (idx >= 0) {
+    traits[idx] = enriched;
+  }
+  return clone;
+}
+function replaceTransition(orb, orbName, traitName, from, event, enriched) {
+  const clone = deepCloneOrb(orb);
+  const orbital = clone.orbitals.find(
+    (o) => o.name === orbName
+  );
+  if (!orbital) return clone;
+  const trait = orbital.traits.find((t) => {
+    if (typeof t === "string") return false;
+    if ("ref" in t) return false;
+    return t.name === traitName;
+  });
+  if (!trait?.stateMachine) return clone;
+  const idx = trait.stateMachine.transitions.findIndex(
+    (t) => t.from === from && t.event === event
+  );
+  if (idx >= 0) {
+    trait.stateMachine.transitions[idx] = enriched;
+  }
+  return clone;
+}
+
+// src/gates/gate1-orbital.ts
+function parseGate1Response(raw, original) {
+  const parsed = extractJsonFromText(raw);
+  if (!parsed) {
+    throw new Error(`Gate 1: failed to parse JSON from response: ${raw.slice(0, 200)}`);
+  }
+  const obj = JSON.parse(parsed);
+  const entityRaw = obj.entity || {};
+  const entityName = String(
+    entityRaw.name || original.entity.name
+  );
+  const fieldsRaw = Array.isArray(entityRaw.fields) ? entityRaw.fields : [];
+  const entity = {
+    name: entityName,
+    persistence: entityRaw.persistence || "runtime",
+    ...entityRaw.collection ? { collection: String(entityRaw.collection) } : {},
+    fields: fieldsRaw.length > 0 ? fieldsRaw.map((f) => ({
+      name: String(f.name || ""),
+      type: f.type || "string",
+      ...f.required ? { required: true } : {},
+      ...f.default !== void 0 ? { default: f.default } : {}
+    })) : [{ name: "id", type: "string", required: true }]
+  };
+  const traitsRaw = Array.isArray(obj.traits) ? obj.traits : [];
+  const traits = traitsRaw.map((t) => ({
+    name: String(t.name || ""),
+    linkedEntity: String(t.linkedEntity || entityName),
+    category: "interaction",
+    ...Array.isArray(t.emits) && t.emits.length > 0 ? { emits: t.emits.map((e) => typeof e === "string" ? { event: e } : e) } : {},
+    ...Array.isArray(t.listens) && t.listens.length > 0 ? { listens: t.listens.map((l) => typeof l === "string" ? { event: l, triggers: l } : l) } : {},
+    stateMachine: {
+      states: [{ name: "idle", isInitial: true }],
+      events: [],
+      transitions: []
+    }
+  }));
+  const traitNames = traits.map((t) => t.name);
+  const defaultTraitRefs = traitNames.map((n) => ({ ref: n }));
+  const pagesRaw = Array.isArray(obj.pages) ? obj.pages : [];
+  const pages = pagesRaw.map((p) => ({
+    name: String(p.name || p.label || ""),
+    path: String(p.path || p.route || "/"),
+    ...p.isInitial ? { isInitial: true } : {},
+    traits: Array.isArray(p.traits) ? p.traits : defaultTraitRefs
+  }));
+  return {
+    name: String(obj.name || original.name),
+    entity,
+    traits,
+    pages
+  };
+}
+async function runGate1(client, orb, opts = {}, behaviorData) {
+  const systemPrompt = buildGate1SystemPrompt();
+  const allOrbitals = orb.orbitals;
+  let result = orb;
+  for (const orbital of allOrbitals) {
+    const guidedOrbital = opts.goldenOrb?.orbitals.find(
+      (o) => o.name === orbital.name
+    );
+    const userPrompt = buildGate1UserPrompt(
+      orbital,
+      allOrbitals,
+      guidedOrbital
+    );
+    const raw = await client.callRaw({
+      systemPrompt,
+      userPrompt,
+      maxTokens: opts.maxTokens ?? 4096
+    });
+    const enriched = parseGate1Response(raw, orbital);
+    result = replaceOrbital(result, orbital.name, enriched);
+  }
+  return result;
+}
+function parseGate2Response(raw, original) {
+  const parsed = extractJsonFromText(raw);
+  if (!parsed) {
+    console.warn(`Gate 2: no JSON found, returning trait as-is`);
+    return original;
+  }
+  let obj;
+  try {
+    obj = JSON.parse(parsed);
+  } catch {
+    console.warn(`Gate 2: malformed JSON, returning trait as-is`);
+    return original;
+  }
+  const statesRaw = Array.isArray(obj.states) ? obj.states : [];
+  const eventsRaw = Array.isArray(obj.events) ? obj.events : [];
+  const transitionsRaw = Array.isArray(obj.transitions) ? obj.transitions : [];
+  const smRaw = obj.stateMachine;
+  const states = (smRaw && Array.isArray(smRaw.states) ? smRaw.states : statesRaw).map((s) => ({
+    name: String(s.name || ""),
+    ...s.isInitial ? { isInitial: true } : {}
+  }));
+  const events = (smRaw && Array.isArray(smRaw.events) ? smRaw.events : eventsRaw).map((e) => ({
+    key: String(e.key || ""),
+    name: String(e.name || e.key || ""),
+    ...Array.isArray(e.payloadSchema) ? { payloadSchema: e.payloadSchema } : {}
+  }));
+  const transitions = (smRaw && Array.isArray(smRaw.transitions) ? smRaw.transitions : transitionsRaw).map((t) => ({
+    from: String(t.from || ""),
+    event: String(t.event || ""),
+    to: String(t.to || ""),
+    effects: []
+  }));
+  const stateMachine = { states, events, transitions };
+  const validPresentations = /* @__PURE__ */ new Set(["modal", "drawer", "popover", "inline", "confirm-dialog"]);
+  const uiRaw = obj.ui || smRaw?.ui;
+  const ui = uiRaw ? Object.fromEntries(
+    Object.entries(uiRaw).map(([stateName, binding]) => {
+      const pres = String(binding.presentation || "inline");
+      return [
+        stateName,
+        {
+          presentation: validPresentations.has(pres) ? pres : "inline",
+          content: binding.content || {}
+        }
+      ];
+    })
+  ) : void 0;
+  return {
+    ...original,
+    name: String(obj.name || original.name),
+    stateMachine,
+    ...ui ? { ui } : {}
+  };
+}
+async function runGate2(client, orb, opts = {}, behaviorData) {
+  const systemPrompt = buildGate2SystemPrompt();
+  let result = orb;
+  for (const orbital of orb.orbitals) {
+    const entity = orbital.entity;
+    for (const traitRef of orbital.traits) {
+      if (typeof traitRef === "string" || "ref" in traitRef) continue;
+      const trait = traitRef;
+      const guidedTrait = findGuidedTrait(opts.goldenOrb, trait.name);
+      const userPrompt = buildGate2UserPrompt(
+        trait,
+        entity,
+        orbital.description || "",
+        guidedTrait
+      );
+      const raw = await client.callRaw({
+        systemPrompt,
+        userPrompt,
+        maxTokens: opts.maxTokens ?? 4096
+      });
+      const enriched = parseGate2Response(raw, trait);
+      result = replaceTrait(result, orbital.name, trait.name, enriched);
+    }
+  }
+  return result;
+}
+function findGuidedTrait(goldenOrb, traitName) {
+  if (!goldenOrb) return void 0;
+  for (const orbital of goldenOrb.orbitals) {
+    for (const t of orbital.traits) {
+      if (typeof t === "string" || "ref" in t) continue;
+      if (t.name === traitName) return t;
+    }
+  }
+  return void 0;
+}
+function parseGate3Response(raw, original) {
+  const parsed = extractJsonFromText(raw);
+  if (!parsed) {
+    console.warn(`Gate 3: no JSON found, returning transition as-is`);
+    return original;
+  }
+  let obj;
+  try {
+    obj = JSON.parse(parsed);
+  } catch {
+    console.warn(`Gate 3: malformed JSON, returning transition as-is`);
+    return original;
+  }
+  const guard = Array.isArray(obj.guard) ? obj.guard : void 0;
+  const effectsRaw = Array.isArray(obj.effects) ? obj.effects : [];
+  const effects = effectsRaw.filter(
+    (e) => Array.isArray(e) && e.length >= 2
+  );
+  return {
+    from: String(obj.from || original.from),
+    event: String(obj.event || original.event),
+    to: String(obj.to || original.to),
+    ...guard ? { guard } : {},
+    effects
+  };
+}
+async function runGate3(client, orb, opts = {}, _behaviorData) {
+  const systemPrompt = buildGate3SystemPrompt();
+  let result = orb;
+  for (const orbital of orb.orbitals) {
+    const entity = orbital.entity;
+    for (const traitRef of orbital.traits) {
+      if (typeof traitRef === "string" || "ref" in traitRef) continue;
+      const trait = traitRef;
+      if (!trait.stateMachine) continue;
+      for (const transition of trait.stateMachine.transitions) {
+        const guidedTransition = findGuidedTransition(
+          opts.goldenOrb,
+          trait.name,
+          transition.from,
+          transition.event
+        );
+        const userPrompt = buildGate3UserPrompt(
+          transition,
+          entity,
+          trait.stateMachine,
+          guidedTransition
+        );
+        const raw = await client.callRaw({
+          systemPrompt,
+          userPrompt,
+          maxTokens: opts.maxTokens ?? 4096
+        });
+        const enriched = parseGate3Response(raw, transition);
+        result = replaceTransition(
+          result,
+          orbital.name,
+          trait.name,
+          transition.from,
+          transition.event,
+          enriched
+        );
+      }
+    }
+  }
+  return result;
+}
+function findGuidedTransition(goldenOrb, traitName, from, event) {
+  if (!goldenOrb) return void 0;
+  for (const orbital of goldenOrb.orbitals) {
+    for (const t of orbital.traits) {
+      if (typeof t === "string" || "ref" in t) continue;
+      if (t.name !== traitName) continue;
+      const sm = t.stateMachine;
+      if (!sm) continue;
+      const found = sm.transitions.find(
+        (tr) => tr.from === from && tr.event === event
+      );
+      if (found) return found;
+    }
+  }
+  return void 0;
+}
+function buildSlotContext(sm, traitUi) {
+  const slots = {};
+  for (const state of sm.states) {
+    const binding = traitUi?.[state.name];
+    slots[state.name] = binding?.presentation === "modal" ? "modal" : "main";
+  }
+  return slots;
+}
+function parseGate4Response(raw) {
+  const parsed = extractJsonFromText(raw);
+  if (!parsed) {
+    console.warn("Gate 4: no JSON found in response, using fallback render-ui");
+    return [{ slot: "main", tree: { type: "typography", variant: "body", content: "Loading..." } }];
+  }
+  let obj;
+  try {
+    obj = JSON.parse(parsed);
+  } catch {
+    console.warn(`Gate 4: malformed JSON, using fallback render-ui: ${parsed.slice(0, 100)}`);
+    return [{ slot: "main", tree: { type: "typography", variant: "body", content: "Loading..." } }];
+  }
+  const renderEffectsRaw = Array.isArray(obj.renderEffects) ? obj.renderEffects : [];
+  return renderEffectsRaw.map((r) => ({
+    slot: String(r.slot || "main"),
+    tree: r.tree === null ? null : r.tree || { type: "typography", variant: "body", content: "Empty" }
+  }));
+}
+async function runGate4(client, orb, opts = {}, _behaviorData) {
+  const systemPrompt = buildGate4SystemPrompt();
+  let result = orb;
+  for (const orbital of orb.orbitals) {
+    const entity = orbital.entity;
+    for (const traitRef of orbital.traits) {
+      if (typeof traitRef === "string" || "ref" in traitRef) continue;
+      const trait = traitRef;
+      if (!trait.stateMachine) continue;
+      const traitUi = trait.ui;
+      const stateSlots = buildSlotContext(trait.stateMachine, traitUi);
+      for (const transition of trait.stateMachine.transitions) {
+        const fromSlot = stateSlots[transition.from] || "main";
+        const toSlot = stateSlots[transition.to] || "main";
+        const exitsModal = fromSlot === "modal" && toSlot === "main";
+        const slotContext = { stateSlots, exitsModal };
+        const guidedRenderEffects = findGuidedRenderEffects(
+          opts.goldenOrb,
+          trait.name,
+          transition.from,
+          transition.event
+        );
+        const userPrompt = buildGate4UserPrompt(
+          transition,
+          entity,
+          transition.to,
+          trait.stateMachine,
+          slotContext,
+          guidedRenderEffects
+        );
+        const raw = await client.callRaw({
+          systemPrompt,
+          userPrompt,
+          maxTokens: (opts.maxTokens ?? 4096) * 2
+        });
+        const renderEffects = parseGate4Response(raw);
+        const existingEffects = [...transition.effects || []];
+        for (const re of renderEffects) {
+          existingEffects.push(["render-ui", re.slot, re.tree]);
+        }
+        if (exitsModal) {
+          const hasModalNull = existingEffects.some(
+            (e) => Array.isArray(e) && e[0] === "render-ui" && e[1] === "modal" && e[2] === null
+          );
+          if (!hasModalNull) {
+            existingEffects.unshift(["render-ui", "modal", null]);
+          }
+        }
+        const enriched = {
+          ...transition,
+          effects: existingEffects
+        };
+        result = replaceTransition(
+          result,
+          orbital.name,
+          trait.name,
+          transition.from,
+          transition.event,
+          enriched
+        );
+      }
+    }
+  }
+  return result;
+}
+function findGuidedRenderEffects(goldenOrb, traitName, from, event) {
+  if (!goldenOrb) return void 0;
+  for (const orbital of goldenOrb.orbitals) {
+    for (const t of orbital.traits) {
+      if (typeof t === "string" || "ref" in t) continue;
+      if (t.name !== traitName) continue;
+      const sm = t.stateMachine;
+      if (!sm) continue;
+      const tr = sm.transitions.find(
+        (tr2) => tr2.from === from && tr2.event === event
+      );
+      if (!tr?.effects) continue;
+      const renderEffects = [];
+      for (const eff of tr.effects) {
+        if (Array.isArray(eff) && eff[0] === "render-ui") {
+          renderEffects.push({
+            slot: String(eff[1] || "main"),
+            tree: eff[2] || {}
+          });
+        }
+      }
+      if (renderEffects.length > 0) return renderEffects;
+    }
+  }
+  return void 0;
+}
+
+// src/gates/orchestrator.ts
+function createClientForProvider(config) {
+  const opts = {
+    ...config.model ? { model: config.model } : {},
+    ...config.temperature !== void 0 ? { temperature: config.temperature } : {}
+  };
+  switch (config.provider) {
+    case "deepseek":
+      return createDeepSeekClient(opts);
+    case "zhipu":
+      return createOpenRouterClient({ model: "z-ai/glm-4.7", ...opts });
+    default: {
+      const _exhaustive = config.provider;
+      throw new Error(`Unknown provider: ${_exhaustive}`);
+    }
+  }
+}
+function timeMs() {
+  return performance.now();
+}
+async function runGatePipeline(prompt, config, behaviorData, goldenOrb) {
+  const client = createClientForProvider(config);
+  const maxTokens = config.maxTokens || 4096;
+  const pipelineStart = timeMs();
+  const opts = {
+    maxTokens,
+    goldenOrb,
+    workDir: config.workDir
+  };
+  const g0Start = timeMs();
+  const orbAfterGate0 = await runGate0(client, prompt, opts, behaviorData);
+  const g0Ms = timeMs() - g0Start;
+  console.log(`[Gate 0] ${orbAfterGate0.name}: ${orbAfterGate0.orbitals.length} orbital(s) (${g0Ms.toFixed(0)}ms)`);
+  maybeValidate(config, orbAfterGate0, 0);
+  if (config.mode === "guided" && !goldenOrb) {
+    const g05Start = timeMs();
+    const matchResult = await runGate05(client, prompt, orbAfterGate0, opts);
+    const g05Ms = timeMs() - g05Start;
+    if (matchResult.goldenOrb) {
+      opts.goldenOrb = matchResult.goldenOrb;
+      console.log(`[Gate 0.5] Matched: ${matchResult.matchedName} (${g05Ms.toFixed(0)}ms)`);
+    } else {
+      console.log(`[Gate 0.5] No match, continuing in pure mode (${g05Ms.toFixed(0)}ms)`);
+    }
+  }
+  const g1Start = timeMs();
+  const orbAfterGate1 = await runGate1(client, orbAfterGate0, opts);
+  const g1Ms = timeMs() - g1Start;
+  console.log(`[Gate 1] Enriched ${orbAfterGate1.orbitals.length} orbital(s) (${g1Ms.toFixed(0)}ms)`);
+  maybeValidate(config, orbAfterGate1, 1);
+  const g2Start = timeMs();
+  const orbAfterGate2 = await runGate2(client, orbAfterGate1, opts);
+  const g2Ms = timeMs() - g2Start;
+  console.log(`[Gate 2] State machines filled (${g2Ms.toFixed(0)}ms)`);
+  maybeValidate(config, orbAfterGate2, 2);
+  const g3Start = timeMs();
+  const orbAfterGate3 = await runGate3(client, orbAfterGate2, opts);
+  const g3Ms = timeMs() - g3Start;
+  console.log(`[Gate 3] Guards + effects filled (${g3Ms.toFixed(0)}ms)`);
+  maybeValidate(config, orbAfterGate3, 3);
+  const g4Start = timeMs();
+  const orbFinal = await runGate4(client, orbAfterGate3, opts);
+  const g4Ms = timeMs() - g4Start;
+  console.log(`[Gate 4] Render-ui appended (${g4Ms.toFixed(0)}ms)`);
+  fs4.mkdirSync(config.workDir, { recursive: true });
+  const validation = validateWithOrbitalCLI(orbFinal, config.workDir);
+  console.log(`[Validate] valid=${validation.valid}, errors=${(validation.errors || []).length}`);
+  let verify;
+  if (config.verify) {
+    verify = await runVerify(orbFinal, config);
+  }
+  const totalMs = timeMs() - pipelineStart;
+  console.log(`[Pipeline] Total: ${(totalMs / 1e3).toFixed(1)}s`);
+  const timings = {
+    gate0Ms: g0Ms,
+    gate1Ms: [g1Ms],
+    gate2Ms: [g2Ms],
+    gate3Ms: [g3Ms],
+    gate4Ms: [g4Ms],
+    totalMs
+  };
+  return {
+    config,
+    orbAfterGate0,
+    orbAfterGate1,
+    orbAfterGate2,
+    orbAfterGate3,
+    orbFinal,
+    validation: {
+      valid: validation.valid ?? false,
+      errors: validation.errors ?? []
+    },
+    verify,
+    timings
+  };
+}
+async function runVerify(orb, config) {
+  const tmpDir = path4.join(config.workDir, "gate-verify");
+  fs4.mkdirSync(tmpDir, { recursive: true });
+  const orbPath = path4.join(tmpDir, `${orb.name || "generated"}.orb`);
+  fs4.writeFileSync(orbPath, JSON.stringify(orb, null, 2));
+  const verifyApiPath = path4.resolve(
+    path4.dirname(new URL(import.meta.url).pathname),
+    "../../../../tools/orbital-verify-unified/src/api.js"
+  );
+  const { verifyApp } = await import(verifyApiPath);
+  console.log(`[Verify] Starting orbital-verify on ${orbPath}`);
+  const result = await verifyApp({
+    orbPath,
+    headed: config.verifyHeaded ?? false,
+    screenshots: config.verifyScreenshots ?? false
+  });
+  console.log(
+    `[Verify] ${result.totalPassed}/${result.totalChecks} passed, ${result.totalFailed} failed` + (result.coverage ? `, coverage=${(result.coverage.ratio * 100).toFixed(0)}%` : "")
+  );
+  return {
+    totalPassed: result.totalPassed,
+    totalFailed: result.totalFailed,
+    totalChecks: result.totalChecks,
+    coverage: result.coverage ? {
+      ratio: result.coverage.ratio,
+      coveredItems: result.coverage.coveredItems,
+      totalItems: result.coverage.totalItems
+    } : void 0,
+    phases: result.phases.map((p) => ({
+      phase: p.phase,
+      name: p.name,
+      passed: p.passed,
+      failed: p.failed,
+      checks: p.checks
+    }))
+  };
+}
+function maybeValidate(config, orb, gate) {
+  if (!config.validateAfterEachGate) return;
+  const result = validateWithOrbitalCLI(orb, config.workDir);
+  if (!result.valid) {
+    console.warn(
+      `[Gate ${gate} validate] ${result.errors.length} error(s): ` + result.errors.slice(0, 3).map((e) => e.message).join("; ")
+    );
+  }
+}
+
+// src/gates/index.ts
+init_gate05_behavior_match();
+
+// src/gates/behavior-extract.ts
+function asArray(val) {
+  if (!val) return [];
+  return Array.isArray(val) ? val : [val];
+}
+function getOrbitals(behavior) {
+  return asArray(behavior.orbitals);
+}
+function getTraitsFromOrbital(orbital) {
+  return asArray(orbital.traits);
+}
+function getStateMachine(trait) {
+  return trait.stateMachine || null;
+}
+function getStates(sm) {
+  const states = asArray(sm.states);
+  return states.map((s) => ({ name: String(s.name || "") }));
+}
+function getEvents(sm) {
+  const events = asArray(sm.events);
+  return events.map((e) => ({ key: String(e.key || "") }));
+}
+function getTransitions(sm) {
+  const transitions = asArray(sm.transitions);
+  return transitions.map((t) => ({
+    from: String(t.from || ""),
+    event: String(t.event || ""),
+    to: String(t.to || ""),
+    guard: t.guard,
+    effects: asArray(t.effects)
+  }));
+}
+function getPagesFromOrbital(orbital) {
+  return asArray(orbital.pages);
+}
+function isRenderUiEffect(effect) {
+  return Array.isArray(effect) && effect[0] === "render-ui";
+}
+function extractRenderEffects(effects) {
+  const results = [];
+  for (const eff of effects) {
+    if (isRenderUiEffect(eff)) {
+      const arr = eff;
+      const slot = String(arr[1] || "main");
+      const tree = arr[2] || {};
+      results.push({ slot, tree });
+    }
+  }
+  return results;
+}
+function extractNonRenderEffects(effects) {
+  return effects.filter((eff) => !isRenderUiEffect(eff));
+}
+function extractBehaviorGateData(behavior) {
+  const orbitals = getOrbitals(behavior);
+  const entityNames = [];
+  const traitNames = [];
+  for (const orbital of orbitals) {
+    const entity = orbital.entity;
+    if (entity?.name) entityNames.push(String(entity.name));
+    for (const trait of getTraitsFromOrbital(orbital)) {
+      if (trait.name) traitNames.push(String(trait.name));
+    }
+  }
+  const appLevel = {
+    orbitalCount: orbitals.length,
+    entityNames,
+    traitNames
+  };
+  const orbitalLevels = orbitals.map((orbital) => {
+    const entity = orbital.entity || {};
+    const traits = getTraitsFromOrbital(orbital);
+    const pages = getPagesFromOrbital(orbital);
+    return {
+      orbitalName: String(orbital.name || ""),
+      entity,
+      traitNames: traits.map((t) => String(t.name || "")),
+      pages
+    };
+  });
+  const traitLevels = [];
+  for (const orbital of orbitals) {
+    for (const trait of getTraitsFromOrbital(orbital)) {
+      const sm = getStateMachine(trait);
+      if (!sm) continue;
+      const states = getStates(sm);
+      const events = getEvents(sm);
+      const transitions = getTransitions(sm);
+      traitLevels.push({
+        traitName: String(trait.name || ""),
+        states: states.map((s) => s.name),
+        events: events.map((e) => e.key),
+        transitionEdges: transitions.map((t) => ({
+          from: t.from,
+          event: t.event,
+          to: t.to
+        }))
+      });
+    }
+  }
+  const transitionLevels = [];
+  for (const orbital of orbitals) {
+    for (const trait of getTraitsFromOrbital(orbital)) {
+      const sm = getStateMachine(trait);
+      if (!sm) continue;
+      for (const transition of getTransitions(sm)) {
+        const effects = transition.effects || [];
+        transitionLevels.push({
+          from: transition.from,
+          event: transition.event,
+          to: transition.to,
+          guard: transition.guard || null,
+          nonRenderEffects: extractNonRenderEffects(effects)
+        });
+      }
+    }
+  }
+  const renderUiLevels = [];
+  for (const orbital of orbitals) {
+    for (const trait of getTraitsFromOrbital(orbital)) {
+      const sm = getStateMachine(trait);
+      if (!sm) continue;
+      for (const transition of getTransitions(sm)) {
+        const effects = transition.effects || [];
+        const renderEffects = extractRenderEffects(effects);
+        if (renderEffects.length > 0) {
+          renderUiLevels.push({
+            from: transition.from,
+            event: transition.event,
+            to: transition.to,
+            renderEffects
+          });
+        }
+      }
+    }
+  }
+  return {
+    appLevel,
+    orbitalLevels,
+    traitLevels,
+    transitionLevels,
+    renderUiLevels
+  };
+}
+function getTraitGateData(data, traitName) {
+  return data.traitLevels.find((t) => t.traitName === traitName);
+}
+function getTransitionGateData(data, from, event) {
+  return {
+    transition: data.transitionLevels.find((t) => t.from === from && t.event === event),
+    renderUi: data.renderUiLevels.find((t) => t.from === from && t.event === event)
+  };
+}
+
+// src/gates/scoring.ts
+function jaccard(a, b) {
+  if (a.size === 0 && b.size === 0) return 1;
+  const intersection = new Set([...a].filter((x) => b.has(x)));
+  const union = /* @__PURE__ */ new Set([...a, ...b]);
+  return intersection.size / union.size;
+}
+function symmetricDifferenceNormalized(a, b) {
+  if (a.size === 0 && b.size === 0) return 1;
+  const symDiff = /* @__PURE__ */ new Set([
+    ...[...a].filter((x) => !b.has(x)),
+    ...[...b].filter((x) => !a.has(x))
+  ]);
+  const union = /* @__PURE__ */ new Set([...a, ...b]);
+  return 1 - symDiff.size / union.size;
+}
+function coverageRatio(produced, golden) {
+  if (golden.size === 0) return 1;
+  const covered = [...golden].filter((x) => produced.has(x));
+  return covered.length / golden.size;
+}
+function scoreGate0(orb, golden) {
+  const orbitals = orb.orbitals;
+  const countDiff = Math.abs(orbitals.length - golden.appLevel.orbitalCount);
+  const countScore = countDiff === 0 ? 1 : countDiff === 1 ? 0.5 : 0;
+  const producedEntities = new Set(
+    orbitals.map((o) => String(o.entity.name).toLowerCase())
+  );
+  const goldenEntities = new Set(golden.appLevel.entityNames.map((n) => n.toLowerCase()));
+  const entityJaccard = jaccard(producedEntities, goldenEntities);
+  const score = countScore * 0.4 + entityJaccard * 0.6;
+  return {
+    gate: 0,
+    score,
+    details: { countScore, entityJaccard }
+  };
+}
+function scoreGate1(orb, golden) {
+  const orbitals = orb.orbitals;
+  if (orbitals.length === 0) {
+    return { gate: 1, score: 0, details: { fieldJaccard: 0, persistenceMatch: 0 } };
+  }
+  const goldenOrbital = golden.orbitalLevels[0];
+  if (!goldenOrbital) {
+    return { gate: 1, score: 0, details: { fieldJaccard: 0, persistenceMatch: 0 } };
+  }
+  const entity = orbitals[0].entity;
+  const producedFields = new Set(entity.fields.map((f) => f.name.toLowerCase()));
+  const goldenEntity = goldenOrbital.entity;
+  const goldenFields = new Set(
+    Array.isArray(goldenEntity.fields) ? goldenEntity.fields.map((f) => f.name.toLowerCase()) : []
+  );
+  const fieldJaccard = jaccard(producedFields, goldenFields);
+  const goldenPersistence = String(goldenEntity.persistence || "runtime");
+  const persistenceMatch = entity.persistence === goldenPersistence ? 1 : 0;
+  const score = fieldJaccard * 0.7 + persistenceMatch * 0.3;
+  return {
+    gate: 1,
+    score,
+    details: { fieldJaccard, persistenceMatch }
+  };
+}
+function scoreGate2(orb, golden) {
+  const traits = extractAllTraits(orb);
+  if (traits.length === 0 || golden.traitLevels.length === 0) {
+    return { gate: 2, score: 0, details: { stateSymDiff: 0, eventJaccard: 0 } };
+  }
+  const trait = traits.find((t) => t.stateMachine) || traits[0];
+  const goldenTrait = golden.traitLevels.find(
+    (t) => t.traitName.toLowerCase() === trait.name.toLowerCase()
+  ) || golden.traitLevels[0];
+  if (!goldenTrait || !trait.stateMachine) {
+    return { gate: 2, score: 0, details: { stateSymDiff: 0, eventJaccard: 0 } };
+  }
+  const producedStates = new Set(trait.stateMachine.states.map((s) => s.name.toLowerCase()));
+  const goldenStates = new Set(goldenTrait.states.map((s) => s.toLowerCase()));
+  const stateSymDiff = symmetricDifferenceNormalized(producedStates, goldenStates);
+  const producedEvents = new Set(trait.stateMachine.events.map((e) => e.key));
+  const goldenEvents = new Set(goldenTrait.events);
+  const eventJaccard = jaccard(producedEvents, goldenEvents);
+  const score = stateSymDiff * 0.5 + eventJaccard * 0.5;
+  return {
+    gate: 2,
+    score,
+    details: { stateSymDiff, eventJaccard }
+  };
+}
+function scoreGate3(orb, golden) {
+  const transitions = extractAllTransitions(orb);
+  if (transitions.length === 0) {
+    return { gate: 3, score: 0.5, details: { effectCoverage: 0.5, guardMatch: 0.5 } };
+  }
+  let totalEffectCoverage = 0;
+  let totalGuardMatch = 0;
+  let count = 0;
+  for (const transition of transitions) {
+    const goldenTransition = golden.transitionLevels.find(
+      (t) => t.from === transition.from && t.event === transition.event
+    );
+    if (!goldenTransition) {
+      totalEffectCoverage += 0.5;
+      totalGuardMatch += 0.5;
+      count++;
+      continue;
+    }
+    const producedTypes = new Set(
+      (transition.effects || []).filter((e) => Array.isArray(e)).map((e) => String(e[0])).filter((t) => t !== "render-ui")
+    );
+    const goldenTypes = new Set(
+      goldenTransition.nonRenderEffects.filter((e) => Array.isArray(e)).map((e) => String(e[0]))
+    );
+    totalEffectCoverage += coverageRatio(producedTypes, goldenTypes);
+    const hasGuard = !!transition.guard;
+    const goldenHasGuard = !!goldenTransition.guard;
+    totalGuardMatch += hasGuard === goldenHasGuard ? 1 : 0;
+    count++;
+  }
+  const effectCoverage = count > 0 ? totalEffectCoverage / count : 0.5;
+  const guardMatch = count > 0 ? totalGuardMatch / count : 0.5;
+  const score = effectCoverage * 0.7 + guardMatch * 0.3;
+  return {
+    gate: 3,
+    score,
+    details: { effectCoverage, guardMatch }
+  };
+}
+function scoreGate4(orb, golden) {
+  const transitions = extractAllTransitions(orb);
+  if (transitions.length === 0 || golden.renderUiLevels.length === 0) {
+    return { gate: 4, score: 0.5, details: { typeRecall: 0.5, nodeRatio: 0.5 } };
+  }
+  let totalTypeRecall = 0;
+  let totalNodeRatio = 0;
+  let count = 0;
+  for (const transition of transitions) {
+    const goldenRender = golden.renderUiLevels.find(
+      (r) => r.from === transition.from && r.event === transition.event
+    );
+    if (!goldenRender) continue;
+    const renderEffects = (transition.effects || []).filter((e) => Array.isArray(e) && e[0] === "render-ui").map((e) => {
+      const arr = e;
+      return { slot: String(arr[1]), tree: arr[2] || {} };
+    });
+    const producedTypes = /* @__PURE__ */ new Set();
+    let producedNodes = 0;
+    for (const re of renderEffects) {
+      for (const t of collectTypes(re.tree)) producedTypes.add(t);
+      producedNodes += countNodes(re.tree);
+    }
+    const goldenTypes = /* @__PURE__ */ new Set();
+    let goldenNodes = 0;
+    for (const re of goldenRender.renderEffects) {
+      for (const t of collectTypes(re.tree)) goldenTypes.add(t);
+      goldenNodes += countNodes(re.tree);
+    }
+    totalTypeRecall += coverageRatio(producedTypes, goldenTypes);
+    totalNodeRatio += goldenNodes > 0 ? Math.min(producedNodes / goldenNodes, goldenNodes / Math.max(producedNodes, 1)) : producedNodes === 0 ? 1 : 0;
+    count++;
+  }
+  const typeRecall = count > 0 ? totalTypeRecall / count : 0.5;
+  const nodeRatio = count > 0 ? totalNodeRatio / count : 0.5;
+  const score = typeRecall * 0.6 + nodeRatio * 0.4;
+  return {
+    gate: 4,
+    score,
+    details: { typeRecall, nodeRatio }
+  };
+}
+var GATE_WEIGHTS = [0.1, 0.15, 0.25, 0.2, 0.3];
+function scoreOverall(gateScores, provider, mode, behaviorName) {
+  let overall = 0;
+  for (const gs of gateScores) {
+    const weight = GATE_WEIGHTS[gs.gate] ?? 0;
+    overall += gs.score * weight;
+  }
+  return {
+    overall,
+    gates: gateScores,
+    provider,
+    mode,
+    behaviorName
+  };
+}
+function extractAllTraits(orb) {
+  const traits = [];
+  for (const orbital of orb.orbitals) {
+    for (const t of orbital.traits) {
+      if (typeof t === "string" || "ref" in t) continue;
+      traits.push(t);
+    }
+  }
+  return traits;
+}
+function extractAllTransitions(orb) {
+  const transitions = [];
+  for (const trait of extractAllTraits(orb)) {
+    if (!trait.stateMachine) continue;
+    transitions.push(...trait.stateMachine.transitions);
+  }
+  return transitions;
+}
+function collectTypes(tree) {
+  const types = /* @__PURE__ */ new Set();
+  if (tree.type) types.add(String(tree.type));
+  const children = tree.children;
+  if (Array.isArray(children)) {
+    for (const child of children) {
+      for (const t of collectTypes(child)) types.add(t);
+    }
+  }
+  return types;
+}
+function countNodes(tree) {
+  let count = 1;
+  const children = tree.children;
+  if (Array.isArray(children)) {
+    for (const child of children) count += countNodes(child);
+  }
+  return count;
+}
+init_gate05_behavior_match();
+function createDecomposeAppTool() {
+  return tool(
+    async (input) => {
+      const client = createDeepSeekClient();
+      const orb = await runGate0(client, input.prompt);
+      return {
+        appName: orb.name,
+        orbitals: orb.orbitals.map((o) => ({
+          name: o.name,
+          entityName: o.entity.name,
+          traitNames: o.traits.filter((t) => typeof t !== "string" && !("ref" in t)).map((t) => t.name),
+          pageCount: o.pages?.length ?? 0
+        })),
+        shellOrb: orb
+      };
+    },
+    {
+      name: "decompose_app",
+      description: "Decompose a natural language prompt into an orbital plan. Returns the app name, orbital list with entity names, and a shell .orb schema.",
+      schema: z.object({
+        prompt: z.string().describe("Natural language application description")
+      })
+    }
+  );
+}
+function createMatchBehaviorTool() {
+  return tool(
+    async (input) => {
+      const client = createDeepSeekClient();
+      const shellOrb = {
+        orbitals: [{
+          name: input.orbitalName,
+          entity: { name: input.entityName, fields: [{ name: "id", type: "string" }] },
+          traits: [],
+          pages: []
+        }]
+      };
+      const result = await runGate05(client, input.description, shellOrb);
+      return {
+        matched: result.matchedName !== null,
+        behaviorName: result.matchedName,
+        hasGoldenOrb: result.goldenOrb !== null
+      };
+    },
+    {
+      name: "match_behavior",
+      description: "Find the best matching golden behavior from 107 standard behaviors. Returns the match name and whether a golden .orb reference was loaded.",
+      schema: z.object({
+        description: z.string().describe("Description of the orbital to match"),
+        orbitalName: z.string().describe("Name of the orbital"),
+        entityName: z.string().describe("Name of the entity")
+      })
+    }
+  );
+}
+function createBuildOrbitalTool(workDir) {
+  return tool(
+    async (input) => {
+      const client = createDeepSeekClient();
+      const orbitalsDir = path4.join(workDir, ".orbitals");
+      fs4.mkdirSync(orbitalsDir, { recursive: true });
+      let shellOrb;
+      try {
+        shellOrb = JSON.parse(input.shellOrb);
+      } catch {
+        return { success: false, error: "Invalid shellOrb JSON" };
+      }
+      let goldenOrb;
+      if (input.goldenBehavior) {
+        const { loadGoldenOrbByName } = await Promise.resolve().then(() => (init_gate05_behavior_match(), gate05_behavior_match_exports));
+        goldenOrb = loadGoldenOrbByName(input.goldenBehavior) ?? void 0;
+      }
+      const opts = {
+        goldenOrb
+      };
+      input.feedback;
+      try {
+        console.log(`[build_orbital] Gate 1: enriching entity for ${input.orbitalName}`);
+        let orb = await runGate1(client, shellOrb, opts);
+        console.log(`[build_orbital] Gate 2: filling state machines`);
+        orb = await runGate2(client, orb, opts);
+        console.log(`[build_orbital] Gate 3: adding effects`);
+        orb = await runGate3(client, orb, opts);
+        console.log(`[build_orbital] Gate 4: adding render-ui`);
+        orb = await runGate4(client, orb, opts);
+        for (const orbital of orb.orbitals) {
+          const safeName = orbital.name.replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
+          const orbitalPath = path4.join(orbitalsDir, `${safeName}.json`);
+          fs4.writeFileSync(orbitalPath, JSON.stringify(orbital, null, 2));
+          console.log(`[build_orbital] Written: ${orbitalPath}`);
+        }
+        fs4.mkdirSync(workDir, { recursive: true });
+        const validation = validateWithOrbitalCLI(orb, workDir);
+        return {
+          success: true,
+          orbitalName: input.orbitalName,
+          orbitalsWritten: orb.orbitals.length,
+          validation: {
+            valid: validation.valid,
+            errorCount: validation.errors?.length ?? 0,
+            errors: (validation.errors ?? []).slice(0, 5).map((e) => e.message)
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          orbitalName: input.orbitalName,
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    },
+    {
+      name: "build_orbital",
+      description: "Build one orbital by running the gate pipeline (entity -> state machine -> effects -> render-ui). Writes the result to .orbitals/ for finish_task to collect. Optionally takes a golden behavior name for guided mode and feedback for retry.",
+      schema: z.object({
+        orbitalName: z.string().describe("Name of the orbital to build"),
+        shellOrb: z.string().describe("JSON string of the shell OrbitalSchema from decompose_app"),
+        goldenBehavior: z.string().optional().describe('Golden behavior name from match_behavior (e.g. "std-cart")'),
+        feedback: z.string().optional().describe("Feedback from a failed verify_app to guide the rebuild")
+      })
+    }
+  );
+}
+function createVerifyAppTool(workDir) {
+  return tool(
+    async (input) => {
+      const orbPath = input.orbPath || path4.join(workDir, "schema.orb");
+      if (!fs4.existsSync(orbPath)) {
+        return { success: false, error: `Schema file not found: ${orbPath}` };
+      }
+      try {
+        const verifyApiPath = path4.resolve(
+          path4.dirname(new URL(import.meta.url).pathname),
+          "../../../../../tools/orbital-verify-unified/src/api.js"
+        );
+        const { verifyApp } = await import(verifyApiPath);
+        const result = await verifyApp({
+          orbPath,
+          headed: true,
+          screenshots: true
+        });
+        const failures = [];
+        for (const phase of result.phases) {
+          for (const check of phase.checks) {
+            if (!check.passed) {
+              failures.push(`[Phase ${phase.phase} ${phase.name}] ${check.label}: ${check.detail || "failed"}`);
+            }
+          }
+        }
+        return {
+          success: result.totalFailed === 0,
+          passed: result.totalPassed,
+          failed: result.totalFailed,
+          total: result.totalChecks,
+          coverage: result.coverage?.ratio ?? null,
+          failures: failures.slice(0, 10)
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+          passed: 0,
+          failed: 1,
+          total: 1,
+          coverage: null,
+          failures: [error instanceof Error ? error.message : String(error)]
+        };
+      }
+    },
+    {
+      name: "verify_app",
+      description: "Run orbital-verify on a compiled .orb schema. Compiles the app, runs server tests, browser tests, and captures screenshots. Returns pass/fail counts and failure details.",
+      schema: z.object({
+        orbPath: z.string().optional().describe("Path to .orb file. Defaults to {workDir}/schema.orb")
+      })
+    }
+  );
+}
+var BEHAVIOR_FUNCTIONS = {};
+async function loadBehaviorFunctions() {
+  if (Object.keys(BEHAVIOR_FUNCTIONS).length > 0) return;
+  try {
+    const fns = await import('@almadar/std/behaviors/functions/index.js');
+    const mapping = {
+      // Molecules: CRUD/Data
+      "std-list": "stdList",
+      "std-cart": "stdCart",
+      "std-detail": "stdDetail",
+      "std-inventory": "stdInventory",
+      "std-messaging": "stdMessaging",
+      "std-geospatial": "stdGeospatial",
+      // Atoms: UI
+      "std-browse": "stdBrowse",
+      "std-modal": "stdModal",
+      "std-confirmation": "stdConfirmation",
+      "std-search": "stdSearch",
+      "std-filter": "stdFilter",
+      "std-sort": "stdSort",
+      "std-pagination": "stdPagination",
+      "std-drawer": "stdDrawer",
+      "std-notification": "stdNotification",
+      "std-timer": "stdTimer",
+      "std-tabs": "stdTabs",
+      "std-loading": "stdLoading",
+      "std-selection": "stdSelection",
+      "std-undo": "stdUndo",
+      "std-input": "stdInput",
+      // Atoms: Domain
+      "std-wizard": "stdWizard",
+      "std-display": "stdDisplay",
+      "std-async": "stdAsync",
+      "std-combat": "stdCombat",
+      "std-gameflow": "stdGameflow",
+      "std-movement": "stdMovement",
+      "std-quest": "stdQuest",
+      "std-overworld": "stdOverworld",
+      "std-circuit-breaker": "stdCircuitBreaker",
+      "std-cache-aside": "stdCacheAside",
+      "std-score": "stdScore",
+      "std-collision": "stdCollision",
+      "std-physics2d": "stdPhysics2d",
+      "std-rate-limiter": "stdRateLimiter",
+      // Atoms: Game UI
+      "std-game-hud": "stdGameHud",
+      "std-score-board": "stdScoreBoard",
+      "std-game-menu": "stdGameMenu",
+      "std-game-over-screen": "stdGameOverScreen",
+      "std-dialogue-box": "stdDialogueBox",
+      "std-inventory-panel": "stdInventoryPanel",
+      "std-combat-log": "stdCombatLog",
+      "std-sprite": "stdSprite",
+      "std-game-audio": "stdGameAudio",
+      // Atoms: Game Canvas
+      "std-isometric-canvas": "stdIsometricCanvas",
+      "std-platformer-canvas": "stdPlatformerCanvas",
+      "std-simulation-canvas": "stdSimulationCanvas",
+      "std-game-canvas-2d": "stdGameCanvas2d",
+      "std-game-canvas-3d": "stdGameCanvas3d",
+      // Molecules: Game
+      "std-turn-based-battle": "stdTurnBasedBattle",
+      "std-platformer-game": "stdPlatformerGame",
+      "std-puzzle-game": "stdPuzzleGame",
+      // Molecules: Educational
+      "std-builder-game": "stdBuilderGame",
+      "std-classifier-game": "stdClassifierGame",
+      "std-sequencer-game": "stdSequencerGame",
+      "std-debugger-game": "stdDebuggerGame",
+      "std-negotiator-game": "stdNegotiatorGame",
+      "std-simulator-game": "stdSimulatorGame",
+      "std-event-handler-game": "stdEventHandlerGame"
+    };
+    for (const [behaviorName, fnName] of Object.entries(mapping)) {
+      if (typeof fns[fnName] === "function") {
+        BEHAVIOR_FUNCTIONS[behaviorName] = fns[fnName];
+      }
+    }
+  } catch {
+  }
+}
+function createUseBehaviorTool(workDir) {
+  return tool(
+    async (input) => {
+      await loadBehaviorFunctions();
+      const newEntityName = input.entityName;
+      const newFields = JSON.parse(input.fieldsJson);
+      let finalOrbital;
+      const behaviorFn = BEHAVIOR_FUNCTIONS[input.behaviorName];
+      if (behaviorFn) {
+        console.log(`[use_behavior] Calling ${input.behaviorName} as pure function`);
+        const orbital = behaviorFn({
+          entityName: newEntityName,
+          fields: newFields,
+          persistence: input.persistence ?? "runtime",
+          pageTitle: input.title,
+          createButtonLabel: input.createButtonLabel,
+          pageName: input.pageName,
+          pagePath: input.pagePath,
+          isInitial: input.isInitialPage
+        });
+        finalOrbital = orbital;
+      } else {
+        console.log(`[use_behavior] Falling back to substitution for ${input.behaviorName}`);
+        const { getBehavior } = await import('@almadar/std');
+        const behavior = getBehavior(input.behaviorName);
+        if (!behavior) {
+          return { success: false, error: `Behavior "${input.behaviorName}" not found` };
+        }
+        const cloned = structuredClone(behavior);
+        const orbitalData = cloned.orbitals?.[0];
+        const goldenTrait = orbitalData ? (orbitalData.traits ?? [])[0] : cloned;
+        const goldenEntity = orbitalData?.entity;
+        if (!goldenTrait?.stateMachine) {
+          return { success: false, error: `Behavior "${input.behaviorName}" has no state machine` };
+        }
+        if (!newFields.some((f) => f.name === "id")) {
+          newFields.unshift({ name: "id", type: "string", required: true });
+        }
+        const oldEntityName = String(goldenEntity?.name ?? goldenTrait.linkedEntity ?? "Item");
+        const traitName = `${newEntityName}Management`;
+        const orbital = {
+          name: `${newEntityName}Orbital`,
+          entity: {
+            name: newEntityName,
+            persistence: input.persistence ?? "runtime",
+            ...input.persistence === "persistent" ? { collection: newEntityName.toLowerCase() + "s" } : {},
+            fields: newFields
+          },
+          traits: [{
+            ...goldenTrait,
+            name: traitName,
+            linkedEntity: newEntityName,
+            category: String(goldenTrait.category ?? "interaction")
+          }],
+          pages: [{
+            name: input.pageName ?? `${newEntityName}Page`,
+            path: input.pagePath ?? `/${newEntityName.toLowerCase()}s`,
+            ...input.isInitialPage ? { isInitial: true } : {},
+            traits: [{ ref: traitName }]
+          }]
+        };
+        const orbStr = JSON.stringify(orbital);
+        const substituted = orbStr.replace(new RegExp(`"entity":\\s*"${oldEntityName}"`, "g"), `"entity": "${newEntityName}"`).replace(new RegExp(`@entity\\.${oldEntityName}\\.`, "g"), `@entity.`).replace(new RegExp(`"${oldEntityName}"`, "g"), `"${newEntityName}"`);
+        try {
+          finalOrbital = JSON.parse(substituted);
+        } catch {
+          finalOrbital = orbital;
+        }
+        if (input.title) {
+          substituteInRenderUi(finalOrbital, "typography", "content", oldEntityName, input.title, true);
+        }
+        if (input.createButtonLabel) {
+          substituteInRenderUi(finalOrbital, "button", "label", null, input.createButtonLabel, false);
+        }
+      }
+      const orbitalsDir = path4.join(workDir, ".orbitals");
+      fs4.mkdirSync(orbitalsDir, { recursive: true });
+      const safeName = newEntityName.replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
+      const orbitalPath = path4.join(orbitalsDir, `${safeName}.json`);
+      fs4.writeFileSync(orbitalPath, JSON.stringify(finalOrbital, null, 2));
+      const schema = { name: newEntityName + "App", version: "1.0.0", orbitals: [finalOrbital] };
+      fs4.mkdirSync(workDir, { recursive: true });
+      const validation = validateWithOrbitalCLI(schema, workDir);
+      return {
+        success: true,
+        behaviorName: input.behaviorName,
+        entityName: newEntityName,
+        orbitalPath,
+        usedFunction: !!behaviorFn,
+        validation: {
+          valid: validation.valid ?? false,
+          errorCount: (validation.errors ?? []).length,
+          errors: (validation.errors ?? []).slice(0, 5).map((e) => e.message)
+        }
+      };
+    },
+    {
+      name: "use_behavior",
+      description: "Instantiate a standard behavior with custom entity fields and labels. Zero LLM calls. Calls pure behavior function when available, falls back to substitution otherwise.",
+      schema: z.object({
+        behaviorName: z.string().describe('Standard behavior name (e.g., "std-list", "std-cart")'),
+        entityName: z.string().describe('New entity name in PascalCase (e.g., "Product", "Task")'),
+        fieldsJson: z.string().describe("JSON array of entity fields: [{ name, type, required?, default? }]"),
+        persistence: z.string().optional().describe('"persistent", "runtime", or "singleton"'),
+        title: z.string().optional().describe("Page title override"),
+        createButtonLabel: z.string().optional().describe("Create button label override"),
+        pageName: z.string().optional().describe("Page component name"),
+        pagePath: z.string().optional().describe('Route path (e.g., "/products")'),
+        isInitialPage: z.boolean().optional().describe("Whether this is the initial/home page")
+      })
+    }
+  );
+}
+function substituteInRenderUi(orbital, patternType, propName, oldValue, newValue, firstOnly) {
+  const traits = orbital.traits || [];
+  for (const trait of traits) {
+    const sm = trait.stateMachine;
+    if (!sm) continue;
+    const transitions = sm.transitions || [];
+    for (const tr of transitions) {
+      if (tr.event !== "INIT") continue;
+      const effects = tr.effects || [];
+      for (const eff of effects) {
+        if (!Array.isArray(eff) || eff[0] !== "render-ui") continue;
+        const tree = eff[2];
+        if (!tree) continue;
+        walkAndSubstitute(tree, patternType, propName, oldValue, newValue, firstOnly, () => {
+        });
+      }
+    }
+  }
+}
+function walkAndSubstitute(node, patternType, propName, oldValue, newValue, firstOnly, onFound) {
+  if (node.type === patternType) {
+    const current = node[propName];
+    if (typeof current === "string") {
+      if (oldValue === null || current.toLowerCase().includes(oldValue.toLowerCase())) {
+        if (!firstOnly || !onFound) {
+          node[propName] = newValue;
+          onFound();
+        }
+      }
+    }
+  }
+  const children = node.children;
+  if (Array.isArray(children)) {
+    for (const child of children) {
+      if (child && typeof child === "object") {
+        walkAndSubstitute(child, patternType, propName, oldValue, newValue, firstOnly, onFound);
+      }
+    }
+  }
+}
+function createConnectTool(workDir) {
+  return tool(
+    async (input) => {
+      const emitterPath = path4.join(workDir, ".orbitals", input.emitterFile);
+      const listenerPath = path4.join(workDir, ".orbitals", input.listenerFile);
+      if (!fs4.existsSync(emitterPath)) return { success: false, error: `Emitter not found: ${emitterPath}` };
+      if (!fs4.existsSync(listenerPath)) return { success: false, error: `Listener not found: ${listenerPath}` };
+      const emitter = JSON.parse(fs4.readFileSync(emitterPath, "utf-8"));
+      const listener = JSON.parse(fs4.readFileSync(listenerPath, "utf-8"));
+      const emitterTraits = emitter.traits || [];
+      const listenerTraits = listener.traits || [];
+      if (emitterTraits.length === 0 || listenerTraits.length === 0) {
+        return { success: false, error: "Both orbitals must have at least one trait" };
+      }
+      const emitterTrait = emitterTraits[0];
+      const listenerTrait = listenerTraits[0];
+      const emits = emitterTrait.emits || [];
+      emits.push({
+        event: input.eventName,
+        scope: "external",
+        ...input.payloadJson ? { payload: JSON.parse(input.payloadJson) } : {}
+      });
+      emitterTrait.emits = emits;
+      const listens = listenerTrait.listens || [];
+      listens.push({
+        event: input.eventName,
+        triggers: input.triggersEvent || "INIT",
+        scope: "external"
+      });
+      listenerTrait.listens = listens;
+      fs4.writeFileSync(emitterPath, JSON.stringify(emitter, null, 2));
+      fs4.writeFileSync(listenerPath, JSON.stringify(listener, null, 2));
+      return {
+        success: true,
+        event: input.eventName,
+        emitter: String(emitterTrait.name),
+        listener: String(listenerTrait.name)
+      };
+    },
+    {
+      name: "connect_behaviors",
+      description: "Wire a cross-orbital event between two behaviors. Adds emits to the emitter trait and listens to the listener trait.",
+      schema: z.object({
+        emitterFile: z.string().describe('Emitter orbital filename in .orbitals/ (e.g., "product.json")'),
+        listenerFile: z.string().describe('Listener orbital filename in .orbitals/ (e.g., "cart_item.json")'),
+        eventName: z.string().describe('Event name in UPPER_SNAKE_CASE (e.g., "ADD_TO_CART")'),
+        triggersEvent: z.string().optional().describe('Event to trigger on listener (defaults to "INIT")'),
+        payloadJson: z.string().optional().describe("JSON array of payload fields: [{ name, type }]")
+      })
+    }
+  );
+}
+function createComposeTool(workDir) {
+  return tool(
+    async (input) => {
+      const orbitalsDir = path4.join(workDir, ".orbitals");
+      const orbitals = [];
+      const orbitalFiles = input.orbitalFiles ? JSON.parse(input.orbitalFiles) : fs4.readdirSync(orbitalsDir).filter((f) => f.endsWith(".json"));
+      for (const file of orbitalFiles) {
+        const filePath = path4.join(orbitalsDir, file);
+        if (!fs4.existsSync(filePath)) continue;
+        orbitals.push(JSON.parse(fs4.readFileSync(filePath, "utf-8")));
+      }
+      if (orbitals.length === 0) {
+        return { success: false, error: "No orbitals found in .orbitals/" };
+      }
+      let pages;
+      if (input.pagesJson) {
+        pages = JSON.parse(input.pagesJson);
+      } else {
+        pages = orbitals.map((o, i) => {
+          const oName = String(o.name || `Orbital${i}`);
+          const entityName = oName.replace(/Orbital$/i, "");
+          const traits = o.traits || [];
+          return {
+            name: `${entityName}Page`,
+            path: `/${entityName.toLowerCase()}s`,
+            ...i === 0 ? { isInitial: true } : {},
+            traits: traits.filter((t) => typeof t !== "string" && !("ref" in t)).map((t) => ({ ref: String(t.name) }))
+          };
+        });
+      }
+      for (const orbital of orbitals) {
+        String(orbital.name || "");
+        const orbitalTraitNames = (orbital.traits || []).filter((t) => typeof t !== "string" && !("ref" in t)).map((t) => String(t.name));
+        orbital.pages = pages.filter((p) => {
+          const pageTraits = p.traits || [];
+          return pageTraits.some((pt) => orbitalTraitNames.includes(pt.ref));
+        });
+      }
+      const schema = {
+        name: input.appName || "Application",
+        version: "1.0.0",
+        orbitals
+      };
+      const schemaPath = path4.join(workDir, "schema.orb");
+      fs4.writeFileSync(schemaPath, JSON.stringify(schema, null, 2));
+      const validation = validateWithOrbitalCLI(schema, workDir);
+      return {
+        success: true,
+        appName: schema.name,
+        orbitalCount: orbitals.length,
+        pageCount: pages.length,
+        schemaPath,
+        validation: {
+          valid: validation.valid ?? false,
+          errorCount: (validation.errors || []).length,
+          errors: (validation.errors || []).slice(0, 5).map((e) => e.message)
+        }
+      };
+    },
+    {
+      name: "compose_app",
+      description: "Compose multiple orbitals from .orbitals/ into a final multi-page application schema. Writes schema.orb and validates.",
+      schema: z.object({
+        appName: z.string().optional().describe("Application name"),
+        orbitalFiles: z.string().optional().describe("JSON array of orbital filenames. Defaults to all .json files in .orbitals/"),
+        pagesJson: z.string().optional().describe("JSON array of page definitions: [{ name, path, isInitial?, traits: [{ ref }] }]. Auto-generated if omitted.")
+      })
+    }
+  );
+}
+
+export { createBuildOrbitalTool, createComposeTool, createConnectTool, createDecomposeAppTool, createMatchBehaviorTool, createUseBehaviorTool, createVerifyAppTool, deepCloneOrb, extractBehaviorGateData, getTraitGateData, getTransitionGateData, replaceOrbital, replaceTrait, replaceTransition, runGate0, runGate05, runGate1, runGate2, runGate3, runGate4, runGatePipeline, scoreGate0, scoreGate1, scoreGate2, scoreGate3, scoreGate4, scoreOverall };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map