@almadar/agent 3.5.6 → 3.5.11

package/dist/gates/index.js

@@ -1,99 +1,16 @@
-import { extractJsonFromText, createOpenRouterClient, createDeepSeekClient } from '@almadar/llm';
-import { loadGoldenOrb, getAllBehaviors } from '@almadar/std';
 import fs3 from 'fs';
 import path3 from 'path';
+import { extractJsonFromText, createAnthropicClient, createOpenRouterClient, createDeepSeekClient } from '@almadar/llm';
 import { execSync } from 'child_process';
-import { getDecompositionCompact, getBindingsCompact, getBindingContextRules, getOrbRenderUIGuide } from '@almadar/skills';
+import { getDecompositionCompact, getBindingsCompact, getBindingContextRules, getOrbRenderUIGuideFiltered, getOrbRenderUIGuide } from '@almadar/skills';
+import { loadGoldenOrb, getAllBehaviors } from '@almadar/std';
+import { getOrbAllowedPatterns } from '@almadar/patterns';
 import { tool } from '@langchain/core/tools';
 import { z } from 'zod';
+import * as stdBehaviorFunctions from '@almadar/std/behaviors/functions';
+import { composeBehaviors } from '@almadar/core/builders';
 
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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: () => loadGoldenOrbByName,
-  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 loadGoldenOrbByName(behaviorName) {
-  return loadGoldenOrb(behaviorName);
-}
-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 = loadGoldenOrbByName(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;
-  }
-});
+// src/gates/orchestrator.ts
 var ORBITAL_BINARY = "/home/osamah/bin/orbital";
 function validateWithOrbitalCLI(schema, workDir) {
   if (!fs3.existsSync(ORBITAL_BINARY)) {
@@ -270,7 +187,7 @@ Your output must be a JSON object with:
 - category: "interaction"
 - stateMachine:
   - states: [{ name: camelCase, isInitial?: true }]
-  - events: [{ key: "UPPER_SNAKE_CASE", name: "Human Label", payloadSchema?: [{ name, type }] }]
+  - events: [{ key: "UPPER_SNAKE_CASE", name: "Human Label", payloadSchema: [{ name, type }] }]
   - transitions: [{ from, event, to, effects: [] }]
 - ui: { "stateName": { "presentation": "inline" | "modal" }, ... }
 
@@ -281,6 +198,26 @@ State Machine Rules:
 - 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)
 
+Payload Schema Rules (MANDATORY - validation fails without these):
+- EVERY event except INIT, CLOSE, and CANCEL MUST have a payloadSchema. This is NOT optional.
+- SAVE: { "key": "SAVE", "name": "Save", "payloadSchema": [{ "name": "data", "type": "object" }] }
+- EDIT: { "key": "EDIT", "name": "Edit", "payloadSchema": [{ "name": "id", "type": "string" }] }
+- DELETE: { "key": "DELETE", "name": "Delete", "payloadSchema": [{ "name": "id", "type": "string" }] }
+- VIEW: { "key": "VIEW", "name": "View", "payloadSchema": [{ "name": "id", "type": "string" }] }
+- CREATE: { "key": "CREATE", "name": "Create" } (no payload needed, opens empty form)
+- Any event with a verb that acts on an entity needs payloadSchema with at least "id" or "data"
+
+Example events array:
+[
+  { "key": "INIT", "name": "Initialize" },
+  { "key": "CREATE", "name": "Create Item" },
+  { "key": "EDIT", "name": "Edit Item", "payloadSchema": [{ "name": "id", "type": "string" }] },
+  { "key": "SAVE", "name": "Save", "payloadSchema": [{ "name": "data", "type": "object" }] },
+  { "key": "DELETE", "name": "Delete Item", "payloadSchema": [{ "name": "id", "type": "string" }] },
+  { "key": "CANCEL", "name": "Cancel" },
+  { "key": "CLOSE", "name": "Close" }
+]
+
 UI Slot Assignment Rules:
 - Assign "inline" to primary view states (idle, browsing, listing, viewing)
 - Assign "modal" to overlay action states (creating, editing, deleting, confirming)
@@ -345,6 +282,13 @@ Rules:
 - set target MUST start with @entity (never @payload)
 - Do NOT include render-ui effects (Gate 4 handles those)
 
+Guard Rules (CRITICAL):
+- Do NOT wrap a single condition in "and". Use "and" ONLY for 2+ conditions.
+  WRONG: ["and", ["eq", "@entity.status", "active"]]
+  RIGHT: ["eq", "@entity.status", "active"]
+- ONLY reference fields that exist on the entity shown in the user prompt. Do NOT invent fields.
+  If the entity has fields [id, name, status], you can use @entity.name, @entity.status. Do NOT use @entity.items or @entity.data if they are not listed.
+
 Respond with ONLY valid JSON. No markdown, no explanation.`;
 }
 function buildGate3UserPrompt(transition, entity, sm, guidedTransition) {
@@ -362,8 +306,8 @@ ${JSON.stringify(guidedTransition, null, 2)}`;
   }
   return userPrompt;
 }
