@almadar/agent 1.6.4 → 2.0.1

package/dist/orbitals/batch/batch-generator.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Batch Generator
+ *
+ * Core batch generation logic for generating multiple orbitals efficiently.
+ * Supports multiple modes: single-call, parallel-individual, adaptive.
+ *
+ * @packageDocumentation
+ */
+import type { LLMClient } from '@almadar/llm';
+import type { OrbitalDefinition } from '@almadar/core/types';
+import type { BatchGenerationOptions, BatchGenerationResult } from './types.js';
+/**
+ * Generate multiple orbitals in optimized batches.
+ *
+ * This is the main entry point for batch generation. It:
+ * 1. Splits orbitals into optimal batches
+ * 2. Generates each batch (parallel or sequential)
+ * 3. Combines results into final schema
+ *
+ * @example
+ * ```typescript
+ * const result = await generateOrbitalsBatch(client, [
+ *   { name: "Products", ... },
+ *   { name: "Orders", ... },
+ *   { name: "Customers", ... },
+ * ], { mode: 'single-call', batchSize: 3 });
+ *
+ * console.log(`Generated ${result.summary.successful}/${result.summary.total} orbitals`);
+ * console.log(`Total time: ${result.totalDurationMs}ms`);
+ * ```
+ */
+export declare function generateOrbitalsBatch(client: LLMClient, orbitals: OrbitalDefinition[], options?: BatchGenerationOptions): Promise<BatchGenerationResult>;
+/**
+ * Estimate optimal batch configuration for a set of orbitals.
+ */
+export declare function estimateOptimalBatchConfig(orbitals: OrbitalDefinition[], provider: 'anthropic' | 'openai' | 'deepseek' | 'kimi' | 'openrouter'): {
+    recommendedMode: 'single-call' | 'parallel-individual';
+    optimalBatchSize: number;
+    estimatedBatches: number;
+    estimatedTimeSeconds: number;
+};

package/dist/orbitals/batch/concurrency.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Concurrency Controller
+ *
+ * Semaphore-based concurrency control for parallel operations.
+ *
+ * @packageDocumentation
+ */
+import type { ConcurrencyController } from './types.js';
+/**
+ * Create a semaphore-based concurrency controller.
+ *
+ * @example
+ * ```typescript
+ * const controller = createConcurrencyController(3); // Max 3 concurrent
+ *
+ * await controller.acquire(); // Acquire slot
+ * try {
+ *   await doWork();
+ * } finally {
+ *   controller.release(); // Release slot
+ * }
+ * ```
+ */
+export declare function createConcurrencyController(maxConcurrency: number): ConcurrencyController;
+/**
+ * Execute an array of async functions with concurrency control.
+ *
+ * @example
+ * ```typescript
+ * const results = await runWithConcurrency(
+ *   items.map(item => () => processItem(item)),
+ *   { concurrency: 3 }
+ * );
+ * ```
+ */
+export declare function runWithConcurrency<T>(tasks: Array<() => Promise<T>>, options: {
+    concurrency: number;
+    onProgress?: (completed: number, total: number) => void;
+}): Promise<T[]>;
+/**
+ * Async map with concurrency limit.
+ *
+ * Similar to Promise.all() but with max concurrency.
+ *
+ * @example
+ * ```typescript
+ * const results = await asyncMapWithConcurrency(
+ *   items,
+ *   async (item, index) => process(item),
+ *   3 // max 3 concurrent
+ * );
+ * ```
+ */
+export declare function asyncMapWithConcurrency<T, R>(items: T[], mapper: (item: T, index: number) => Promise<R>, concurrency: number): Promise<R[]>;

package/dist/orbitals/batch/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Batch Orbital Generation
+ *
+ * Efficient batch generation of multiple orbitals using:
+ * - Single-call batch mode (multiple orbitals per LLM call)
+ * - Parallel individual mode (concurrent single-orbital calls)
+ * - Adaptive mode (automatically chooses best strategy)
+ *
+ * @packageDocumentation
+ */
+export { generateOrbitalsBatch, estimateOptimalBatchConfig, } from './batch-generator.js';
+export { assembleBatchPrompt, splitIntoBatches, extractSharedContext, estimateBatchTokens, willBatchFit, type BatchAssembledPrompt, type SharedBatchContext, } from './prompt-assembler.js';
+export { createConcurrencyController, runWithConcurrency, asyncMapWithConcurrency, } from './concurrency.js';
+export { type BatchGenerationOptions, type BatchGenerationResult, type BatchProgressEvent, type SingleBatchResult, type ConcurrencyController, type BatchMode, type SingleCallBatchOptions, type ParallelIndividualOptions, type AdaptiveBatchOptions, } from './types.js';

