@almadar/skills 2.5.0 → 2.5.4

package/dist/index.js

@@ -1,8 +1,8 @@
 import { existsSync, mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
-import { generateBehaviorsDocs, getAllBehaviors, generateModulesDocs, getAllStdOperators } from '@almadar/std';
+import { getAllBehaviors, generateBehaviorsDocs, generateModulesDocs, getAllStdOperators } from '@almadar/std';
 import { OPERATORS, UI_SLOTS, PATTERN_TYPES, ViewTypeSchema, isInlineTrait as isInlineTrait$1 } from '@almadar/core/types';
-import { getPatternPropsCompact, getPatternActionsRef, getOrbAllowedPatternsCompact, getAllPatternTypes } from '@almadar/patterns';
+import { getPatternPropsCompact, getPatternActionsRef, getOrbAllowedPatternsCompact, getOrbAllowedPatternsFiltered, getAllPatternTypes } from '@almadar/patterns';
 import { BINDING_DOCS, CORE_BINDINGS, isInlineTrait } from '@almadar/core';
 import { generateDomainLanguageReference } from '@almadar/core/domain-language';
 
@@ -1542,6 +1542,139 @@ ${patternsRef}
 
 ### BANNED Patterns
 
+| Wrong | Correct |
+|-------|---------|
+| \`entity-table\` | \`data-list\` or \`data-grid\` |
+| \`page-header\` | \`stack\` with \`icon\` + \`typography\` + \`button\` |
+| \`detail-panel\` | \`stack\` with field \`typography\` rows |
+| \`stats\` | \`stat-display\` atoms in a \`stack\` |
+| Multiple flat render-ui calls | Single composed render-ui |
+| Hex colors / pixels | Theme CSS variables |
+| \`onSubmit\` / \`onCancel\` | \`submitEvent\` / \`cancelEvent\` |
+`;
+}
+function getOrbRenderUIGuideFiltered(patternNames) {
+  const patternsRef = getOrbAllowedPatternsFiltered(patternNames);
+  return `## .orb Render-UI Composition Guide
+
+### Golden Behavior Pattern
+
+Every render-ui tree in .orb follows the same structure observed across all 107 golden behaviors:
+
+\`\`\`
+stack (vertical, gap: lg)            \u2190 root wrapper, ALWAYS
+  \u251C\u2500\u2500 stack (horizontal)             \u2190 header row (icon + title + actions)
+  \u2502     \u251C\u2500\u2500 icon
+  \u2502     \u251C\u2500\u2500 typography (h2/h3)
+  \u2502     \u2514\u2500\u2500 button (primary action)
+  \u251C\u2500\u2500 divider                        \u2190 visual separation
+  \u251C\u2500\u2500 stat-display / badge row       \u2190 optional summary stats
+  \u2514\u2500\u2500 data-list / data-grid          \u2190 main content
+        OR form-section              \u2190 for create/edit states
+\`\`\`
+
+---
+
+### Composition Rules
+
+| Rule | Requirement |
+|------|-------------|
+| **1** | Root element MUST be \`stack\` (vertical) or \`box\` |
+| **2** | Use ONLY the patterns listed below |
+| **3** | Single \`render-ui\` per transition (compose children, never multiple flat calls) |
+| **4** | ALL visual props use CSS theme variables (no hex colors, no pixels) |
+| **5** | Every action button's \`event\` must match a state machine event key |
+
+---
+
+### Layout Reference
+
+**Stack** (use for ALL layout):
+\`\`\`json
+{
+  "type": "stack",
+  "direction": "vertical" | "horizontal",
+  "gap": "xs" | "sm" | "md" | "lg" | "xl",
+  "align": "start" | "center" | "end" | "stretch",
+  "justify": "start" | "center" | "end" | "between"
+}
+\`\`\`
+
+**Box** (styled container):
+\`\`\`json
+{
+  "type": "box",
+  "padding": "sm" | "md" | "lg",
+  "bg": "var(--color-card)",
+  "border": true,
+  "borderColor": "var(--color-border)",
+  "rounded": "var(--radius-md)",
+  "shadow": "var(--shadow-sm)"
+}
+\`\`\`
+
+---
+
+### Theme Variables (MANDATORY)
+
+| Property | Use | Never |
+|----------|-----|-------|
+| Colors | \`var(--color-primary)\` | \`#3b82f6\` |
+| Backgrounds | \`var(--color-card)\` | \`white\` |
+| Text | \`var(--color-foreground)\` | \`black\` |
+| Muted text | \`var(--color-muted-foreground)\` | \`gray\` |
+| Borders | \`var(--color-border)\` | \`#e5e7eb\` |
+| Radius | \`var(--radius-md)\` | \`8px\` |
+| Shadows | \`var(--shadow-sm)\` | \`0 2px 4px...\` |
+
+---
+
+### Example: Browsing State (from golden behaviors)
+
+\`\`\`json
+["render-ui", "main", {
+  "type": "stack", "direction": "vertical", "gap": "lg",
+  "children": [
+    {
+      "type": "stack", "direction": "horizontal", "gap": "md",
+      "justify": "between", "align": "center",
+      "children": [
+        {
+          "type": "stack", "direction": "horizontal", "gap": "sm", "align": "center",
+          "children": [
+            { "type": "icon", "name": "list", "size": "lg" },
+            { "type": "typography", "variant": "h2", "content": "Items" }
+          ]
+        },
+        { "type": "button", "label": "Create", "event": "CREATE", "variant": "primary" }
+      ]
+    },
+    { "type": "divider" },
+    {
+      "type": "data-list", "entity": "Item",
+      "itemActions": [
+        { "label": "Edit", "event": "EDIT" },
+        { "label": "Delete", "event": "DELETE", "variant": "danger" }
+      ]
+    }
+  ]
+}]
+\`\`\`
+
+---
+
+${getBindingsGuide()}
+
+---
+
+### Available Patterns (selected for this application)
+
+${patternsRef}
+
+---
+
+### BANNED Patterns
+
 | Wrong | Correct |
 |-------|---------|
 | \`entity-table\` | \`data-list\` or \`data-grid\` |
@@ -4256,6 +4389,91 @@ When answering:
   };
 }
 
+// src/generators/converter.ts
+function generateConverterSkill() {
+  const frontmatter = {
+    name: "converter",
+    description: "Convert existing source code projects or live websites to .orb orbital schemas",
+    allowedTools: [
+      "extract_source",
+      "extract_crawl",
+      "match_behavior",
+      "use_behavior",
+      "build_orbital",
+      "connect_behaviors",
+      "compose_app",
+      "verify_app"
+    ],
+    version: "1.0.0"
+  };
+  const content = `
+# Almadar Converter Agent
+
+You convert existing TypeScript/JavaScript projects into .orb orbital schemas.
+
+## Workflow
+
+1. **Extract**: Call \`extract_source\` with the project path to get a SourceSnapshot
+2. **Read**: Examine the SourceSnapshot \u2014 entities, routes, API routes, state management
+3. **Match**: For each entity, call \`match_behavior\` with a description of the entity's usage pattern
+4. **Instantiate**: For each matched entity:
+   - If matched \u2192 call \`use_behavior\` with the behavior name, entity name, and fields JSON (FAST, 0 LLM)
+   - If not matched \u2192 call \`build_orbital\` with a shell schema (SLOW, 40+ LLM calls, FALLBACK ONLY)
+5. **Connect**: If entities have cross-entity relationships, call \`connect_behaviors\` to wire events
+6. **Compose**: Call \`compose_app\` to combine all orbitals into the final schema
+7. **Verify**: If requested, call \`verify_app\` to run round-trip verification
+8. **Retry**: If verify fails, read failures, fix the specific orbital, recompose, reverify (max 2 retries)
+
+## Tools
+
+- \`extract_source\`: Extract entities, routes, APIs, state from source code (deterministic for TS, agent-driven for other languages)
+- \`match_behavior\`: Find matching std behavior for an entity (1 LLM call)
+- \`use_behavior\`: Instantiate a behavior with custom entity + fields (0 LLM calls, PREFERRED)
+- \`build_orbital\`: Full gate pipeline for novel patterns (40+ LLM calls, FALLBACK)
+- \`connect_behaviors\`: Wire cross-orbital events between emitter and listener (0 LLM calls)
+- \`compose_app\`: Combine all orbitals into final multi-page app schema (0 LLM calls)
+- \`verify_app\`: Compile + serve + browser test (0 LLM calls)
+
+## Rules
+
+- ALWAYS try \`use_behavior\` first via \`match_behavior\`. Only \`build_orbital\` as fallback.
+- When calling \`use_behavior\`, provide \`fieldsJson\` as a JSON string array:
+  '[{"name":"title","type":"string","required":true},{"name":"status","type":"enum","values":["active","done"],"required":true}]'
+- Set \`persistence\` to "persistent" for entities with database backing, "runtime" otherwise.
+- Always call \`compose_app\` before \`verify_app\`.
+- Read verify failures carefully and fix only the broken orbital.
+
+## Behavior Matching Guidelines
+
+When deciding which behavior matches an entity, consider:
+
+| Pattern | Behavior | Key Indicators |
+|---------|----------|---------------|
+| List + CRUD operations | \`std-list\` | GET (list), POST, PUT, DELETE API routes; browse/create/edit states |
+| Detail view | \`std-detail\` | GET (single) route with :id param; view-only display |
+| Multi-step form / wizard | \`std-wizard\` | Sequential steps, stages, or phases in UI |
+| Shopping cart / checkout | \`std-cart\` | Add/remove items, quantity, checkout flow |
+| Static display | \`std-display\` | Read-only data presentation, no CRUD |
+| Search functionality | \`std-search\` | Search input, filter, query results |
+| Notification / alerts | \`std-notification\` | Push notifications, alerts, toasts |
+| Timer / countdown | \`std-timer\` | Time-based state, countdown, duration |
+
+## Cross-Entity Connection Patterns
+
+Look for these signals in the SourceSnapshot to identify connections:
+
+- Field names ending in \`Id\` (e.g., \`authorId\`, \`categoryId\`) \u2192 relation
+- Import statements between entity modules \u2192 dependency
+- Shared event names in state management \u2192 event connection
+- Foreign key patterns in Prisma/ORM \u2192 emits/listens wiring
+`.trim();
+  return {
+    name: "converter",
+    frontmatter,
+    content
+  };
+}
+
 // src/generators/orb.ts
 function generateOrbSkill() {
   const frontmatter = {
@@ -4914,6 +5132,460 @@ Uses only atoms and molecules. No organisms.
 `;
 }
 
+// src/prompts/behavior-sections/classify.ts
+var ATOM_NAMES = /* @__PURE__ */ new Set([
+  "std-browse",
+  "std-modal",
+  "std-confirmation",
+  "std-search",
+  "std-filter",
+  "std-sort",
+  "std-pagination",
+  "std-drawer",
+  "std-notification",
+  "std-timer",
+  "std-tabs",
+  "std-loading",
+  "std-selection",
+  "std-undo",
+  "std-input",
+  "std-wizard",
+  "std-display",
+  "std-async",
+  "std-combat",
+  "std-gameflow",
+  "std-movement",
+  "std-quest",
+  "std-overworld",
+  "std-circuit-breaker",
+  "std-cache-aside",
+  "std-score",
+  "std-collision",
+  "std-physics2d",
+  "std-rate-limiter",
+  "std-game-hud",
+  "std-score-board",
+  "std-game-menu",
+  "std-game-over-screen",
+  "std-dialogue-box",
+  "std-inventory-panel",
+  "std-combat-log",
+  "std-sprite",
+  "std-game-audio",
+  "std-isometric-canvas",
+  "std-platformer-canvas",
+  "std-simulation-canvas",
+  "std-game-canvas-2d",
+  "std-game-canvas-3d"
+]);
+var MOLECULE_NAMES = /* @__PURE__ */ new Set([
+  "std-list",
+  "std-cart",
+  "std-detail",
+  "std-inventory",
+  "std-messaging",
+  "std-geospatial",
+  "std-turn-based-battle",
+  "std-platformer-game",
+  "std-puzzle-game",
+  "std-builder-game",
+  "std-classifier-game",
+  "std-sequencer-game",
+  "std-debugger-game",
+  "std-negotiator-game",
+  "std-simulator-game",
+  "std-event-handler-game"
+]);
+function classifyBehavior(name) {
+  if (ATOM_NAMES.has(name)) return "atoms";
+  if (MOLECULE_NAMES.has(name)) return "molecules";
+  return "organisms";
+}
+function extractTraitData(schema) {
+  const orbitals = schema.orbitals;
+  if (!orbitals || orbitals.length === 0) {
+    return { states: [], events: [], emits: [], listens: [] };
+  }
+  const traits = orbitals[0].traits;
+  if (!traits || traits.length === 0) {
+    return { states: [], events: [], emits: [], listens: [] };
+  }
+  const trait = traits[0];
+  const sm = trait.stateMachine;
+  const states = sm?.states?.map((s) => s.name) ?? [];
+  const events = sm?.events?.map((e) => e.key) ?? [];
+  const emits = trait.emits?.map((e) => e.event) ?? [];
+  const listens = trait.listens?.map((l) => l.event) ?? [];
+  return { states, events, emits, listens };
+}
+
+// src/prompts/behavior-sections/behavior-catalog.ts
+function extractDescription(schema) {
+  if (schema.description) return schema.description;
+  const orbitals = schema.orbitals;
+  if (!orbitals || orbitals.length === 0) return "No description available";
+  const traits = orbitals[0].traits;
+  if (traits && traits.length > 0 && typeof traits[0].name === "string") {
+    return `Behavior: ${traits[0].name}`;
+  }
+  if (typeof orbitals[0].name === "string") {
+    return `Orbital: ${orbitals[0].name}`;
+  }
+  return "No description available";
+}
+function getBehaviorCatalogSection() {
+  const allBehaviors = getAllBehaviors();
+  const atoms = [];
+  const molecules = [];
+  const organisms = [];
+  for (const b of allBehaviors) {
+    const level = classifyBehavior(b.name);
+    if (level === "atoms") atoms.push(b);
+    else if (level === "molecules") molecules.push(b);
+    else organisms.push(b);
+  }
+  const formatList = (behaviors) => behaviors.map((b) => `- \`${b.name}\`: ${extractDescription(b)}`).join("\n");
+  return `## Behavior Catalog (${allBehaviors.length} behaviors)
+
+### Atoms (${atoms.length})
+Self-contained, irreducible state machines. Building blocks for molecules.
+
+${formatList(atoms)}
+
+### Molecules (${molecules.length})
+Compose atoms via extractTrait + shared event bus. Mid-complexity behaviors.
+
+${formatList(molecules)}
+
+### Organisms (${organisms.length})
+Compose atoms/molecules via connect/compose/pipe. Full application patterns.
+
+${formatList(organisms)}`;
+}
+function getBehaviorAtomReference() {
+  const allBehaviors = getAllBehaviors();
+  const atoms = allBehaviors.filter((b) => classifyBehavior(b.name) === "atoms");
+  if (atoms.length === 0) {
+    return "### Atom Reference\n\nNo atoms found.";
+  }
+  const entries = atoms.map((schema) => {
+    const { states, events } = extractTraitData(schema);
+    const desc = schema.description ?? "";
+    const lines = [];
+    lines.push(`#### \`${schema.name}\``);
+    if (desc) lines.push(desc);
+    lines.push(`- **States**: ${states.length > 0 ? states.join(", ") : "none"}`);
+    lines.push(`- **Events**: ${events.length > 0 ? events.join(", ") : "none"}`);
+    return lines.join("\n");
+  });
+  return `### Atom Reference (${atoms.length})
+
+Atoms are self-contained, irreducible state machines. Each atom handles a single concern.
+
+${entries.join("\n\n")}`;
+}
+function getBehaviorMoleculeReference() {
+  const allBehaviors = getAllBehaviors();
+  const molecules = allBehaviors.filter((b) => classifyBehavior(b.name) === "molecules");
+  if (molecules.length === 0) {
+    return "### Molecule Reference\n\nNo molecules found.";
+  }
+  const entries = molecules.map((schema) => {
+    const { states, events } = extractTraitData(schema);
+    const desc = schema.description ?? "";
+    const lines = [];
+    lines.push(`#### \`${schema.name}\``);
+    if (desc) lines.push(desc);
+    lines.push(`- **States**: ${states.length > 0 ? states.join(", ") : "none"}`);
+    lines.push(`- **Events**: ${events.length > 0 ? events.join(", ") : "none"}`);
+    return lines.join("\n");
+  });
+  return `### Molecule Reference (${molecules.length})
+
+Molecules compose atoms via extractTrait and shared event buses. They handle mid-complexity interaction patterns.
+
+${entries.join("\n\n")}`;
+}
+function getBehaviorOrganismReference() {
+  const allBehaviors = getAllBehaviors();
+  const organisms = allBehaviors.filter((b) => classifyBehavior(b.name) === "organisms");
+  if (organisms.length === 0) {
+    return "### Organism Reference\n\nNo organisms found.";
+  }
+  const entries = organisms.map((schema) => {
+    const { states, events } = extractTraitData(schema);
+    const desc = schema.description ?? "";
+    const lines = [];
+    lines.push(`#### \`${schema.name}\``);
+    if (desc) lines.push(desc);
+    lines.push(`- **States**: ${states.length > 0 ? states.join(", ") : "none"}`);
+    lines.push(`- **Events**: ${events.length > 0 ? events.join(", ") : "none"}`);
+    return lines.join("\n");
+  });
+  return `### Organism Reference (${organisms.length})
+
+Organisms compose atoms and molecules via connect/compose/pipe. They represent full application patterns.
+
+${entries.join("\n\n")}`;
+}
+
+// src/prompts/behavior-sections/behavior-composition-guide.ts
+function getBehaviorCompositionGuide() {
+  return `## Behavior Composition Guide
+
+### Core Rule: One Entity Per Orbital
+Every orbital has exactly ONE entity. If your app needs multiple entity types (e.g., Products and Orders),
+create multiple orbitals and wire them together with events.
+
+### How \`use_behavior\` Works
+Call \`use_behavior\` with an entity name and its fields to instantiate a standard behavior.
+The behavior function replaces generic field names with your entity-specific names and returns a complete orbital.
+
+\`\`\`
+use_behavior({ behavior: "std-list", entityName: "Product", fields: ["name", "price", "category"] })
+// Returns: complete orbital with entity=Product, all states/events/UI wired for Product
+\`\`\`
+
+### How \`composeBehaviors\` Works
+After instantiating individual behaviors, compose them into a full application.
+\`composeBehaviors\` takes an array of orbitals and adds:
+- Layout: how orbitals are arranged on screen
+- Wiring: event connections between orbitals (emits/listens)
+- Pages: route configuration
+
+\`\`\`
+compose_behaviors({
+  orbitals: [productOrbital, orderOrbital],
+  layout: "sidebar",
+  wiring: [{ from: "ProductInteraction", event: "ADD_TO_CART", to: "OrderInteraction", triggers: "REFRESH" }]
+})
+\`\`\`
+
+### Layout Strategies
+
+| Strategy | Description | Best For |
+|----------|-------------|----------|
+| \`sidebar\` | Navigation sidebar + main content | CRUD apps, dashboards |
+| \`tabs\` | Tabbed content sections | Multi-entity views |
+| \`dashboard\` | Grid of widgets/cards | Analytics, monitoring |
+| \`wizard-flow\` | Sequential step-by-step | Onboarding, checkout |
+| \`auto\` | Let the system choose based on orbital count | Quick prototyping |
+
+### Event Wiring
+Behaviors communicate through emits/listens. When one behavior emits an event,
+another behavior's listener triggers a transition.
+
+- **emits**: Events this behavior sends out (e.g., ITEM_CREATED, ADD_TO_CART)
+- **listens**: Events this behavior responds to (e.g., REFRESH, ITEM_SELECTED)
+- **wiring**: Explicit connections between behaviors: \`{ from, event, to, triggers }\`
+
+Every \`emits\` declaration must have a matching \`listens\` in another trait.`;
+}
+function extractEventContracts(schema) {
+  const allEmits = [];
+  const allListens = [];
+  const orbitals = schema.orbitals;
+  if (!orbitals) return { emits: allEmits, listens: allListens };
+  for (const orbital of orbitals) {
+    const traits = orbital.traits;
+    if (!traits) continue;
+    for (const trait of traits) {
+      const emits = trait.emits;
+      if (emits) {
+        for (const e of emits) {
+          if (e.event && !allEmits.includes(e.event)) {
+            allEmits.push(e.event);
+          }
+        }
+      }
+      const listens = trait.listens;
+      if (listens) {
+        for (const l of listens) {
+          if (l.event && !allListens.includes(l.event)) {
+            allListens.push(l.event);
+          }
+        }
+      }
+    }
+  }
+  return { emits: allEmits, listens: allListens };
+}
+function getBehaviorEventContractsSection() {
+  const behaviors = getAllBehaviors();
+  const entries = [];
+  for (const schema of behaviors) {
+    const { emits, listens } = extractEventContracts(schema);
+    if (emits.length === 0 && listens.length === 0) continue;
+    const parts = [];
+    if (emits.length > 0) parts.push(`emits [${emits.join(", ")}]`);
+    if (listens.length > 0) parts.push(`listens [${listens.join(", ")}]`);
+    entries.push(`- \`${schema.name}\`: ${parts.join(", ")}`);
+  }
+  if (entries.length === 0) {
+    return `## Event Contracts
+
+No behaviors with emits or listens found.`;
+  }
+  return `## Event Contracts
+
+Behaviors communicate via events. Each behavior declares what it emits and what it listens to.
+Wire matching emits to listens when composing behaviors.
+
+${entries.join("\n")}`;
+}
+
+// src/prompts/behavior-sections/domain-behavior-mapping.ts
+function getDomainBehaviorMapping() {
+  return `## Domain to Behavior Mapping
+
+Use this guide to select behaviors based on the application domain.
+
+| Domain | Recommended Behaviors |
+|--------|----------------------|
+| **Business CRUD** | std-list, std-detail |
+| **E-commerce** | std-list (products), std-cart, std-wizard (checkout) |
+| **Healthcare** | std-list (patients), std-wizard (intake), std-display (vitals) |
+| **Education** | std-list (courses), std-wizard (enrollment) |
+| **Gaming** | std-gameflow, std-combat, std-inventory-panel, std-quest |
+| **Dashboard/Analytics** | std-display, std-list |
+| **Social** | std-list (posts), std-messaging, std-detail (profile) |
+| **DevOps** | std-list, std-display, std-circuit-breaker |
+| **Finance** | std-list (transactions), std-display (portfolio), std-wizard (transfers) |
+| **IoT/Monitoring** | std-display (sensors), std-list (devices), std-timer (polling) |
+| **Content Management** | std-list (articles), std-detail (editor), std-tabs (categories) |
+| **Booking/Scheduling** | std-list (slots), std-wizard (booking flow), std-confirmation |
+| **Project Management** | std-list (tasks), std-detail (task view), std-tabs (boards) |
+
+### Selection Strategy
+1. Identify the primary entity types in the application
+2. Match each entity to a behavior based on how users interact with it
+3. Wire behaviors together using emits/listens for cross-entity communication
+4. Use layout strategy (sidebar, tabs, dashboard) based on the relationship between entities`;
+}
+
+// src/prompts/behavior-sections/cross-orbital-wiring-guide.ts
+function getCrossOrbitalWiringGuide() {
+  return `## Cross-Orbital Wiring Guide
+
+### How Events Flow Between Orbitals
+Orbitals communicate through a shared event bus. One orbital's trait emits an event,
+and another orbital's trait listens for it. The listener triggers a local transition.
+
+### Wiring Format
+\`\`\`json
+{
+  "from": "ProductInteraction",
+  "event": "ADD_TO_CART",
+  "to": "CartInteraction",
+  "triggers": "REFRESH"
+}
+\`\`\`
+
+- **from**: The trait that emits the event
+- **event**: The event name being emitted
+- **to**: The trait that listens for the event
+- **triggers**: The local event triggered in the listening trait
+
+### Common Wiring Patterns
+
+#### CRUD Refresh
+When one orbital creates/updates/deletes, another orbital refreshes its list.
+
+\`\`\`
+ProductInteraction emits PRODUCT_CREATED
+  -> OrderInteraction listens PRODUCT_CREATED, triggers REFRESH
+\`\`\`
+
+#### Navigation / Detail View
+When one orbital selects an item, another shows its details.
+
+\`\`\`
+ListInteraction emits VIEW_DETAIL
+  -> DetailInteraction listens VIEW_DETAIL, triggers INIT
+\`\`\`
+
+#### Cart Pattern
+Add-to-cart from a product list updates the cart orbital.
+
+\`\`\`
+ProductInteraction emits ADD_TO_CART
+  -> CartInteraction listens ADD_TO_CART, triggers ITEM_ADDED
+\`\`\`
+
+#### Wizard Completion
+A multi-step wizard emits completion, triggering a downstream action.
+
+\`\`\`
+CheckoutInteraction emits ORDER_PLACED
+  -> ConfirmationInteraction listens ORDER_PLACED, triggers INIT
+\`\`\`
+
+### Rules
+1. Every \`emits\` must have a matching \`listens\` in another trait
+2. Event names should be descriptive: ENTITY_ACTION (e.g., PRODUCT_CREATED, ORDER_PLACED)
+3. The \`triggers\` field is a local event name in the listening trait's state machine
+4. Multiple traits can listen to the same event
+5. A trait can emit to multiple listeners`;
+}
+
+// src/generators/behaviors.ts
+function generateBehaviorsSkill() {
+  const frontmatter = {
+    name: "behaviors",
+    description: "Generate applications by selecting and composing behaviors from the standard library.",
+    allowedTools: [
+      "decompose_app",
+      "match_behavior",
+      "use_behavior",
+      "connect_behaviors",
+      "compose_behaviors",
+      "verify_app",
+      "finish_task"
+    ],
+    version: "1.0.0"
+  };
+  const content = `# Behaviors Composition Skill
+> Select and compose behaviors from the standard library.
+
+${getBehaviorCatalogSection()}
+
+---
+
+${getBehaviorCompositionGuide()}
+
+---
+
+${getBehaviorEventContractsSection()}
+
+---
+
+${getDomainBehaviorMapping()}
+
+---
+
+${getCrossOrbitalWiringGuide()}
+
+---
+
+## Detailed References
+
+${getBehaviorAtomReference()}
+
+---
+
+${getBehaviorMoleculeReference()}
+
+---
+
+${getBehaviorOrganismReference()}
+`;
+  return {
+    name: "behaviors",
+    frontmatter,
+    content
+  };
+}
+
 // src/orbitals-skills-generators/lean/lean-orbital-generator.ts
 var LEAN_CORE_INSTRUCTIONS = `
 ## Core Instructions
@@ -5511,7 +6183,8 @@ function generateAllBuilderSkills() {
       content: generateLeanFixingSkill2()
     },
     generateDomainLanguageSkill(),
-    generateAlmadarAssistantSkill()
+    generateAlmadarAssistantSkill(),
+    generateBehaviorsSkill()
   ];
 }
 function getMinimalTypeReference() {
@@ -6145,6 +6818,6 @@ function generateComparisonMatrix(comparisons) {
   return markdown;
 }
 
-export { EVAL_CASES, analyzeComposition, calculateTotalScore, formatFrontmatter, generateAllBuilderSkills, generateAlmadarAssistantSkill, generateComparisonMatrix, generateDomainLanguageSkill, generateKflowOrbitalFixingSkill, generateKflowOrbitalsSkill, generateLeanFixingSkill2 as generateLeanFixingSkill, generateLeanFixingSkill as generateLeanFixingSkillFull, generateLeanOrbitalSkill2 as generateLeanOrbitalSkill, generateLeanOrbitalSkill as generateLeanOrbitalSkillFull, generateOrbSkill, getArchitectureSection, getAssetRefSection, getBannedProps, getBindingContextRules, getBindingsCompact, getBindingsGuide, getCommonErrorsSection, getCommonFixPatternsSection, getCompletionRulesSection, getConnectivityCompact, getContextUsageCompact, getContextUsageSection, getCustomTraitCompact, getCustomTraitSection, getDecompositionChecklist, getDecompositionCompact, getDecompositionSection, getDesignErrorsCompact, getDesignErrorsSection, getEfficiencySection, getFieldTypesCompact, getFixingWorkflowSection, getFlowPatternSection, getFullOrbitalPrompt, getGameAsOrbitalsSection, getGameEntityTemplatesSection, getGamePatternsSection, getGameTraitsSection, getGameTypesSection, getIconLibraryCompact, getIconLibrarySection, getKeyBehaviorsReference2 as getKeyBehaviorsReference, getMinimalTypeReference, getMultiFileSection, getOrbRenderUIGuide, getOrbitalConnectivitySection, getOrbitalDecompositionPrompt, getOverGenerationSection, getPatternTypesCompact, getPortableOrbitalOutputSection, getRenderUIDesignGuide, getRenderUIQuickRef2 as getRenderUIQuickRef, getRequirementsDecomposePrompt, getRequirementsTraitPrompt, getSExprQuickRef2 as getSExprQuickRef, getSchemaUpdateCompact, getSchemaUpdateSection, getSubagentSystemPrompt, getThemeGuide, getUsesImportCompact, getUsesImportSection, getValidationHintsSection, writeAllSkills, writeSkill };
+export { EVAL_CASES, analyzeComposition, calculateTotalScore, formatFrontmatter, generateAllBuilderSkills, generateAlmadarAssistantSkill, generateBehaviorsSkill, generateComparisonMatrix, generateConverterSkill, generateDomainLanguageSkill, generateKflowOrbitalFixingSkill, generateKflowOrbitalsSkill, generateLeanFixingSkill2 as generateLeanFixingSkill, generateLeanFixingSkill as generateLeanFixingSkillFull, generateLeanOrbitalSkill2 as generateLeanOrbitalSkill, generateLeanOrbitalSkill as generateLeanOrbitalSkillFull, generateOrbSkill, getArchitectureSection, getAssetRefSection, getBannedProps, getBehaviorAtomReference, getBehaviorCatalogSection, getBehaviorCompositionGuide, getBehaviorEventContractsSection, getBehaviorMoleculeReference, getBehaviorOrganismReference, getBindingContextRules, getBindingsCompact, getBindingsGuide, getCommonErrorsSection, getCommonFixPatternsSection, getCompletionRulesSection, getConnectivityCompact, getContextUsageCompact, getContextUsageSection, getCrossOrbitalWiringGuide, getCustomTraitCompact, getCustomTraitSection, getDecompositionChecklist, getDecompositionCompact, getDecompositionSection, getDesignErrorsCompact, getDesignErrorsSection, getDomainBehaviorMapping, getEfficiencySection, getFieldTypesCompact, getFixingWorkflowSection, getFlowPatternSection, getFullOrbitalPrompt, getGameAsOrbitalsSection, getGameEntityTemplatesSection, getGamePatternsSection, getGameTraitsSection, getGameTypesSection, getIconLibraryCompact, getIconLibrarySection, getKeyBehaviorsReference2 as getKeyBehaviorsReference, getMinimalTypeReference, getMultiFileSection, getOrbRenderUIGuide, getOrbRenderUIGuideFiltered, getOrbitalConnectivitySection, getOrbitalDecompositionPrompt, getOverGenerationSection, getPatternTypesCompact, getPortableOrbitalOutputSection, getRenderUIDesignGuide, getRenderUIQuickRef2 as getRenderUIQuickRef, getRequirementsDecomposePrompt, getRequirementsTraitPrompt, getSExprQuickRef2 as getSExprQuickRef, getSchemaUpdateCompact, getSchemaUpdateSection, getSubagentSystemPrompt, getThemeGuide, getUsesImportCompact, getUsesImportSection, getValidationHintsSection, writeAllSkills, writeSkill };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map