-function buildGate4SystemPrompt() {
-  const orbGuide = getOrbRenderUIGuide();
+function buildGate4SystemPrompt(matchedPatterns) {
+  const orbGuide = matchedPatterns ? getOrbRenderUIGuideFiltered(matchedPatterns) : getOrbRenderUIGuide();
   return `You are a UI designer. Given a transition with its effects, produce the render-ui pattern tree.
 
 ${orbGuide}
@@ -375,19 +319,27 @@ Your output must be a JSON object with:
 
 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:
+- When exiting a modal state (the user prompt will say so), you MUST include BOTH:
   1. { "slot": "modal", "tree": null } to clear the modal
-  2. { "slot": "main", "tree": { ... } } to render the main view
+  2. { "slot": "main", "tree": { ... } } to re-render the main view
+  WITHOUT BOTH, the main view shows stale content after closing the modal. This is a validation error.
 
 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
+- ONLY bind to entity fields shown in the user prompt. Do NOT invent fields.
+  If entity has fields [id, name, status, price], you can use @entity.name, @entity.price.
+  Do NOT use @entity.items, @entity.data, or any field not listed. This is a validation error.
 
 Pattern Rules:
 - Use ONLY props that exist on the pattern. Do NOT invent props.
-- data-list: entity, itemActions, emptyState (NOT emptyIcon, emptyTitle)
+- data-list fields MUST be a string array: ["name", "status", "price"]. NEVER use objects or nested trees for fields.
+  WRONG: "fields": [{ "type": "stack", "children": [...] }]
+  WRONG: "fields": [{ "field": "name", "label": "Name" }]
+  RIGHT: "fields": ["name", "status", "price"]
+- data-list: entity, fields, itemActions (NOT emptyIcon, emptyTitle)
 - button: label, variant, event, icon, size (NOT disabled)
 - card: children (NOT padding, bg, border, use box for those)
 
@@ -519,9 +471,72 @@ async function runGate0(client, prompt, opts = {}, behaviorData) {
   });
   return parseGate0Response(raw);
 }
+var cachedCatalog = null;
+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 loadGoldenOrbByName(behaviorName) {
+  return loadGoldenOrb(behaviorName);
+}
+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.
 
-// src/gates/orchestrator.ts
-init_gate05_behavior_match();
+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 = loadGoldenOrbByName(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 };
+}
 
 // src/gates/merge.ts
 function deepCloneOrb(orb) {
@@ -823,6 +838,296 @@ function findGuidedTransition(goldenOrb, traitName, from, event) {
   }
   return void 0;
 }
+var CORE_PATTERNS = [
+  "stack",
+  "box",
+  "typography",
+  "divider",
+  "icon",
+  "button"
+];
+var GAME_EVENTS = /* @__PURE__ */ new Set([
+  "ATTACK",
+  "DEFEND",
+  "MOVE",
+  "SPAWN",
+  "DAMAGE",
+  "HEAL",
+  "CAST",
+  "LEVEL_UP",
+  "GAME_OVER",
+  "START_GAME",
+  "PAUSE",
+  "RESUME",
+  "NEXT_TURN",
+  "END_TURN",
+  "COLLECT",
+  "EQUIP",
+  "UNEQUIP",
+  "CRAFT",
+  "TICK",
+  "STEP",
+  "SIMULATE"
+]);
+var GAME_PATTERN_NAMES = /* @__PURE__ */ new Set([
+  "health-bar",
+  "score-display",
+  "control-button",
+  "d-pad",
+  "action-button",
+  "choice-button",
+  "combo-counter",
+  "damage-number",
+  "mini-map",
+  "resource-counter",
+  "timer-display",
+  "turn-indicator",
+  "waypoint-marker",
+  "x-p-bar",
+  "crafting-recipe",
+  "enemy-plate",
+  "health-panel",
+  "quest-tracker",
+  "resource-bar",
+  "turn-panel",
+  "unit-command-bar",
+  "powerup-slots",
+  "item-slot",
+  "status-effect",
+  // display: game/simulation
+  "model-loader",
+  "feature-renderer",
+  "unit-renderer",
+  "state-indicator",
+  "simulation-controls",
+  "simulation-graph",
+  "event-log",
+  "object-rule-panel",
+  "rule-editor",
+  "action-palette",
+  "sequence-bar",
+  "state-node",
+  "transition-arrow",
+  "variable-panel"
+]);
+var SEARCH_PATTERNS = /* @__PURE__ */ new Set(["search-input"]);
+var WIZARD_PATTERNS = /* @__PURE__ */ new Set(["wizard-progress", "wizard-navigation"]);
+var SPECIALIZED_PATTERNS = /* @__PURE__ */ new Set([
+  "law-reference-tooltip",
+  "violation-alert",
+  "scaled-diagram",
+  "quiz-block",
+  "code-block",
+  "code-view",
+  "markdown-content",
+  "flip-card",
+  "flip-container",
+  "confetti-effect",
+  "typewriter-text",
+  "pull-to-refresh",
+  "swipeable-row",
+  "lightbox",
+  "carousel",
+  "calendar-grid",
+  "time-slot-cell",
+  "day-cell",
+  "line-chart",
+  "chart-legend",
+  "graph-view",
+  "split-pane",
+  "master-detail",
+  "tabbed-container",
+  // Aliases (typography already covers these)
+  "heading",
+  "text",
+  // Alias for button
+  "button-pattern",
+  // Niche/unlikely for most apps
+  "conditional-wrapper",
+  "text-highlight",
+  "theme-toggle",
+  "flex",
+  "floating-action-button",
+  "animated-counter",
+  "infinite-scroll-sentinel",
+  "progress-dots",
+  "map-view",
+  "range-slider",
+  "number-stepper",
+  "star-rating",
+  "upload-drop-zone",
+  "collapsible-section",
+  "stat-badge",
+  "status-dot",
+  "sortable-list",
+  "trend-indicator",
+  // Container patterns (compiler handles these, not render-ui)
+  "modal",
+  "drawer",
+  "overlay",
+  // Form sub-patterns (form-section is enough)
+  "repeatable-form-section",
+  "form-field",
+  "form-section-header",
+  "input-group",
+  "relation-select",
+  "date-range-selector",
+  // Layout extras (stack/box cover these)
+  "grid",
+  "center",
+  "spacer",
+  // Error boundary (runtime handles this)
+  "error-boundary"
+]);
+function analyzeApp(orb) {
+  const signals = {
+    hasModalStates: false,
+    hasInlineStates: false,
+    hasCreateEdit: false,
+    hasDelete: false,
+    hasSearch: false,
+    hasWizard: false,
+    isGame: false,
+    eventNames: /* @__PURE__ */ new Set()
+  };
+  for (const orbital of orb.orbitals) {
+    for (const traitRef of orbital.traits) {
+      if (typeof traitRef === "string" || "ref" in traitRef) continue;
+      const trait = traitRef;
+      if (!trait.stateMachine) continue;
+      const ui = trait.ui;
+      if (ui) {
+        for (const val of Object.values(ui)) {
+          if (val.presentation === "modal") signals.hasModalStates = true;
+          if (val.presentation === "inline") signals.hasInlineStates = true;
+        }
+      }
+      for (const state of trait.stateMachine.states) {
+        const name = state.name.toLowerCase();
+        if (name.includes("creat") || name.includes("edit")) signals.hasCreateEdit = true;
+        if (name.includes("delet") || name.includes("confirm")) signals.hasDelete = true;
+        if (name.includes("search") || name.includes("filter")) signals.hasSearch = true;
+        if (name.includes("step") || name.includes("wizard")) signals.hasWizard = true;
+      }
+      for (const event of trait.stateMachine.events) {
+        signals.eventNames.add(event.key);
+        if (GAME_EVENTS.has(event.key)) signals.isGame = true;
+        if (event.key === "SEARCH" || event.key === "FILTER") signals.hasSearch = true;
+      }
+    }
+  }
+  return signals;
+}
+function preFilterPatterns(signals) {
+  const grouped = getOrbAllowedPatterns();
+  const allowed = [];
+  for (const items of Object.values(grouped)) {
+    for (const item of items) {
+      if (CORE_PATTERNS.includes(item.name)) continue;
+      if (!signals.isGame && GAME_PATTERN_NAMES.has(item.name)) continue;
+      if (!signals.hasSearch && SEARCH_PATTERNS.has(item.name)) continue;
+      if (!signals.hasWizard && WIZARD_PATTERNS.has(item.name)) continue;
+      if (!signals.isGame && SPECIALIZED_PATTERNS.has(item.name)) continue;
+      allowed.push(item.name);
+    }
+  }
+  return allowed;
+}
+function buildSlimCatalog(patternNames) {
+  const grouped = getOrbAllowedPatterns();
+  const nameSet = new Set(patternNames);
+  const lines = [];
+  for (const [cat, items] of Object.entries(grouped).sort()) {
+    const filtered = items.filter((i) => nameSet.has(i.name));
+    if (filtered.length === 0) continue;
+    lines.push(`## ${cat}`);
+    for (const item of filtered) {
+      const desc = item.description.split("\n")[0].slice(0, 80);
+      lines.push(`- ${item.name}: ${desc}`);
+    }
+  }
+  return lines.join("\n");
+}
+function buildSystemPrompt(preFiltered, signals) {
+  const catalog = buildSlimCatalog(preFiltered);
+  return `You are a UI pattern selector. Pick 5-15 patterns from the catalog below to render this application's UI.
+
+Core layout patterns are ALWAYS included (do not list them):
+${CORE_PATTERNS.join(", ")}
+
+Select from each applicable category:
+
+**Content (pick 1-3)**: data-list or data-grid for lists, card for grouping, stat-display for metrics, badge for status
+**Forms${signals.hasCreateEdit ? " (REQUIRED - app has create/edit states)" : ""}**: form-section for create/edit forms
+**Feedback (pick 1-2)**: empty-state, loading-state, error-state, notification
+**Navigation (if needed)**: tabs, pagination, breadcrumb
+
+Pick at most 15 patterns total. Only pick patterns you are confident the app needs.
+
+Catalog (${preFiltered.length} patterns):
+${catalog}
+
+Respond with ONLY valid JSON: { "patterns": ["pattern-name", ...] }`;
+}
+function buildUserPrompt(orb) {
+  const lines = [];
+  for (const orbital of orb.orbitals) {
+    const entity = orbital.entity;
+    const fields = entity.fields?.map((f) => `${f.name}:${f.type}`).join(", ") || "none";
+    lines.push(`Entity: ${entity.name} (${fields})`);
+    for (const traitRef of orbital.traits) {
+      if (typeof traitRef === "string" || "ref" in traitRef) continue;
+      const trait = traitRef;
+      if (!trait.stateMachine) continue;
+      const states = trait.stateMachine.states.map((s) => s.name).join(", ");
+      const events = trait.stateMachine.events.map((e) => e.key).join(", ");
+      const ui = trait.ui;
+      const slots = ui ? Object.entries(ui).map(([s, v]) => `${s}(${v.presentation})`).join(", ") : "none";
+      lines.push(`Trait: ${trait.name} | States: ${states} | Events: ${events} | Slots: ${slots}`);
+    }
+  }
+  return `Select UI patterns for this application:
+
+${lines.join("\n")}`;
+}
+async function runGate35(client, orb, _opts = {}) {
+  const signals = analyzeApp(orb);
+  const preFiltered = preFilterPatterns(signals);
+  console.log(`[Gate 3.5] Pre-filtered: ${preFiltered.length} patterns (game=${signals.isGame}, createEdit=${signals.hasCreateEdit})`);
+  const systemPrompt = buildSystemPrompt(preFiltered, signals);
+  const userPrompt = buildUserPrompt(orb);
+  try {
+    const raw = await client.callRaw({
+      systemPrompt,
+      userPrompt,
+      maxTokens: 256
+    });
+    const jsonStr = extractJsonFromText(raw);
+    if (!jsonStr) {
+      console.warn("[Gate 3.5] No JSON in response, using pre-filtered set");
+      return [.../* @__PURE__ */ new Set([...CORE_PATTERNS, ...preFiltered])];
+    }
+    const parsed = JSON.parse(jsonStr);
+    const selected = Array.isArray(parsed.patterns) ? parsed.patterns : [];
+    const preFilteredSet = new Set(preFiltered);
+    const validated = selected.filter((p) => preFilteredSet.has(p));
+    const result = [.../* @__PURE__ */ new Set([...CORE_PATTERNS, ...validated])];
+    if (result.length > 20) {
+      return [...CORE_PATTERNS, ...validated.slice(0, 14)];
+    }
+    if (result.length < 8) {
+      console.warn(`[Gate 3.5] Only ${result.length} patterns, adding essentials`);
+      const essentials = ["badge", "stat-display", "data-list", "form-section", "empty-state", "card"];
+      for (const p of essentials) {
+        if (!result.includes(p) && preFilteredSet.has(p)) result.push(p);
+      }
+    }
+    return result;
+  } catch (error) {
+    console.warn(`[Gate 3.5] Error: ${error instanceof Error ? error.message : error}, using pre-filtered set`);
+    return [.../* @__PURE__ */ new Set([...CORE_PATTERNS, ...preFiltered])];
+  }
+}
 function buildSlotContext(sm, traitUi) {
   const slots = {};
   for (const state of sm.states) {
@@ -850,8 +1155,8 @@ function parseGate4Response(raw) {
     tree: r.tree === null ? null : r.tree || { type: "typography", variant: "body", content: "Empty" }
   }));
 }