package/dist/orbitals/batch/prompt-assembler.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Batch Prompt Assembler
+ *
+ * Assembles prompts for generating multiple orbitals in a single LLM call.
+ * Optimized for:
+ * - Context sharing (domain vocabulary, design style)
+ * - Cross-orbital references (emits/listens wiring)
+ * - Token efficiency (shared system context)
+ *
+ * @packageDocumentation
+ */
+import type { OrbitalDefinition } from '@almadar/core/types';
+import type { AssembledPrompt } from '../cache/index.js';
+/**
+ * Assembled prompt for batch generation.
+ */
+export interface BatchAssembledPrompt extends AssembledPrompt {
+    /** Number of orbitals in this batch */
+    orbitalCount: number;
+    /** Names of orbitals in this batch */
+    orbitalNames: string[];
+}
+/**
+ * Shared context extracted from a batch of orbitals.
+ */
+export interface SharedBatchContext {
+    /** Domain vocabulary shared across orbitals */
+    domainVocabulary?: Record<string, string>;
+    /** Design style (minimal, modern, etc.) */
+    designStyle?: string;
+    /** Common patterns used */
+    commonPatterns?: string[];
+    /** Cross-orbital event relationships */
+    eventRelationships?: Array<{
+        emitter: string;
+        event: string;
+        listener: string;
+        handler: string;
+    }>;
+}
+/**
+ * Extract shared context from a batch of orbitals.
+ */
+export declare function extractSharedContext(orbitals: OrbitalDefinition[]): SharedBatchContext;
+/**
+ * Assemble a batch prompt for generating multiple orbitals in one call.
+ *
+ * @example
+ * ```typescript
+ * const batchPrompt = assembleBatchPrompt([
+ *   { name: "Products", entity: {...}, traits: [...] },
+ *   { name: "Orders", entity: {...}, traits: [...] },
+ *   { name: "Customers", entity: {...}, traits: [...] },
+ * ]);
+ * // Returns a single prompt that generates all 3 orbitals
+ * ```
+ */
+export declare function assembleBatchPrompt(orbitals: OrbitalDefinition[], options?: {
+    baseSystemPrompt?: string;
+    includeConnectivity?: boolean;
+}): BatchAssembledPrompt;
+/**
+ * Split orbitals into optimally-sized batches.
+ *
+ * Considers:
+ * - Provider token limits
+ * - Cross-orbital relationships (keeps related orbitals together)
+ * - Batch size limits
+ *
+ * @example
+ * ```typescript
+ * const batches = splitIntoBatches(orbitals, {
+ *   maxBatchSize: 3,
+ *   provider: 'anthropic'
+ * });
+ * // Returns: [[orb1, orb2, orb3], [orb4, orb5], [orb6]]
+ * ```
+ */
+export declare function splitIntoBatches(orbitals: OrbitalDefinition[], options?: {
+    maxBatchSize?: number;
+    provider?: 'anthropic' | 'openai' | 'deepseek' | 'kimi' | 'openrouter';
+    preserveRelationships?: boolean;
+}): OrbitalDefinition[][];
+/**
+ * Estimate token count for a batch prompt.
+ * Rough estimate: ~4 characters per token.
+ */
+export declare function estimateBatchTokens(orbitals: OrbitalDefinition[]): number;
+/**
+ * Check if a batch will fit within token limits.
+ */
+export declare function willBatchFit(orbitals: OrbitalDefinition[], maxTokens?: number): boolean;

