@almadar/agent 1.3.0 → 1.3.1

package/dist/agent/index.js

@@ -1,11 +1,12 @@
 import { AgentDomainCategorySchema, isOrbitalDefinition, isEntityReference, getTraitName } from '@almadar/core/types';
+import { getFullOrbitalPrompt, getRequirementsTraitPrompt, getKeyBehaviorsReference, getSExprQuickRef, getCommonErrorsSection, getArchitectureSection } from '@almadar/skills';
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod';
+import { LLMClient, ANTHROPIC_MODELS, createAnthropicClient, OPENROUTER_MODELS, createOpenRouterClient, KIMI_MODELS, createKimiClient, OPENAI_MODELS, createOpenAIClient, DEEPSEEK_MODELS, createDeepSeekClient } from '@almadar/llm';
 import { FilesystemBackend, createDeepAgent } from 'deepagents';
 import { MemorySaver } from '@langchain/langgraph';
 export { Command } from '@langchain/langgraph';
 import { v4 } from 'uuid';
-import { ANTHROPIC_MODELS, createAnthropicClient, OPENAI_MODELS, createOpenAIClient, DEEPSEEK_MODELS, createDeepSeekClient, LLMClient } from '@almadar/llm';
-import { tool } from '@langchain/core/tools';
-import { z } from 'zod';
 import { exec, spawn } from 'child_process';
 import * as path from 'path';
 import { promisify } from 'util';
@@ -13,7 +14,6 @@ import * as fs4 from 'fs/promises';
 import * as domain_language_star from '@almadar/core/domain-language';
 import * as fs3 from 'fs';
 import crypto, { randomUUID } from 'crypto';
-import { getFullOrbitalPrompt, getRequirementsTraitPrompt, getKeyBehaviorsReference, getSExprQuickRef, getCommonErrorsSection, getArchitectureSection } from '@almadar/skills';
 import { GitHubIntegration } from '@almadar/integrations';
 import { BaseCheckpointSaver } from '@langchain/langgraph-checkpoint';
 
@@ -308,6 +308,855 @@ var init_cache = __esm({
     init_prompt_assembler();
   }
 });