-async function runGate4(client, orb, opts = {}, _behaviorData) {
-  const systemPrompt = buildGate4SystemPrompt();
+async function runGate4(client, orb, opts = {}, _behaviorData, matchedPatterns) {
+  const systemPrompt = buildGate4SystemPrompt(matchedPatterns);
   let result = orb;
   for (const orbital of orb.orbitals) {
     const entity = orbital.entity;
@@ -968,6 +1273,9 @@ function createClientForProvider(config) {
     case "mistral-medium":
       client = createOpenRouterClient({ model: "mistralai/mistral-medium-3.1", ...opts });
       break;
+    case "anthropic":
+      client = createAnthropicClient(opts);
+      break;
     default: {
       const _exhaustive = config.provider;
       throw new Error(`Unknown provider: ${_exhaustive}`);
@@ -986,8 +1294,29 @@ ${opts2.userPrompt}` });
 function timeMs() {
   return performance.now();
 }
+function withCallCounter(client) {
+  let calls = 0;
+  const proxy = new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === "calls") return calls;
+      if (prop === "reset") return () => {
+        calls = 0;
+      };
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "callRaw" || prop === "callRawWithMetadata") {
+        return (...args) => {
+          calls++;
+          return value.apply(target, args);
+        };
+      }
+      return value;
+    }
+  });
+  return proxy;
+}
 async function runGatePipeline(prompt, config, behaviorData, goldenOrb) {
-  const client = createClientForProvider(config);
+  const counter = withCallCounter(createClientForProvider(config));
+  const client = counter;
   const maxTokens = config.maxTokens || 4096;
   const pipelineStart = timeMs();
   const opts = {
@@ -995,41 +1324,60 @@ async function runGatePipeline(prompt, config, behaviorData, goldenOrb) {
     goldenOrb,
     workDir: config.workDir
   };
+  counter.reset();
   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)`);
+  const g0Calls = counter.calls;
+  console.log(`[Gate 0] ${orbAfterGate0.name}: ${orbAfterGate0.orbitals.length} orbital(s) (${g0Ms.toFixed(0)}ms, ${g0Calls} LLM call(s))`);
   maybeValidate(config, orbAfterGate0, 0);
+  let g05Calls = 0;
   if (config.mode === "guided" && !goldenOrb) {
+    counter.reset();
     const g05Start = timeMs();
     const matchResult = await runGate05(client, prompt, orbAfterGate0, opts);
     const g05Ms = timeMs() - g05Start;
+    g05Calls = counter.calls;
     if (matchResult.goldenOrb) {
       opts.goldenOrb = matchResult.goldenOrb;
-      console.log(`[Gate 0.5] Matched: ${matchResult.matchedName} (${g05Ms.toFixed(0)}ms)`);
+      console.log(`[Gate 0.5] Matched: ${matchResult.matchedName} (${g05Ms.toFixed(0)}ms, ${g05Calls} LLM call(s))`);
     } else {
-      console.log(`[Gate 0.5] No match, continuing in pure mode (${g05Ms.toFixed(0)}ms)`);
+      console.log(`[Gate 0.5] No match, continuing in pure mode (${g05Ms.toFixed(0)}ms, ${g05Calls} LLM call(s))`);
     }
   }
+  counter.reset();
   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)`);
+  const g1Calls = counter.calls;
+  console.log(`[Gate 1] Enriched ${orbAfterGate1.orbitals.length} orbital(s) (${g1Ms.toFixed(0)}ms, ${g1Calls} LLM call(s))`);
   maybeValidate(config, orbAfterGate1, 1);
+  counter.reset();
   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)`);
+  const g2Calls = counter.calls;
+  console.log(`[Gate 2] State machines filled (${g2Ms.toFixed(0)}ms, ${g2Calls} LLM call(s))`);
   maybeValidate(config, orbAfterGate2, 2);
+  counter.reset();
   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)`);
+  const g3Calls = counter.calls;
+  console.log(`[Gate 3] Guards + effects filled (${g3Ms.toFixed(0)}ms, ${g3Calls} LLM call(s))`);
   maybeValidate(config, orbAfterGate3, 3);
+  counter.reset();
+  const g35Start = timeMs();
+  const matchedPatterns = await runGate35(client, orbAfterGate3, opts);
+  const g35Ms = timeMs() - g35Start;
+  const g35Calls = counter.calls;
+  console.log(`[Gate 3.5] Matched ${matchedPatterns.length} patterns (${g35Ms.toFixed(0)}ms, ${g35Calls} LLM call(s))`);
+  counter.reset();
   const g4Start = timeMs();
-  const orbFinal = await runGate4(client, orbAfterGate3, opts);
+  const orbFinal = await runGate4(client, orbAfterGate3, opts, behaviorData, matchedPatterns);
   const g4Ms = timeMs() - g4Start;
-  console.log(`[Gate 4] Render-ui appended (${g4Ms.toFixed(0)}ms)`);
+  const g4Calls = counter.calls;
+  console.log(`[Gate 4] Render-ui appended (${g4Ms.toFixed(0)}ms, ${g4Calls} LLM call(s))`);
   fs3.mkdirSync(config.workDir, { recursive: true });
   const validation = validateWithOrbitalCLI(orbFinal, config.workDir);
   console.log(`[Validate] valid=${validation.valid}, errors=${(validation.errors || []).length}`);
@@ -1038,12 +1386,14 @@ async function runGatePipeline(prompt, config, behaviorData, goldenOrb) {
     verify = await runVerify(orbFinal, config);
   }
   const totalMs = timeMs() - pipelineStart;
-  console.log(`[Pipeline] Total: ${(totalMs / 1e3).toFixed(1)}s`);
+  const totalCalls = g0Calls + g05Calls + g1Calls + g2Calls + g3Calls + g35Calls + g4Calls;
+  console.log(`[Pipeline] Total: ${(totalMs / 1e3).toFixed(1)}s, ${totalCalls} LLM calls`);
   const timings = {
     gate0Ms: g0Ms,
     gate1Ms: [g1Ms],
     gate2Ms: [g2Ms],
     gate3Ms: [g3Ms],
+    gate35Ms: g35Ms,
     gate4Ms: [g4Ms],
     totalMs
   };
@@ -1109,9 +1459,6 @@ function maybeValidate(config, orb, gate) {
   }
 }
 
-// src/gates/index.ts
-init_gate05_behavior_match();
-
 // src/gates/behavior-extract.ts
 function asArray(val) {
   if (!val) return [];
@@ -1486,7 +1833,6 @@ function countNodes(tree) {
   }
   return count;
 }
-init_gate05_behavior_match();
 function createGateClient(provider = "mistral-small") {
   let client;
   switch (provider) {
@@ -1586,8 +1932,7 @@ function createBuildOrbitalTool(workDir, gateProvider) {
       }
       let goldenOrb;
       if (input.goldenBehavior) {
-        const { loadGoldenOrbByName: loadGoldenOrbByName2 } = await Promise.resolve().then(() => (init_gate05_behavior_match(), gate05_behavior_match_exports));
-        goldenOrb = loadGoldenOrbByName2(input.goldenBehavior) ?? void 0;
+        goldenOrb = loadGoldenOrbByName(input.goldenBehavior) ?? void 0;
       }
       const opts = {
         goldenOrb
@@ -1696,10 +2041,10 @@ function createVerifyAppTool(workDir) {
   );
 }
 var BEHAVIOR_FUNCTIONS = {};
-async function loadBehaviorFunctions() {
+function loadBehaviorFunctions() {
   if (Object.keys(BEHAVIOR_FUNCTIONS).length > 0) return;
   try {
-    const fns = await import('@almadar/std/behaviors/functions');
+    const fns = stdBehaviorFunctions;
     const mapping = {
       // Molecules: CRUD/Data
       "std-list": "stdList",
@@ -1779,7 +2124,7 @@ async function loadBehaviorFunctions() {
 function createUseBehaviorTool(workDir) {
   return tool(
     async (input) => {
-      await loadBehaviorFunctions();
+      loadBehaviorFunctions();
       const newEntityName = input.entityName;
       const newFields = JSON.parse(input.fieldsJson);
       let finalOrbital;
@@ -1799,7 +2144,6 @@ function createUseBehaviorTool(workDir) {
         finalOrbital = orbital;
       } else {
         console.log(`[use_behavior] Falling back to substitution for ${input.behaviorName}`);
-        const { loadGoldenOrb } = await import('@almadar/std');
         const behavior = loadGoldenOrb(input.behaviorName);
         if (!behavior) {
           return { success: false, error: `Behavior "${input.behaviorName}" not found` };
@@ -1995,43 +2339,29 @@ function createComposeTool(workDir) {
       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) }))
-          };
-        });
+      let eventWiring;
+      if (input.eventWiringJson) {
+        eventWiring = JSON.parse(input.eventWiringJson);
       }
-      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));
-        });
+      let entityMappings;
+      if (input.entityMappingsJson) {
+        entityMappings = JSON.parse(input.entityMappingsJson);
       }
-      const schema = {
-        name: input.appName || "Application",
-        version: "1.0.0",
-        orbitals
-      };
+      const result = composeBehaviors({
+        appName: input.appName || "Application",
+        orbitals,
+        layoutStrategy: input.layoutStrategy ?? "auto",
+        eventWiring,
+        entityMappings
+      });
       const schemaPath = path3.join(workDir, "schema.orb");
-      fs3.writeFileSync(schemaPath, JSON.stringify(schema, null, 2));
-      const validation = validateWithOrbitalCLI(schema, workDir);
+      fs3.writeFileSync(schemaPath, JSON.stringify(result.schema, null, 2));
+      const validation = validateWithOrbitalCLI(result.schema, workDir);
       return {
         success: true,
-        appName: schema.name,
+        appName: result.schema.name,
         orbitalCount: orbitals.length,
-        pageCount: pages.length,
+        pageCount: result.layout.pageCount,
         schemaPath,
         validation: {
           valid: validation.valid ?? false,
@@ -2041,12 +2371,14 @@ function createComposeTool(workDir) {
       };
     },
     {
-      name: "compose_app",
-      description: "Compose multiple orbitals from .orbitals/ into a final multi-page application schema. Writes schema.orb and validates.",
+      name: "compose_behaviors",
+      description: "Compose multiple orbitals from .orbitals/ into a final application schema using composeBehaviors. Handles layout strategy detection, event wiring, and page generation. 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.")
+        layoutStrategy: z.enum(["sidebar", "tabs", "dashboard", "wizard-flow", "auto"]).optional().describe("Layout strategy. Defaults to auto."),
+        eventWiringJson: z.string().optional().describe("JSON array of event wiring entries: [{ from, event, to, triggers }]"),
+        entityMappingsJson: z.string().optional().describe('JSON object of entity mappings: { "Entity.field": "OtherEntity.field" }')
       })
     }
   );