package/dist/orbitals/batch/types.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Batch Generation Types
+ *
+ * Type definitions specific to batch orbital generation.
+ *
+ * @packageDocumentation
+ */
+import type { OrbitalDefinition } from '@almadar/core/types';
+import type { GenerationLog, TokenUsage, BatchGenerationOptions as SharedBatchOptions, BatchGenerationResult as SharedBatchResult } from '../shared/index.js';
+export { type GenerationLog, type TokenUsage, type ValidationResult, } from '../shared/index.js';
+/**
+ * Options for batch generation.
+ */
+export interface BatchGenerationOptions extends SharedBatchOptions {
+    /** Callback for batch progress events */
+    onBatchProgress?: (event: BatchProgressEvent) => void;
+    /** Whether to group orbitals by relationships */
+    preserveRelationships?: boolean;
+}
+/**
+ * Batch progress event.
+ */
+export interface BatchProgressEvent {
+    type: 'batch_start' | 'batch_complete' | 'orbital_start' | 'orbital_complete' | 'error';
+    batchIndex: number;
+    totalBatches: number;
+    orbitalIndex?: number;
+    orbitalName?: string;
+    completedOrbitals: number;
+    totalOrbitals: number;
+    error?: string;
+}
+/**
+ * Result for a single batch within multi-batch generation.
+ */
+export interface SingleBatchResult {
+    /** Orbitals in this batch */
+    orbitals: OrbitalDefinition[];
+    /** Generated results */
+    results: Array<{
+        orbital: OrbitalDefinition;
+        success: boolean;
+        error?: string;
+    }>;
+    /** Token usage for this batch */
+    usage?: TokenUsage;
+    /** Batch duration in ms */
+    durationMs: number;
+    /** Logs from this batch */
+    logs: GenerationLog[];
+}
+/**
+ * Complete batch generation result.
+ */
+export interface BatchGenerationResult extends SharedBatchResult {
+    /** Results grouped by batch */
+    batchResults: SingleBatchResult[];
+    /** Total number of batches */
+    totalBatches: number;
+}
+/**
+ * Concurrency controller interface.
+ */
+export interface ConcurrencyController {
+    /** Acquire a slot (returns promise that resolves when slot available) */
+    acquire(): Promise<void>;
+    /** Release a slot */
+    release(): void;
+    /** Current active count */
+    readonly activeCount: number;
+    /** Current waiting count */
+    readonly waitingCount: number;
+}
+/**
+ * Mode for batch generation.
+ */
+export type BatchMode = 'single-call' | 'parallel-individual' | 'adaptive';
+/**
+ * Options for single-call batch generation.
+ */
+export interface SingleCallBatchOptions {
+    mode: 'single-call';
+    /** Max orbitals per LLM call */
+    maxBatchSize: number;
+}
+/**
+ * Options for parallel individual generation.
+ */
+export interface ParallelIndividualOptions {
+    mode: 'parallel-individual';
+    /** Max concurrent generations */
+    concurrency: number;
+}
+/**
+ * Options for adaptive mode (chooses best strategy).
+ */
+export interface AdaptiveBatchOptions {
+    mode: 'adaptive';
+    /** Prefer speed vs quality */
+    priority?: 'speed' | 'quality';
+    /** Max time budget in seconds */
+    timeBudget?: number;
+}

package/dist/orbitals/cache/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Orbital Cache Module
+ *
+ * Exports fingerprinting, templates, and prompt assembly utilities
+ * for efficient LLM prompt caching.
+ *
+ * @packageDocumentation
+ */
+export { computeOrbitalFingerprint, computeEntitySignature, fingerprintsMatch, parseFingerprint, fingerprintSimilarity, } from './orbital-fingerprint.js';
+export { type StructuralTemplate, STRUCTURAL_TEMPLATES, findMatchingTemplates, getBestTemplate, getTemplateGuidance, } from './structural-templates.js';
+export { type AssembledPrompt, type CacheableAssembledPrompt, assembleOrbitalPrompt, assembleCacheableOrbitalPrompt, assembleMultiOrbitalPrompts, getCacheStats, } from './prompt-assembler.js';

package/dist/orbitals/cache/orbital-fingerprint.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Orbital Fingerprinting for Caching
+ *
+ * Computes structural fingerprints for Orbital Units to enable
+ * prompt caching based on similar structures.
+ *
+ * @packageDocumentation
+ */
+import type { OrbitalUnit, OrbitalEntity } from '@almadar/core/types';
+/**
+ * Compute a structural fingerprint for an Orbital Unit.
+ * Units with the same fingerprint can share cached prompts.
+ * Only works with full orbital definitions (not references).
+ */
+export declare function computeOrbitalFingerprint(orbital: OrbitalUnit): string;
+/**
+ * Compute entity structure signature based on field types.
+ */
+export declare function computeEntitySignature(entity: OrbitalEntity): string;
+/**
+ * Check if two fingerprints are structurally similar.
+ * Similar fingerprints can share template guidance.
+ */
+export declare function fingerprintsMatch(fp1: string, fp2: string): boolean;
+/**
+ * Extract fingerprint components.
+ */
+export declare function parseFingerprint(fingerprint: string): {
+    persistence: string;
+    entity: string;
+    traits: string[];
+    patterns: string[];
+};
+/**
+ * Compute similarity score between two fingerprints (0-1).
+ */
+export declare function fingerprintSimilarity(fp1: string, fp2: string): number;