+
+// src/orbitals/shared/constants.ts
+var PROVIDER_CONCURRENCY_LIMITS, PROVIDER_BATCH_SIZES, BATCH_MAX_TOKENS;
+var init_constants = __esm({
+  "src/orbitals/shared/constants.ts"() {
+    PROVIDER_CONCURRENCY_LIMITS = {
+      anthropic: 3,
+      openai: 5,
+      deepseek: 3,
+      kimi: 3,
+      openrouter: 5
+    };
+    PROVIDER_BATCH_SIZES = {
+      anthropic: 3,
+      // Anthropic works well with 3 orbitals per call
+      openai: 5,
+      // OpenAI can handle more
+      deepseek: 3,
+      // Conservative for DeepSeek
+      kimi: 3,
+      // Conservative for Kimi
+      openrouter: 5
+      // OpenRouter proxies multiple providers
+    };
+    BATCH_MAX_TOKENS = 12e3;
+  }
+});
+function getEntityName2(entity) {
+  if (isEntityReference(entity)) {
+    return entity.replace(".entity", "");
+  }
+  return entity.name;
+}
+function getInlineEntity3(entity) {
+  if (isEntityReference(entity)) {
+    return null;
+  }
+  return entity;
+}
+function getFieldNames(entity) {
+  const inlineEntity = getInlineEntity3(entity);
+  if (!inlineEntity?.fields?.length) {
+    return "N/A";
+  }
+  return inlineEntity.fields.map((f) => f.name).join(", ");
+}
+function createLog(level, message, data) {
+  return {
+    timestamp: Date.now(),
+    level,
+    message,
+    data
+  };
+}
+function buildContextSection2(orbital) {
+  const parts = [];
+  if (orbital.domainContext) {
+    const ctx = orbital.domainContext;
+    parts.push(`DomainContext: category=${ctx.category || "business"}`);
+    if (ctx.vocabulary) {
+      parts.push(`Vocabulary: ${JSON.stringify(ctx.vocabulary)}`);
+    }
+    if (ctx.requestFragment) {
+      parts.push(`RequestFragment: "${ctx.requestFragment}"`);
+    }
+  }
+  if (orbital.design) {
+    const d = orbital.design;
+    if (d.style) parts.push(`Style: ${d.style}`);
+    if (d.uxHints) {
+      const hints = d.uxHints;
+      if (hints.flowPattern) parts.push(`FlowPattern: ${hints.flowPattern}`);
+      if (hints.listPattern) parts.push(`ListPattern: ${hints.listPattern}`);
+      if (hints.formPattern) parts.push(`FormPattern: ${hints.formPattern}`);
+    }
+  }
+  return parts.length > 0 ? `Context: ${parts.join(", ")}
+` : "";
+}
+function buildConnectivitySection(orbital) {
+  const parts = [];
+  if (orbital.emits?.length) {
+    parts.push(`Emits: ${orbital.emits.join(", ")}`);
+  }
+  if (orbital.listens?.length) {
+    parts.push(`Listens: ${orbital.listens.map((l) => `${l.event}\u2192${l.triggers}`).join(", ")}`);
+  }
+  return parts.join("\n");
+}
+function chunkArray(array, size) {
+  const chunks = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
+}
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+var init_utils = __esm({
+  "src/orbitals/shared/utils.ts"() {
+  }
+});
+
+// src/orbitals/shared/index.ts
+var init_shared = __esm({
+  "src/orbitals/shared/index.ts"() {
+    init_constants();
+    init_utils();
+  }
+});
+function extractSharedContext(orbitals) {
+  const vocabulary = {};
+  const styles = /* @__PURE__ */ new Set();
+  const patterns = /* @__PURE__ */ new Set();
+  const relationships = [];
+  for (const orbital of orbitals) {
+    if (orbital.domainContext?.vocabulary) {
+      Object.assign(vocabulary, orbital.domainContext.vocabulary);
+    }
+    if (orbital.design?.style) {
+      styles.add(orbital.design.style);
+    }
+  }
+  new Map(orbitals.map((o) => [o.name, o]));
+  for (const orbital of orbitals) {
+    if (orbital.emits) {
+      for (const event of orbital.emits) {
+        for (const other of orbitals) {
+          if (other === orbital) continue;
+          if (other.listens) {
+            const listener = other.listens.find((l) => l.event === event.event);
+            if (listener) {
+              relationships.push({
+                emitter: orbital.name,
+                event: event.event,
+                listener: other.name,
+                handler: listener.triggers
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  return {
+    domainVocabulary: Object.keys(vocabulary).length > 0 ? vocabulary : void 0,
+    designStyle: styles.size === 1 ? Array.from(styles)[0] : void 0,
+    commonPatterns: patterns.size > 0 ? Array.from(patterns) : void 0,
+    eventRelationships: relationships.length > 0 ? relationships : void 0
+  };
+}
+function assembleBatchPrompt(orbitals, options = {}) {
+  const {
+    baseSystemPrompt = getFullOrbitalPrompt(),
+    includeConnectivity = true
+  } = options;
+  if (orbitals.length === 0) {
+    throw new Error("Cannot assemble batch prompt for empty orbitals array");
+  }
+  const sharedContext = extractSharedContext(orbitals);
+  const batchHeader = buildBatchHeader(orbitals, sharedContext);
+  const orbitalSections = orbitals.map(
+    (orbital, index) => buildOrbitalSection(orbital, index + 1, orbitals.length, includeConnectivity)
+  );
+  const outputSection = buildOutputSection(orbitals);
+  const prompt = `${baseSystemPrompt}
+
+${"=".repeat(60)}
+BATCH GENERATION: ${orbitals.length} ORBITALS
+${"=".repeat(60)}
+
+${batchHeader}
+
+${orbitalSections.join("\n\n")}
+
+${outputSection}`;
+  const fingerprint = generateBatchFingerprint(orbitals);
+  return {
+    prompt,
+    fingerprint,
+    usedCachedTemplate: false,
+    // Batch doesn't use templates yet
+    orbitalCount: orbitals.length,
+    orbitalNames: orbitals.map((o) => o.name)
+  };
+}
+function buildBatchHeader(orbitals, sharedContext) {
+  const lines = [
+    `## Batch Overview`,
+    `- Total Orbitals: ${orbitals.length}`,
+    `- Orbitals: ${orbitals.map((o) => o.name).join(", ")}`
+  ];
+  if (sharedContext.designStyle) {
+    lines.push(`- Design Style: ${sharedContext.designStyle}`);
+  }
+  if (sharedContext.commonPatterns?.length) {
+    lines.push(`- Common Patterns: ${sharedContext.commonPatterns.join(", ")}`);
+  }
+  if (sharedContext.domainVocabulary && Object.keys(sharedContext.domainVocabulary).length > 0) {
+    lines.push(`
+## Shared Domain Vocabulary`);
+    for (const [term, definition] of Object.entries(sharedContext.domainVocabulary)) {
+      lines.push(`- ${term}: ${definition}`);
+    }
+  }
+  if (sharedContext.eventRelationships?.length) {
+    lines.push(`
+## Cross-Orbital Event Relationships`);
+    for (const rel of sharedContext.eventRelationships) {
+      lines.push(`- ${rel.emitter} emits "${rel.event}" \u2192 ${rel.listener} handles with "${rel.handler}"`);
+    }
+  }
+  return lines.join("\n");
+}
+function buildOrbitalSection(orbital, index, total, includeConnectivity) {
+  const entityName = getEntityName2(orbital.entity);
+  const fieldNames = getFieldNames(orbital.entity);
+  const contextSection = buildContextSection2(orbital);
+  const connectivitySection = includeConnectivity ? buildConnectivitySection(orbital) : "";
+  return `---
+## ORBITAL ${index}/${total}: ${orbital.name}
+
+**Entity**: ${entityName}
+**Persistence**: ${orbital.entity.persistence || "persistent"}
+**Fields**: ${fieldNames}
+**Traits**: ${orbital.traits.map((t) => typeof t === "string" ? t : "ref" in t ? t.ref : t.name).join(", ")}
+${contextSection}${connectivitySection ? `**Connectivity**:
+${connectivitySection}
+` : ""}
+Generate a complete FullOrbitalUnit for ${orbital.name} with:
+- Full field definitions with types and validation
+- Trait state machines with transitions and effects
+- Business rule validation using "guard" S-expression on SAVE transitions
+- Pages with trait references
+- domainContext with category, vocabulary, and requestFragment
+- design with style and uxHints (flowPattern, listPattern, formPattern)
+${orbital.emits?.length ? "- PRESERVE emits: " + orbital.emits.map((e) => e.event).join(", ") : ""}
+${orbital.listens?.length ? "- PRESERVE listens: " + orbital.listens.map((l) => l.event).join(", ") : ""}`;
+}
+function buildOutputSection(orbitals) {
+  return `---
+## OUTPUT FORMAT
+
+Return a JSON object with this exact structure:
+
+\`\`\`json
+{
+  "orbitals": [
+${orbitals.map((o, i) => `    {
+      "name": "${o.name}",
+      // ... complete FullOrbitalUnit for ${o.name}
+    }${i < orbitals.length - 1 ? "," : ""}`).join("\n")}
+  ]
+}
+\`\`\`
+
+**CRITICAL RULES:**
+1. Return a SINGLE JSON object with an "orbitals" array
+2. Each element in the array is a complete FullOrbitalUnit
+3. Maintain the order: ${orbitals.map((o) => o.name).join(", ")}
+4. PRESERVE all emits/listens as specified in each orbital section
+5. Use shared domain vocabulary consistently across all orbitals
+6. Ensure cross-orbital event wiring is maintained
+`;
+}
+function generateBatchFingerprint(orbitals) {
+  const fingerprints = orbitals.map((o) => computeOrbitalFingerprint(o));
+  const combined = fingerprints.sort().join("|");
+  let hash = 0;
+  for (let i = 0; i < combined.length; i++) {
+    const char = combined.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return `batch:${orbitals.length}:${Math.abs(hash).toString(16).slice(0, 8)}`;
+}
+function splitIntoBatches(orbitals, options = {}) {
+  const {
+    maxBatchSize = 3,
+    preserveRelationships = true
+  } = options;
+  if (!preserveRelationships) {
+    return chunkArray(orbitals, maxBatchSize);
+  }
+  const clusters = groupByRelationships(orbitals);
+  const batches = [];
+  for (const cluster of clusters) {
+    if (cluster.length <= maxBatchSize) {
+      batches.push(cluster);
+    } else {
+      batches.push(...chunkArray(cluster, maxBatchSize));
+    }
+  }
+  return batches;
+}
+function groupByRelationships(orbitals) {
+  const visited = /* @__PURE__ */ new Set();
+  const clusters = [];
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const orbital of orbitals) {
+    if (!adjacency.has(orbital.name)) {
+      adjacency.set(orbital.name, /* @__PURE__ */ new Set());
+    }
+    if (orbital.emits) {
+      for (const event of orbital.emits) {
+        for (const other of orbitals) {
+          if (other === orbital) continue;
+          if (other.listens?.some((l) => l.event === event.event)) {
+            adjacency.get(orbital.name)?.add(other.name);
+            if (!adjacency.has(other.name)) {
+              adjacency.set(other.name, /* @__PURE__ */ new Set());
+            }
+            adjacency.get(other.name)?.add(orbital.name);
+          }
+        }
+      }
+    }
+  }
+  function dfs(orbital, cluster) {
+    visited.add(orbital.name);
+    cluster.push(orbital);
+    const neighbors = adjacency.get(orbital.name) || /* @__PURE__ */ new Set();
+    for (const neighborName of neighbors) {
+      if (!visited.has(neighborName)) {
+        const neighbor = orbitals.find((o) => o.name === neighborName);
+        if (neighbor) {
+          dfs(neighbor, cluster);
+        }
+      }
+    }
+  }
+  for (const orbital of orbitals) {
+    if (!visited.has(orbital.name)) {
+      const cluster = [];
+      dfs(orbital, cluster);
+      clusters.push(cluster);
+    }
+  }
+  return clusters;
+}
+function estimateBatchTokens(orbitals) {
+  const baseTokens = 2e3;
+  const perOrbitalTokens = 800;
+  return baseTokens + orbitals.length * perOrbitalTokens;
+}
+function willBatchFit(orbitals, maxTokens = 12e3) {
+  const estimated = estimateBatchTokens(orbitals);
+  return estimated < maxTokens * 0.5;
+}
+var init_prompt_assembler2 = __esm({
+  "src/orbitals/batch/prompt-assembler.ts"() {
+    init_cache();
+    init_shared();
+  }
+});
+
+// src/orbitals/batch/concurrency.ts
+function createConcurrencyController(maxConcurrency) {
+  let activeCount = 0;
+  const queue = [];
+  return {
+    async acquire() {
+      if (activeCount < maxConcurrency) {
+        activeCount++;
+        return Promise.resolve();
+      }
+      return new Promise((resolve2) => {
+        queue.push(() => {
+          activeCount++;
+          resolve2();
+        });
+      });
+    },
+    release() {
+      activeCount = Math.max(0, activeCount - 1);
+      const next = queue.shift();
+      if (next) {
+        next();
+      }
+    },
+    get activeCount() {
+      return activeCount;
+    },
+    get waitingCount() {
+      return queue.length;
+    }
+  };
+}
+async function runWithConcurrency(tasks, options) {
+  const { concurrency, onProgress } = options;
+  const controller = createConcurrencyController(concurrency);
+  const results = [];
+  let completed = 0;
+  await Promise.all(
+    tasks.map(async (task, index) => {
+      await controller.acquire();
+      try {
+        results[index] = await task();
+        completed++;
+        onProgress?.(completed, tasks.length);
+      } finally {
+        controller.release();
+      }
+    })
+  );
+  return results;
+}
+async function asyncMapWithConcurrency2(items, mapper, concurrency) {
+  return runWithConcurrency(
+    items.map((item, index) => () => mapper(item, index)),
+    { concurrency }
+  );
+}
+var init_concurrency = __esm({
+  "src/orbitals/batch/concurrency.ts"() {
+  }
+});
+
+// src/orbitals/batch/batch-generator.ts
+async function generateOrbitalsBatch(client, orbitals, options = {}) {
+  const startTime = Date.now();
+  const aggregateLogs = [];
+  const provider = client.getProvider();
+  const mode = options.mode || "single-call";
+  const maxConcurrency = options.concurrency ?? PROVIDER_CONCURRENCY_LIMITS[provider];
+  const maxBatchSize = options.batchSize ?? PROVIDER_BATCH_SIZES[provider];
+  console.log(`[BatchGenerator] Starting batch generation: ${orbitals.length} orbitals, mode=${mode}, concurrency=${maxConcurrency}`);
+  aggregateLogs.push(createLog("info", `Starting batch generation`, {
+    totalOrbitals: orbitals.length,
+    mode,
+    provider,
+    maxConcurrency,
+    maxBatchSize
+  }));
+  const batches = splitIntoBatches(orbitals, {
+    maxBatchSize,
+    preserveRelationships: options.preserveRelationships ?? true
+  });
+  console.log(`[BatchGenerator] Split into ${batches.length} batches: [${batches.map((b) => b.length).join(", ")}]`);
+  aggregateLogs.push(createLog("info", `Split into ${batches.length} batches`, {
+    batchSizes: batches.map((b) => b.length)
+  }));
+  options.onBatchProgress?.({
+    type: "batch_start",
+    batchIndex: 0,
+    totalBatches: batches.length,
+    completedOrbitals: 0,
+    totalOrbitals: orbitals.length
+  });
+  let batchResults;
+  if (mode === "parallel-individual") {
+    batchResults = await generateParallelIndividual(client, orbitals, {
+      ...options,
+      concurrency: maxConcurrency,
+      onBatchProgress: options.onBatchProgress
+    });
+  } else if (mode === "single-call") {
+    batchResults = await generateSingleCallBatches(client, batches, {
+      ...options,
+      concurrency: maxConcurrency,
+      onBatchProgress: options.onBatchProgress
+    });
+  } else {
+    batchResults = await generateAdaptive(client, orbitals, batches, {
+      ...options,
+      concurrency: maxConcurrency,
+      maxBatchSize,
+      onBatchProgress: options.onBatchProgress
+    });
+  }
+  const totalDurationMs = Date.now() - startTime;
+  const allResults = batchResults.flatMap((b) => b.results);
+  const successful = allResults.filter((r) => r.success).length;
+  const failed = allResults.length - successful;
+  const totalTokens = batchResults.reduce(
+    (sum, b) => sum + (b.usage?.totalTokens ?? 0),
+    0
+  );
+  console.log(`[BatchGenerator] Complete: ${successful}/${allResults.length} successful, ${totalTokens} tokens, ${totalDurationMs}ms`);
+  aggregateLogs.push(createLog("info", `Batch generation completed`, {
+    totalDurationMs,
+    successful,
+    failed,
+    totalTokens,
+    totalBatches: batches.length
+  }));
+  options.onBatchProgress?.({
+    type: "batch_complete",
+    batchIndex: batches.length - 1,
+    totalBatches: batches.length,
+    completedOrbitals: successful,
+    totalOrbitals: orbitals.length
+  });
+  return {
+    results: allResults.map((r) => ({
+      orbital: r.orbital,
+      fingerprint: "",
+      // TODO: compute from orbital
+      usedTemplate: false,
+      usage: void 0,
+      validation: r.success ? { valid: true, errorCount: 0, warningCount: 0 } : { valid: false, errorCount: 1, warningCount: 0 },
+      logs: []
+    })),
+    totalDurationMs,
+    aggregateLogs,
+    summary: {
+      total: allResults.length,
+      successful,
+      failed,
+      totalTokens
+    },
+    batchResults,
+    totalBatches: batches.length
+  };
+}
+async function generateSingleCallBatches(client, batches, options) {
+  let completedOrbitals = 0;
+  const totalOrbitals = batches.reduce((sum, b) => sum + b.length, 0);
+  return asyncMapWithConcurrency2(
+    batches,
+    async (batch, batchIndex) => {
+      return generateSingleBatch(client, batch, batchIndex, {
+        ...options,
+        onProgress: (completedInBatch) => {
+          const newCompleted = completedOrbitals + completedInBatch;
+          options.onBatchProgress?.({
+            type: "orbital_complete",
+            batchIndex,
+            totalBatches: batches.length,
+            completedOrbitals: newCompleted,
+            totalOrbitals
+          });
+          completedOrbitals = newCompleted;
+        }
+      });
+    },
+    options.concurrency
+  );
+}
+async function generateParallelIndividual(client, orbitals, options) {
+  const batches = orbitals.map((o) => [o]);
+  return generateSingleCallBatches(client, batches, {
+    ...options,
+    concurrency: options.concurrency
+  });
+}
+async function generateAdaptive(client, orbitals, batches, options) {
+  const allFit = batches.every((batch) => willBatchFit(batch, BATCH_MAX_TOKENS));
+  if (allFit) {
+    console.log(`[BatchGenerator] Adaptive: Using single-call batches (${batches.length} batches)`);
+    return generateSingleCallBatches(client, batches, options);
+  }
+  console.log(`[BatchGenerator] Adaptive: Using parallel-individual (batches too large)`);
+  return generateParallelIndividual(client, orbitals, options);
+}
+async function generateSingleBatch(client, orbitals, batchIndex, options) {
+  const batchStartTime = Date.now();
+  const logs = [];
+  console.log(`[BatchGenerator] Starting batch ${batchIndex + 1}: ${orbitals.map((o) => o.name).join(", ")}`);
+  logs.push(createLog("info", `Starting batch ${batchIndex + 1}`, {
+    orbitalCount: orbitals.length,
+    orbitals: orbitals.map((o) => o.name)
+  }));
+  try {
+    const batchPrompt = assembleBatchPrompt(orbitals);
+    console.log(`[BatchGenerator] Batch ${batchIndex + 1} prompt assembled: ${batchPrompt.prompt.length} chars`);
+    logs.push(createLog("info", `Batch prompt assembled`, {
+      promptLength: batchPrompt.prompt.length,
+      estimatedTokens: Math.ceil(batchPrompt.prompt.length / 4)
+    }));
+    const llmResult = await client.callWithMetadata({
+      systemPrompt: batchPrompt.prompt,
+      userPrompt: "Generate all orbitals in the batch. Return valid JSON matching the output format specified.",
+      maxTokens: BATCH_MAX_TOKENS,
+      skipSchemaValidation: true
+    });
+    logs.push(createLog("info", `LLM call completed`, {
+      promptTokens: llmResult.usage?.promptTokens,
+      completionTokens: llmResult.usage?.completionTokens
+    }));
+    const parsed = parseBatchResult(llmResult.data, orbitals);
+    console.log(`[BatchGenerator] Batch ${batchIndex + 1} parsed: ${parsed.filter((p) => p.success).length}/${parsed.length} successful`);
+    for (let i = 0; i < parsed.length; i++) {
+      options.onProgress?.(i + 1);
+    }
+    const durationMs = Date.now() - batchStartTime;
+    logs.push(createLog("info", `Batch ${batchIndex + 1} completed`, {
+      durationMs,
+      successful: parsed.filter((r) => r.success).length
+    }));
+    return {
+      orbitals,
+      results: parsed,
+      usage: llmResult.usage ?? void 0,
+      durationMs,
+      logs
+    };
+  } catch (error) {
+    const errorMessage = getErrorMessage(error);
+    console.error(`[BatchGenerator] Batch ${batchIndex + 1} FAILED: ${errorMessage}`);
+    logs.push(createLog("error", `Batch ${batchIndex + 1} failed`, {
+      error: errorMessage
+    }));
+    return {
+      orbitals,
+      results: orbitals.map((o) => ({
+        orbital: o,
+        success: false,
+        error: errorMessage
+      })),
+      durationMs: Date.now() - batchStartTime,
+      logs
+    };
+  }
+}
+function parseBatchResult(data, expectedOrbitals) {
+  if (!data || typeof data !== "object") {
+    return expectedOrbitals.map((o) => ({
+      orbital: o,
+      success: false,
+      error: "Invalid response: expected object"
+    }));
+  }
+  const obj = data;
+  if (!obj.orbitals || !Array.isArray(obj.orbitals)) {
+    return expectedOrbitals.map((o) => ({
+      orbital: o,
+      success: false,
+      error: "Invalid response: missing orbitals array"
+    }));
+  }
+  const results = obj.orbitals;
+  return expectedOrbitals.map((expected, index) => {
+    const result = results[index];
+    if (!result) {
+      return {
+        orbital: expected,
+        success: false,
+        error: `Missing result for orbital ${index + 1}`
+      };
+    }
+    if (!result.name) {
+      return {
+        orbital: expected,
+        success: false,
+        error: "Generated orbital missing name"
+      };
+    }
+    return {
+      orbital: result,
+      success: true
+    };
+  });
+}
+var init_batch_generator = __esm({
+  "src/orbitals/batch/batch-generator.ts"() {
+    init_shared();
+    init_prompt_assembler2();
+    init_concurrency();
+  }
+});
+
+// src/orbitals/batch/index.ts
+var init_batch = __esm({
+  "src/orbitals/batch/index.ts"() {
+    init_batch_generator();
+    init_prompt_assembler2();
+    init_concurrency();
+  }
+});
+
+// src/tools/orbital-batch-subagent.ts
+var orbital_batch_subagent_exports = {};
+__export(orbital_batch_subagent_exports, {
+  createOrbitalBatchSubagentTool: () => createOrbitalBatchSubagentTool
+});
+function createOrbitalBatchSubagentTool(options = {}) {
+  let eventCallback = options.onSubagentEvent;
+  let completeCallback = options.onBatchComplete;
+  const requirements = options.requirements;
+  const workDir = options.workDir;
+  const setEventCallback = (callback) => {
+    eventCallback = callback;
+  };
+  const setBatchCompleteCallback = (callback) => {
+    completeCallback = callback;
+  };
+  const emitEvent = (orbitalName, orbitalIndex, totalOrbitals, type, data) => {
+    if (eventCallback) {
+      eventCallback(orbitalName, orbitalIndex, totalOrbitals, {
+        type,
+        data,
+        timestamp: Date.now()
+      });
+    }
+  };
+  const batchTool = tool(
+    async ({ orbitals, options: batchOptions }) => {
+      if (!orbitals || orbitals.length === 0) {
+        return JSON.stringify({
+          success: false,
+          error: "No orbitals provided for batch generation.",
+          orbitals: []
+        });
+      }
+      console.log(`[OrbitalBatchSubagent] Starting batch generation for ${orbitals.length} orbitals`);
+      try {
+        emitEvent("batch", 0, 1, "message", {
+          content: `Starting batch generation for ${orbitals.length} orbitals`,
+          role: "assistant",
+          isComplete: false
+        });
+        emitEvent("batch", 0, 1, "todo_update", {
+          todos: orbitals.map((o, i) => ({
+            id: `orbital-${i}`,
+            task: `Generate ${o.name}`,
+            status: "pending"
+          }))
+        });
+        const client = new LLMClient({
+          provider: options.provider || "anthropic",
+          model: options.model || "claude-sonnet-4-20250514"
+        });
+        const generationOptions = {
+          mode: batchOptions?.mode || "adaptive",
+          batchSize: batchOptions?.batchSize,
+          concurrency: batchOptions?.maxConcurrency ?? PROVIDER_CONCURRENCY_LIMITS[client.getProvider()],
+          preserveRelationships: batchOptions?.preserveRelationships ?? true,
+          requirements,
+          onBatchProgress: (event) => {
+            if (event.type === "orbital_complete" && event.orbitalName) {
+              emitEvent(event.orbitalName || "batch", event.batchIndex, event.totalBatches, "todo_update", {
+                todos: orbitals.map((o, i) => ({
+                  id: `orbital-${i}`,
+                  task: `Generate ${o.name}`,
+                  status: o.name === event.orbitalName ? "completed" : event.completedOrbitals > i ? "completed" : "pending"
+                }))
+              });
+            }
+            emitEvent(event.orbitalName || "batch", event.batchIndex, event.totalBatches, "generation_log", {
+              level: "info",
+              message: `Progress: ${event.completedOrbitals}/${event.totalOrbitals} orbitals complete`,
+              data: {
+                batchIndex: event.batchIndex,
+                completedOrbitals: event.completedOrbitals,
+                totalOrbitals: event.totalOrbitals
+              }
+            });
+          }
+        };
+        emitEvent("batch", 0, 1, "tool_call", {
+          tool: "generateOrbitalsBatch",
+          args: {
+            orbitalCount: orbitals.length,
+            mode: generationOptions.mode,
+            concurrency: generationOptions.concurrency
+          }
+        });
+        const result = await generateOrbitalsBatch(client, orbitals, generationOptions);
+        emitEvent("batch", result.totalBatches - 1, result.totalBatches, "todo_update", {
+          todos: orbitals.map((o, i) => ({
+            id: `orbital-${i}`,
+            task: `Generate ${o.name}`,
+            status: result.batchResults.some(
+              (b) => b.results.some((r) => r.orbital.name === o.name && r.success)
+            ) ? "completed" : "failed"
+          }))
+        });
+        const generatedOrbitals = result.results.filter((r) => r.orbital).map((r) => r.orbital);
+        const successCount = generatedOrbitals.length;
+        const failedCount = orbitals.length - successCount;
+        emitEvent("batch", result.totalBatches - 1, result.totalBatches, "message", {
+          content: `Batch generation complete: ${successCount}/${orbitals.length} orbitals generated successfully`,
+          role: "assistant",
+          isComplete: true
+        });
+        if (workDir && completeCallback && generatedOrbitals.length > 0) {
+          try {
+            await completeCallback(generatedOrbitals, 0, 1);
+            emitEvent("batch", result.totalBatches - 1, result.totalBatches, "generation_log", {
+              level: "info",
+              message: `Persisted ${generatedOrbitals.length} orbitals`
+            });
+          } catch (persistError) {
+            console.error(`[OrbitalBatchSubagent] Failed to persist orbitals:`, persistError);
+            emitEvent("batch", result.totalBatches - 1, result.totalBatches, "generation_log", {
+              level: "warn",
+              message: "Failed to persist some orbitals",
+              data: { error: String(persistError) }
+            });
+          }
+        }
+        return JSON.stringify({
+          success: successCount === orbitals.length,
+          generated: successCount,
+          failed: failedCount,
+          total: orbitals.length,
+          orbitals: generatedOrbitals,
+          duration: result.totalDurationMs,
+          totalTokens: result.summary.totalTokens,
+          batches: result.totalBatches
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`[OrbitalBatchSubagent] Batch generation failed:`, errorMessage);
+        emitEvent("batch", 0, 1, "error", {
+          error: errorMessage,
+          code: "BATCH_GENERATION_ERROR"
+        });
+        return JSON.stringify({
+          success: false,
+          error: errorMessage,
+          orbitals: []
+        });
+      }
+    },
+    {
+      name: "generate_orbitals_batch",
+      description: "Generate multiple orbitals in optimized batches. MUCH FASTER than calling generate_orbital multiple times. Use this when generating 3+ orbitals. Supports parallel generation with automatic concurrency control.",
+      schema: OrbitalBatchInputSchema
+    }
+  );
+  return {
+    tool: batchTool,
+    setEventCallback,
+    setBatchCompleteCallback
+  };
+}
+var OrbitalBatchInputSchema;
+var init_orbital_batch_subagent = __esm({
+  "src/tools/orbital-batch-subagent.ts"() {
+    init_shared();
+    init_batch();
+    OrbitalBatchInputSchema = z.object({
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      orbitals: z.array(z.any()).describe("Array of OrbitalUnits to generate"),
+      options: z.object({
+        mode: z.enum(["single-call", "parallel-individual", "adaptive"]).optional().default("adaptive"),
+        batchSize: z.number().optional(),
+        maxConcurrency: z.number().optional(),
+        preserveRelationships: z.boolean().optional().default(true)
+      }).optional().describe("Batch generation options")
+    });
+  }
+});
 var DANGEROUS_COMMANDS = [
   "rm",
   "rmdir",
@@ -1535,8 +2384,8 @@ function createGenerateOrbitalDomainTool(options = {}) {
           orbitalName: spec.name
         });
         const client = new LLMClient({
-          provider: "anthropic",
-          model: "claude-sonnet-4-20250514",
+          provider: options.provider ?? "anthropic",
+          model: options.model ?? "claude-sonnet-4-20250514",
           temperature: 0
         });
         const userPrompt = buildDynamicUserPrompt(spec);
@@ -1742,20 +2591,8 @@ function createDomainOrbitalTools(options = {}) {
 
 // src/orbitals/generation/orbital-generator.ts
 init_cache();
-function getEntityName2(entity) {
-  if (isEntityReference(entity)) {
-    return entity.replace(".entity", "");
-  }
-  return entity.name;
-}
-function createLog(level, message, data) {
-  return {
-    timestamp: Date.now(),
-    level,
-    message,
-    data
-  };
-}
+init_shared();
+init_shared();
 async function generateFullOrbital(client, orbital, options = {}) {
   const {
     maxTokens = 8192,
@@ -2016,8 +2853,8 @@ function createOrbitalSubagentTool(options = {}) {
           ]
         });
         const client = new LLMClient({
-          provider: "anthropic",
-          model: "claude-sonnet-4-20250514"
+          provider: options.provider ?? "anthropic",
+          model: options.model ?? "claude-sonnet-4-20250514"
         });
         emitEvent(orbitalUnit.name, orbitalIndex, totalOrbitals, "tool_call", {
           tool: "llm_generate",
@@ -2134,6 +2971,9 @@ USAGE:
     setOrbitalCompleteCallback
   };
 }
+
+// src/tools/index.ts
+init_orbital_batch_subagent();
 var TraitSpecSchema = z.object({
   name: z.string().describe("Name of the trait"),
   description: z.string().describe("Description of what this trait does"),
@@ -3506,6 +4346,21 @@ function createLLMClient(provider, model, verbose) {
         model: model || OPENAI_MODELS.GPT4O,
         temperature
       });
+    case "kimi":
+      if (verbose)
+        console.log(`[SkillAgent] Using Kimi: ${model || KIMI_MODELS.K2_5}`);
+      return createKimiClient({
+        model: model || KIMI_MODELS.K2_5,
+        temperature: 0.6
+        // Kimi with thinking disabled requires 0.6
+      });
+    case "openrouter":
+      if (verbose)
+        console.log(`[SkillAgent] Using OpenRouter: ${model || OPENROUTER_MODELS.QWEN_2_5_72B}`);
+      return createOpenRouterClient({
+        model: model || OPENROUTER_MODELS.QWEN_2_5_72B,
+        temperature: 0.3
+      });
     case "anthropic":
     default:
       if (verbose)
@@ -3530,6 +4385,8 @@ async function createSkillAgent(options) {
     threadId: providedThreadId,
     provider = "anthropic",
     model,
+    subagentProvider = "anthropic",
+    subagentModel = "claude-sonnet-4-20250514",
     verbose = false,
     skillLoader,
     skillRefLoader
@@ -3626,18 +4483,24 @@ ${skillContents}`;
   const finishTaskTool = createFinishTaskTool(workDir);
   const validateSchemaTool = createValidateSchemaTool(workDir);
   const ORBITAL_SKILLS = ["kflow-orbitals", "kflow-orbital-games", "kflow-orbital-fixing"];
+  const ORBITAL_BATCH_SKILLS = ["kflow-orbitals-batch"];
   const LEAN_SKILLS = ["kflow-lean-orbitals", "kflow-lean-fixing"];
   const isOrbitalSkill = primarySkill.name === "kflow-orbitals";
+  const isOrbitalBatchSkill = ORBITAL_BATCH_SKILLS.includes(primarySkill.name);
   const isLeanSkill = LEAN_SKILLS.includes(primarySkill.name);
   const needsChunkingTools = ORBITAL_SKILLS.includes(primarySkill.name);
   let orbitalTool;
   let setOrbitalEventCallback;
   let setOrbitalCompleteCallback;
+  let orbitalBatchTool;
+  let setBatchEventCallback;
   let domainOrbitalTools;
   const chunkingTools = needsChunkingTools ? createSchemaChunkingTools(workDir) : null;
   if (isOrbitalSkill) {
     const orbitalResult = createOrbitalSubagentTool({
-      requirements: options.requirements
+      requirements: options.requirements,
+      provider: subagentProvider,
+      model: subagentModel
     });
     orbitalTool = orbitalResult.tool;
     setOrbitalEventCallback = orbitalResult.setEventCallback;
@@ -3649,10 +4512,31 @@ ${skillContents}`;
       console.log(`[SkillAgent] Orbital tools enabled for kflow-orbitals skill`);
     }
   }
+  if (isOrbitalBatchSkill) {
+    const { createOrbitalBatchSubagentTool: createOrbitalBatchSubagentTool2 } = await Promise.resolve().then(() => (init_orbital_batch_subagent(), orbital_batch_subagent_exports));
+    const batchResult = createOrbitalBatchSubagentTool2({
+      requirements: options.requirements,
+      provider: subagentProvider,
+      model: subagentModel,
+      workDir
+    });
+    orbitalBatchTool = batchResult.tool;
+    setBatchEventCallback = batchResult.setEventCallback;
+    if (options.onSubagentEvent) {
+      setBatchEventCallback(options.onSubagentEvent);
+    }
+    if (verbose) {
+      console.log(`[SkillAgent] Batch orbital tools enabled for kflow-orbitals-batch skill`);
+    }
+  }
   if (isLeanSkill) {
-    domainOrbitalTools = createDomainOrbitalTools({ workDir });
+    domainOrbitalTools = createDomainOrbitalTools({
+      workDir,
+      provider: subagentProvider,
+      model: subagentModel
+    });
     if (verbose) {
-      console.log(`[SkillAgent] Domain orbital tools enabled for ${primarySkill.name} skill`);
+      console.log(`[SkillAgent] Domain orbital tools enabled for ${primarySkill.name} skill (provider: ${subagentProvider})`);
     }
   }
   const githubTools = options.githubConfig ? createGitHubToolsArray({
@@ -3667,8 +4551,9 @@ ${skillContents}`;
   const tools = [
     executeTool,
     finishTaskTool,
-    ...isOrbitalSkill ? [] : [validateSchemaTool],
+    ...isOrbitalSkill || isOrbitalBatchSkill ? [] : [validateSchemaTool],
     ...orbitalTool ? [orbitalTool] : [],
+    ...orbitalBatchTool ? [orbitalBatchTool] : [],
     ...domainOrbitalTools ? [
       domainOrbitalTools.generateOrbitalDomain,
       domainOrbitalTools.constructCombinedDomain