package/dist/orbitals/cache/prompt-assembler.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Prompt Assembler for Cache-Aware Prompt Construction
+ *
+ * Assembles prompts with cache markers for efficient LLM caching.
+ *
+ * @packageDocumentation
+ */
+import type { OrbitalUnit } from '@almadar/core/types';
+import type { CacheableBlock } from '@almadar/llm';
+export interface AssembledPrompt {
+    /** The full prompt text */
+    prompt: string;
+    /** Fingerprint for this orbital */
+    fingerprint: string;
+    /** Whether a cached template was used */
+    usedCachedTemplate: boolean;
+    /** Template name if used */
+    templateName?: string;
+}
+/**
+ * Cache-aware assembled prompt with separate blocks.
+ */
+export interface CacheableAssembledPrompt {
+    /** System blocks (cacheable) */
+    systemBlocks: CacheableBlock[];
+    /** User blocks (usually not cacheable) */
+    userBlocks: CacheableBlock[];
+    /** Fingerprint for this orbital */
+    fingerprint: string;
+    /** Whether a cached template was used */
+    usedCachedTemplate: boolean;
+    /** Template name if used */
+    templateName?: string;
+}
+/**
+ * Assemble a prompt for orbital unit generation.
+ * Organizes content to maximize cache hits.
+ * Only works with full orbital definitions (not references).
+ */
+export declare function assembleOrbitalPrompt(orbital: OrbitalUnit, baseSystemPrompt: string): AssembledPrompt;
+/**
+ * Assemble cacheable blocks for Anthropic prompt caching.
+ *
+ * Structure:
+ * - System block 1: Base system prompt (highly cacheable, rarely changes)
+ * - System block 2: Template guidance (cacheable per fingerprint)
+ * - User block: Specific orbital details (not cached)
+ *
+ * Only works with full orbital definitions (not references).
+ */
+export declare function assembleCacheableOrbitalPrompt(orbital: OrbitalUnit, baseSystemPrompt: string): CacheableAssembledPrompt;
+/**
+ * Assemble prompts for multiple orbitals.
+ * Groups by fingerprint for batch efficiency.
+ */
+export declare function assembleMultiOrbitalPrompts(orbitals: OrbitalUnit[], baseSystemPrompt: string): Map<string, AssembledPrompt[]>;
+/**
+ * Get cache statistics for a set of orbitals.
+ */
+export declare function getCacheStats(orbitals: OrbitalUnit[]): {
+    totalOrbitals: number;
+    uniqueFingerprints: number;
+    potentialCacheHits: number;
+    templateMatches: number;
+};

package/dist/orbitals/cache/structural-templates.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Structural Templates for Cached Generation
+ *
+ * Pre-defined templates for common structural patterns.
+ *
+ * @packageDocumentation
+ */
+export interface StructuralTemplate {
+    /** Fingerprint pattern this template matches */
+    fingerprintPattern: string;
+    /** Human-readable name */
+    name: string;
+    /** Template guidance for generation */
+    guidance: string;
+    /** Example sections */
+    exampleSections: string[];
+}
+/**
+ * Templates for common structural patterns.
+ */
+export declare const STRUCTURAL_TEMPLATES: StructuralTemplate[];
+/**
+ * Find matching templates for a fingerprint.
+ */
+export declare function findMatchingTemplates(fingerprint: string): StructuralTemplate[];
+/**
+ * Get the best matching template for a fingerprint.
+ */
+export declare function getBestTemplate(fingerprint: string): StructuralTemplate | null;
+/**
+ * Get guidance for a fingerprint.
+ */
+export declare function getTemplateGuidance(fingerprint: string): string;

package/dist/orbitals/combiner/index.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Orbital Combiner
+ *
+ * Deterministically combines multiple Orbitals into a single OrbitalSchema.
+ * This removes the need for LLM involvement in the combining step.
+ *
+ * All UI is rendered via render_ui effects from traits (no static sections).
+ *
+ * NOTE: Validation is handled externally via `orbital validate` CLI.
+ * The combiner only assembles schemas - it does not validate them.
+ *
+ * @packageDocumentation
+ */
+import type { Orbital, OrbitalSchema, DomainContext } from "@almadar/core/types";
+export interface OrbitalSchemaValidationResult {
+    valid: boolean;
+    errors: Array<{
+        code: string;
+        message: string;
+        path?: string;
+    }>;
+    warnings: Array<{
+        code: string;
+        message: string;
+        path?: string;
+    }>;
+}
+type FullOrbitalUnit = Orbital;
+export interface CombinerOptions {
+    /** Application name */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Schema version */
+    version?: string;
+    /** Domain context */
+    domain?: DomainContext;
+    /** Whether to run validation (default: true) */
+    validate?: boolean;
+    /** Global theme */
+    theme?: string;
+    /** Default route (first page if not specified) */
+    defaultRoute?: string;
+}
+export interface CombinerResult {
+    /** Whether combining succeeded */
+    success: boolean;
+    /** The combined OrbitalSchema (if successful) */
+    schema?: OrbitalSchema;
+    /** Validation result (if validation was run) */
+    validation?: OrbitalSchemaValidationResult;
+    /** Error message (if failed) */
+    error?: string;
+    /** Statistics about the combining */
+    stats: {
+        totalOrbitals: number;
+        totalEntities: number;
+        totalPages: number;
+        totalTraits: number;
+    };
+}
+/**
+ * Combine multiple Orbitals into a single OrbitalSchema.
+ *
+ * This function performs deterministic merging:
+ * 1. Builds an OrbitalSchema from the Orbitals
+ * 2. Optionally runs validation
+ *
+ * Note: All UI is rendered via render_ui effects from traits.
+ *
+ * @example
+ * ```typescript
+ * const result = combineOrbitals([taskOrbital, userOrbital], {
+ *   name: 'My App',
+ *   validate: true,
+ * });
+ *
+ * if (result.success) {
+ *   // Write schema to file
+ *   await fs.writeFile('schema.json', JSON.stringify(result.schema, null, 2));
+ * } else {
+ *   console.error(result.error);
+ *   console.error(result.validation?.errors);
+ * }
+ * ```
+ */
+export declare function combineOrbitals(orbitals: FullOrbitalUnit[], options: CombinerOptions): CombinerResult;
+/**
+ * Combine orbitals and return only the schema (throws on error).
+ * Use this when you want a simple API and will handle errors upstream.
+ */
+export declare function combineOrbitalsToSchema(orbitals: FullOrbitalUnit[], options: CombinerOptions): OrbitalSchema;
+/**
+ * Estimate the combination complexity (for progress indication).
+ */
+export declare function estimateCombineComplexity(orbitals: FullOrbitalUnit[]): {
+    entities: number;
+    pages: number;
+    traits: number;
+    totalSections: number;
+};
+export {};

package/dist/orbitals/domain-language/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Domain Language Module
+ *
+ * MIGRATED: The core domain language engine has been moved to @almadar/core.
+ * This file re-exports everything from the core package for backward compatibility.
+ * Only agent-specific modules (prompts) remain here.
+ */
+export * from '@almadar/core/domain-language';
+export * from './prompts/index.js';

package/dist/orbitals/domain-language/prompts/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Domain Language Prompts
+ *
+ * Reusable prompt sections for Domain Language generation and fixing.
+ *
+ * @packageDocumentation
+ */
+export { ODL_SYNTAX_REFERENCE } from './odl-syntax.js';
+export { ODL_EXAMPLES } from './odl-examples.js';
+export { ODL_PATTERNS } from './odl-patterns.js';
+export { ODL_TO_SCHEMA_MAPPING } from './odl-to-schema.js';

package/dist/orbitals/domain-language/prompts/odl-examples.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Domain Language Examples
+ *
+ * Complete examples of Domain Language for common patterns.
+ *
+ * @packageDocumentation
+ */
+export declare const ODL_EXAMPLES = "\n## Complete Example\n\n### Entity\n\n```\nA Task is a persistent entity that:\n  - has title as text (required)\n  - has description as long text\n  - has status as enum [todo, in_progress, done] with default \"todo\"\n  - has dueDate as date\n  - belongs to User as assignee\n  - belongs to Project\n```\n\n### Page\n\n```\nTasksPage at /tasks:\n  - shows Task using TaskManagement\n  - view type: list\n  - is initial page\n```\n\n### Behavior\n\n```\nTaskManagement behavior:\n  States: Viewing, Editing, Creating\n  Initial: Viewing\n\n  Transitions:\n    - From Viewing to Viewing on INIT\n      then render page-header to main with title 'Tasks'\n      then render entity-table to center for Task\n\n    - From Viewing to Editing on EDIT_TASK\n      then render form-section to modal for Task\n\n    - From Editing to Viewing on SAVE_TASK\n      then persist update Task\n      then render null to modal\n      then emit TASK_UPDATED\n```\n\n## Multi-Entity Example\n\n```\n# Entities\n\nA User is a persistent entity that:\n  - has name as text (required)\n  - has email as text (required)\n  - has role as enum [admin, user, guest] with default \"user\"\n\nA Project is a persistent entity that:\n  - has name as text (required)\n  - has description as long text\n  - has status as enum [active, archived] with default \"active\"\n  - belongs to User as owner\n\nA Task is a persistent entity that:\n  - has title as text (required)\n  - has status as enum [todo, in_progress, done] with default \"todo\"\n  - has priority as number with default 0\n  - belongs to Project\n  - belongs to User as assignee\n\n# Pages\n\nProjectsPage at /projects:\n  - shows Project using ProjectManagement\n  - view type: list\n  - is initial page\n\nTasksPage at /projects/:projectId/tasks:\n  - shows Task using TaskManagement\n  - view type: list\n\n# Behaviors\n\nProjectManagement behavior:\n  States: List, Detail\n  Initial: List\n\n  Transitions:\n    - From List to List on INIT\n      then render entity-table to main for Project\n\n    - From List to Detail on VIEW_PROJECT\n      then render entity-detail to drawer for Project\n\nTaskManagement behavior:\n  States: Viewing, Editing\n  Initial: Viewing\n\n  Transitions:\n    - From Viewing to Viewing on INIT\n      then [\"render-ui\", \"main\", {\"type\": \"entity-table\", \"entity\": \"Task\", \"itemActions\": [{\"label\": \"Edit\", \"event\": \"EDIT_TASK\"}, {\"label\": \"Delete\", \"event\": \"DELETE_TASK\", \"variant\": \"danger\"}]}]\n\n    - From Viewing to Editing on EDIT_TASK\n      then render form-section to modal for Task\n\n    - From Editing to Viewing on SAVE_TASK\n      then persist update Task\n      then render null to modal\n```\n\n## Dashboard Example (Complex Patterns)\n\n```\nDashboard behavior:\n  States: Viewing\n  Initial: Viewing\n\n  Transitions:\n    - From Viewing to Viewing on INIT\n      then render page-header to main with title 'Dashboard'\n      then [\"render-ui\", \"center\", {\"type\": \"stats\", \"metrics\": [{\"field\": \"totalTasks\", \"label\": \"Total Tasks\"}, {\"field\": \"completedTasks\", \"label\": \"Completed\"}, {\"field\": \"overdueTasks\", \"label\": \"Overdue\"}]}]\n      then [\"render-ui\", \"bottom\", {\"type\": \"tabs\", \"tabs\": [{\"id\": \"overview\", \"label\": \"Overview\", \"event\": \"VIEW_OVERVIEW\"}, {\"id\": \"recent\", \"label\": \"Recent Activity\", \"event\": \"VIEW_RECENT\"}]}]\n```\n\n**Note**: Use inline JSON for `render-ui` effects with complex props (metrics, tabs, itemActions, cells).\n";

package/dist/orbitals/domain-language/prompts/odl-patterns.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Domain Language Common Patterns
+ *
+ * Reusable patterns for common application types.
+ *
+ * @packageDocumentation
+ */
+export declare const ODL_PATTERNS = "\n## Common Patterns\n\n### CRUD Pattern\n\n```\n[Entity]Management behavior:\n  States: List, Detail, Create, Edit\n  Initial: List\n\n  Transitions:\n    - From List to List on INIT\n      then render entity-table to main for [Entity]\n\n    - From List to Create on CREATE_[ENTITY]\n      then render form-section to modal for [Entity]\n\n    - From Create to List on SUBMIT_CREATE\n      then persist create [Entity]\n      then render null to modal\n\n    - From List to Detail on VIEW_[ENTITY]\n      then render entity-detail to drawer for [Entity]\n\n    - From Detail to Edit on EDIT_[ENTITY]\n      then render form-section to modal for [Entity]\n\n    - From Edit to Detail on SUBMIT_EDIT\n      then persist update [Entity]\n      then render null to modal\n\n    - From Detail to List on DELETE_[ENTITY]\n      then persist delete [Entity]\n      then render null to drawer\n```\n\n### Game Health Pattern\n\n```\nHealth behavior:\n  States: Healthy, Wounded, Critical, Dead\n  Initial: Healthy\n\n  Transitions:\n    - From Healthy to Wounded on TAKE_DAMAGE\n      if health >= 30 and health < 70\n      then update status to 'wounded'\n\n    - From Wounded to Critical on TAKE_DAMAGE\n      if health < 30\n      then update status to 'critical'\n\n    - From Critical to Dead on TAKE_DAMAGE\n      if health <= 0\n      then update isAlive to false\n      then emit ENTITY_DIED\n```\n\n### Approval Workflow Pattern\n\n```\nApprovalWorkflow behavior:\n  States: Draft, Pending, Approved, Rejected\n  Initial: Draft\n\n  Transitions:\n    - From Draft to Pending on SUBMIT\n      then update status to 'pending'\n      then emit APPROVAL_REQUESTED\n\n    - From Pending to Approved on APPROVE\n      then update status to 'approved'\n      then update approvedAt to now\n      then emit APPROVAL_GRANTED\n\n    - From Pending to Rejected on REJECT\n      then update status to 'rejected'\n      then emit APPROVAL_DENIED\n\n    - From Rejected to Draft on REVISE\n      then update status to 'draft'\n```\n\n### Form Validation Pattern\n\n```\nFormValidation behavior:\n  States: Idle, Validating, Valid, Invalid\n  Initial: Idle\n\n  Transitions:\n    - From Idle to Validating on VALIDATE\n      then update isValidating to true\n\n    - From Validating to Valid on VALIDATION_SUCCESS\n      then update isValidating to false\n      then update errors to null\n\n    - From Validating to Invalid on VALIDATION_FAILED\n      then update isValidating to false\n\n    - From Invalid to Validating on VALIDATE\n      then update isValidating to true\n\n    - From Valid to Idle on RESET\n      then update errors to null\n```\n\n### Dashboard Pattern\n\n```\nDashboardView behavior:\n  States: Loading, Ready\n  Initial: Loading\n\n  Transitions:\n    - From Loading to Ready on DATA_LOADED\n      then render stats to main\n      then render entity-cards to center\n\n    - From Ready to Loading on REFRESH\n      then emit FETCH_DASHBOARD_DATA\n```\n";

package/dist/orbitals/domain-language/prompts/odl-syntax.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Domain Language Syntax Reference
+ *
+ * Complete syntax reference for the Orbital Domain Language.
+ *
+ * @packageDocumentation
+ */
+export declare const ODL_SYNTAX_REFERENCE = "\n## Domain Language Syntax\n\n### Entity Definition\n\n```\nA [EntityName] is a [persistence] entity that:\n  - has [fieldName] as [type] (required|optional)\n  - has [fieldName] as [type] with default [value]\n  - belongs to [RelatedEntity]\n  - belongs to [RelatedEntity] as [alias]\n  - has many [RelatedEntity]s\n```\n\n**Persistence types:**\n- `persistent` - Stored in database (default)\n- `runtime` - Memory only, for games/UI state\n- `singleton` - Single instance, for config\n\n**Field types:**\n- `text` / `long text` - String fields\n- `number` / `currency` - Numeric fields\n- `yes/no` - Boolean fields\n- `date` / `timestamp` / `datetime` - Date fields\n- `enum [val1, val2]` - Enumeration\n- `list` / `object` - Complex types\n\n### Page Definition\n\n```\n[PageName] at /[path]:\n  - shows [Entity] using [TraitName]\n  - view type: [list|detail|create|edit|dashboard]\n  - is initial page\n```\n\n### Behavior Definition\n\n```\n[BehaviorName] behavior:\n  States: [State1], [State2], [State3]\n  Initial: [State1]\n\n  Transitions:\n    - From [State1] to [State2] on [EVENT_NAME]\n      if [guard condition]\n      then [effect1]\n      then [effect2]\n```\n\n### Section Headers\n\nDomain Language text is organized into sections:\n\n```\n# Entities\n[entity definitions]\n\n# Pages\n[page definitions]\n\n# Behaviors\n[behavior/trait definitions]\n```\n";

package/dist/orbitals/domain-language/prompts/odl-to-schema.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Domain Language to OrbitalSchema Mapping
+ *
+ * Reference for how Domain Language maps to OrbitalSchema JSON.
+ *
+ * @packageDocumentation
+ */
+export declare const ODL_TO_SCHEMA_MAPPING = "\n## Domain Language -> OrbitalSchema Mapping\n\n| Domain Language | OrbitalSchema |\n|-----------------|---------------|\n| \"A Task is...\" | `{ \"entity\": { \"name\": \"Task\", ... } }` |\n| \"persistent entity\" | `\"persistence\": \"persistent\"` |\n| \"runtime entity\" | `\"persistence\": \"runtime\"` |\n| \"singleton entity\" | `\"persistence\": \"singleton\"` |\n| \"has X as text\" | `{ \"name\": \"X\", \"type\": \"string\" }` |\n| \"has X as number\" | `{ \"name\": \"X\", \"type\": \"number\" }` |\n| \"has X as yes/no\" | `{ \"name\": \"X\", \"type\": \"boolean\" }` |\n| \"has X as enum [a, b]\" | `{ \"name\": \"X\", \"type\": \"enum\", \"values\": [\"a\", \"b\"] }` |\n| \"belongs to Y\" | `{ \"type\": \"relation\", \"relation\": { \"entity\": \"Y\" } }` |\n| \"belongs to Y as alias\" | `{ \"name\": \"alias\", \"type\": \"relation\", \"relation\": { \"entity\": \"Y\" } }` |\n| \"States: A, B\" | `\"states\": [{ \"name\": \"A\" }, { \"name\": \"B\" }]` |\n| \"Initial: A\" | `{ \"name\": \"A\", \"isInitial\": true }` |\n| \"From X to Y on Z\" | `{ \"from\": \"X\", \"to\": \"Y\", \"event\": \"Z\" }` |\n| \"if health >= 0\" | `\"guard\": [\">=\", \"@entity.health\", 0]` |\n| \"then update status to 'done'\" | `\"effects\": [[\"set\", \"@entity.status\", \"done\"]]` |\n| \"then emit EVENT\" | `\"effects\": [[\"emit\", \"EVENT\"]]` |\n| \"then render X to slot\" | `\"effects\": [[\"render-ui\", \"slot\", { \"type\": \"X\" }]]` |\n| \"then persist create Task\" | `\"effects\": [[\"persist\", \"create\", \"Task\"]]` |\n| \"then navigate to /path\" | `\"effects\": [[\"navigate\", \"/path\"]]` |\n\n## Conversion Process\n\n1. **Parse Domain Language** - Split into sections (Entities, Pages, Behaviors)\n2. **Extract entities** - Parse \"A X is...\" definitions\n3. **Extract pages** - Parse \"[Name] at /path\" definitions\n4. **Extract behaviors** - Parse \"[Name] behavior:\" definitions\n5. **Parse guards** - Convert human-readable conditions to S-expressions\n6. **Parse effects** - Convert human-readable effects to S-expressions\n7. **Assemble schema** - Build OrbitalSchema JSON structure\n\n## CLI Commands\n\n```bash\n# Convert Domain Language to OrbitalSchema\nnpx kflow domain:to-schema input.txt -o output.orb\n\n# Convert OrbitalSchema to Domain Language\nnpx kflow domain:to-text input.orb -o output.txt\n\n# Validate round-trip conversion\nnpx kflow domain:validate input.orb --verbose\n```\n";

package/dist/orbitals/generation/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Orbital Generation Module
+ *
+ * Exports generation utilities for eval/testing purposes.
+ * NOTE: The actual skill uses the DeepAgent/subagent pattern where
+ * agents use parent tools to write schema - not programmatic generation.
+ *
+ * @packageDocumentation
+ */
+export { generateFullOrbital, generateFullOrbitalsParallel, decomposeToOrbitals, estimateCacheSavings, PROVIDER_CONCURRENCY_LIMITS, type GenerationLog, type OrbitalGenerationOptions, type OrbitalGenerationResult, type ParallelGenerationOptions, type ParallelGenerationResult, type ExtractedRequirements, type DecomposeOptions, } from './orbital-generator.js';