@almadar/agent 1.2.2 → 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,8 +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, generateKflowDesignSkill, getRequirementsTraitPrompt, getKeyBehaviorsReference, getSExprQuickRef, getCommonErrorsSection, getArchitectureSection } from '@almadar/skills';
-import { formatRecommendationsForPrompt, buildRecommendationContext, recommendPatterns } from '@almadar/patterns';
 import { GitHubIntegration } from '@almadar/integrations';
 import { BaseCheckpointSaver } from '@langchain/langgraph-checkpoint';
 
@@ -309,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",
@@ -1051,6 +1899,77 @@ npx kflow domain:validate input.orb --verbose
 
 // src/tools/finish-task.ts
 var execAsync2 = promisify(exec);
+var PROP_CORRECTIONS = {
+  onSubmit: "submitEvent",
+  onCancel: "cancelEvent",
+  headerActions: "actions",
+  loading: "isLoading",
+  fieldNames: "fields"
+};
+function autoCorrectProps(schema) {
+  let corrections = 0;
+  JSON.stringify(schema);
+  function walkAndFix(obj) {
+    if (Array.isArray(obj)) {
+      return obj.map(walkAndFix);
+    }
+    if (obj && typeof obj === "object") {
+      const result = {};
+      for (const [key, value] of Object.entries(obj)) {
+        if (key in PROP_CORRECTIONS) {
+          result[PROP_CORRECTIONS[key]] = walkAndFix(value);
+          corrections++;
+        } else {
+          result[key] = walkAndFix(value);
+        }
+      }
+      return result;
+    }
+    return obj;
+  }
+  const fixed = walkAndFix(schema);
+  Object.assign(schema, fixed);
+  return corrections;
+}
+function checkCompositionQuality(schema) {
+  const warnings = [];
+  const orbitals = schema.orbitals;
+  if (!Array.isArray(orbitals)) return warnings;
+  for (const orbital of orbitals) {
+    const orbObj = orbital;
+    const traits = orbObj.traits;
+    if (!Array.isArray(traits)) continue;
+    for (const trait of traits) {
+      const traitObj = trait;
+      const transitions = traitObj.stateMachine?.transitions;
+      if (!Array.isArray(transitions)) continue;
+      for (const transition of transitions) {
+        const trans = transition;
+        if (trans.event !== "INIT") continue;
+        const effects = trans.effects;
+        if (!Array.isArray(effects)) continue;
+        const mainRenderUIs = effects.filter(
+          (e) => Array.isArray(e) && e[0] === "render-ui" && e[1] === "main"
+        );
+        if (mainRenderUIs.length > 1) {
+          warnings.push(
+            `\u26A0\uFE0F ${orbObj.name}/${traitObj.name} INIT has ${mainRenderUIs.length} flat render-ui calls to main. Should be a single composed stack with children.`
+          );
+        }
+        if (mainRenderUIs.length === 1) {
+          const renderPayload = mainRenderUIs[0];
+          const payload = renderPayload[2];
+          if (payload && payload.type !== "stack" && !payload.children) {
+            warnings.push(
+              `\u26A0\uFE0F ${orbObj.name}/${traitObj.name} INIT renders a single flat ${payload.type} to main. Should be a composed stack with header, metrics, and data sections.`
+            );
+          }
+        }
+      }
+    }
+  }
+  return warnings;
+}
 async function collectOrbitalsFromDir(workDir) {
   const orbitalsDir = path.join(workDir, ".orbitals");
   try {
@@ -1105,6 +2024,8 @@ function createFinishTaskTool(workDir) {
       let stats = null;
       let validationResult = null;
       let source = null;
+      let propCorrections = 0;
+      let compositionWarnings = [];
       if (workDir) {
         const orbitals = await collectOrbitalsFromDir(workDir);
         if (orbitals.length > 0) {
@@ -1149,6 +2070,10 @@ function createFinishTaskTool(workDir) {
           } catch {
           }
         }
+        if (combinedSchema) {
+          propCorrections = autoCorrectProps(combinedSchema);
+          compositionWarnings = checkCompositionQuality(combinedSchema);
+        }
         if (combinedSchema) {
           const schemaPath = path.join(workDir, "schema.json");
           await fs4.writeFile(schemaPath, JSON.stringify(combinedSchema, null, 2));
@@ -1168,6 +2093,10 @@ function createFinishTaskTool(workDir) {
           errorCount: validationResult.errors?.length || 0,
           warningCount: validationResult.warnings?.length || 0
         } : void 0,
+        designQuality: {
+          propCorrections: propCorrections || 0,
+          compositionWarnings: compositionWarnings || []
+        },
         schemaPath: combinedSchema ? path.join(workDir, "schema.json") : input.schemaPath,
         nextAction: "NONE - Task is complete. Output a brief success message to the user."
       };
@@ -1455,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);
@@ -1662,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,
@@ -1936,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",
@@ -2054,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"),
@@ -2328,273 +3248,6 @@ function createSchemaChunkingTools(workDir) {
     applyChunk: createApplyChunkTool(workDir)
   };
 }
-var designCache = /* @__PURE__ */ new Map();
-var CACHE_TTL_MS2 = 24 * 60 * 60 * 1e3;
-var CACHE_VERSION2 = 1;
-function generateFingerprint2(input) {
-  const normalized = JSON.stringify({
-    version: CACHE_VERSION2,
-    ...input
-  });
-  return crypto.createHash("sha256").update(normalized).digest("hex").slice(0, 16);
-}
-function getCached2(fingerprint) {
-  const entry = designCache.get(fingerprint);
-  if (!entry) return null;
-  if (Date.now() - entry.timestamp > CACHE_TTL_MS2) {
-    designCache.delete(fingerprint);
-    return null;
-  }
-  return entry;
-}
-var STATIC_DESIGN_PROMPT = null;
-function getDesignSystemPrompt() {
-  if (!STATIC_DESIGN_PROMPT) {
-    const skill = generateKflowDesignSkill();
-    STATIC_DESIGN_PROMPT = skill.content;
-  }
-  return STATIC_DESIGN_PROMPT;
-}
-function getPatternRecommendations(input) {
-  const recContext = buildRecommendationContext({
-    state: input.from,
-    event: input.event,
-    slot: input.slot,
-    domainCategory: input.domainCategory,
-    entityFields: input.entityFields
-  });
-  return recommendPatterns(recContext, 8);
-}
-function buildDesignUserPrompt(input) {
-  const fieldList = input.entityFields.map((f) => {
-    let desc = `  - ${f.name}: ${f.type}`;
-    if (f.values) desc += ` (values: ${f.values.join(", ")})`;
-    return desc;
-  }).join("\n");
-  const hints = [];
-  if (input.designStyle) hints.push(`Style: ${input.designStyle}`);
-  if (input.flowPattern) hints.push(`Flow: ${input.flowPattern}`);
-  if (input.listPattern) hints.push(`List: ${input.listPattern}`);
-  if (input.formPattern) hints.push(`Form: ${input.formPattern}`);
-  if (input.detailPattern) hints.push(`Detail: ${input.detailPattern}`);
-  const vocab = input.vocabulary ? Object.entries(input.vocabulary).map(([k, v]) => `  ${k} \u2192 "${v}"`).join("\n") : "";
-  return `Design render-ui effects for this transition:
-
-## Transition
-- **From**: ${input.from}
-- **To**: ${input.to}
-- **Event**: ${input.event}
-- **Slot**: ${input.slot}
-
-## Entity: ${input.entityName}
-${fieldList}
-
-## Domain
-- **Category**: ${input.domainCategory || "business"}
-${vocab ? `- **Vocabulary**:
-${vocab}` : ""}
-${hints.length > 0 ? `- **Design Hints**: ${hints.join(", ")}` : ""}
-
-${input.recommendationsSection || ""}
-
-${input.existingEffects ? `## Existing Effects (enhance these)
-\`\`\`json
-${JSON.stringify(input.existingEffects, null, 2)}
-\`\`\`` : ""}
-
-Return ONLY the JSON array of render-ui effect tuples.`;
-}
-var DesignTransitionSchema = z.object({
-  from: z.string().describe('Source state name (e.g., "Browsing")'),
-  to: z.string().describe('Target state name (e.g., "Browsing" for self-loop, "Creating" for transition)'),
-  event: z.string().describe('Event name (e.g., "INIT", "CREATE", "VIEW", "EDIT", "DELETE", "SAVE", "CANCEL")'),
-  slot: z.string().describe('UI slot to render into: "main", "modal", "drawer", "sidebar", "overlay"'),
-  entityName: z.string().describe('Entity name (e.g., "Task", "Order")'),
-  entityFields: z.array(z.object({
-    name: z.string(),
-    type: z.string(),
-    values: z.array(z.string()).optional()
-  })).describe("Entity fields with types and optional enum values"),
-  domainCategory: AgentDomainCategorySchema.optional().describe("Domain category for pattern selection"),
-  vocabulary: z.record(z.string(), z.string()).optional().describe('Domain vocabulary mapping (e.g., { "create": "Place Order", "item": "Order" })'),
-  designStyle: z.enum(["minimal", "modern", "playful", "data-driven", "immersive"]).optional().describe("Visual style hint"),
-  flowPattern: z.enum(["hub-spoke", "master-detail", "crud-cycle", "linear", "role-based"]).optional().describe("Application flow pattern"),
-  listPattern: z.enum(["entity-table", "entity-cards", "entity-list"]).optional().describe("Preferred list pattern"),
-  formPattern: z.enum(["modal", "drawer", "page"]).optional().describe("Preferred form pattern"),
-  detailPattern: z.enum(["drawer", "page", "split"]).optional().describe("Preferred detail view pattern"),
-  existingEffects: z.array(z.any()).optional().describe("Existing render-ui effects to enhance (for refinement passes)")
-});
-function createDesignTransitionTool(options = {}) {
-  let eventCallback = options.onEvent;
-  const setEventCallback = (callback) => {
-    eventCallback = callback;
-  };
-  const emitEvent = (transitionId, type, data) => {
-    if (eventCallback) {
-      eventCallback(transitionId, {
-        type,
-        data,
-        timestamp: Date.now()
-      });
-    }
-  };
-  const designTransitionTool = tool(
-    async (input) => {
-      const transitionId = `${input.entityName}:${input.from}->${input.to}:${input.event}`;
-      const fingerprint = generateFingerprint2({
-        from: input.from,
-        to: input.to,
-        event: input.event,
-        slot: input.slot,
-        entityName: input.entityName,
-        entityFields: input.entityFields,
-        domainCategory: input.domainCategory,
-        designStyle: input.designStyle,
-        flowPattern: input.flowPattern,
-        listPattern: input.listPattern
-      });
-      try {
-        emitEvent(transitionId, "message", {
-          content: `Designing UI for ${transitionId}`,
-          role: "assistant",
-          isComplete: false
-        });
-        const cached = getCached2(fingerprint);
-        if (cached) {
-          emitEvent(transitionId, "generation_log", {
-            level: "info",
-            message: `Design cache HIT for ${transitionId}`,
-            data: { fingerprint }
-          });
-          return JSON.stringify({
-            success: true,
-            transitionId,
-            effects: cached.effects,
-            cached: true,
-            usage: cached.usage
-          });
-        }
-        const recommendations = getPatternRecommendations(input);
-        const recommendationsSection = formatRecommendationsForPrompt(recommendations);
-        const systemPrompt = getDesignSystemPrompt();
-        const userPrompt = buildDesignUserPrompt({
-          ...input,
-          recommendationsSection
-        });
-        emitEvent(transitionId, "tool_call", {
-          tool: "llm_design_transition",
-          args: {
-            transition: transitionId,
-            slot: input.slot,
-            domain: input.domainCategory
-          }
-        });
-        const client = new LLMClient({
-          provider: "anthropic",
-          model: "claude-sonnet-4-20250514",
-          temperature: 0.1
-          // Slight creativity for design
-        });
-        const response = await client.callWithCache({
-          systemPrompt: "",
-          systemBlocks: [{
-            type: "text",
-            text: systemPrompt,
-            cache_control: { type: "ephemeral" }
-          }],
-          userPrompt,
-          maxTokens: 4096,
-          rawText: true
-        });
-        const rawText = (response.raw || String(response.data) || "").trim();
-        let effects;
-        try {
-          const jsonText = rawText.replace(/^```(?:json)?\n?/m, "").replace(/\n?```$/m, "").trim();
-          effects = JSON.parse(jsonText);
-          if (!Array.isArray(effects)) {
-            effects = [effects];
-          }
-        } catch {
-          return JSON.stringify({
-            success: false,
-            transitionId,
-            error: "Failed to parse design output as JSON",
-            rawOutput: rawText
-          });
-        }
-        const usage = {
-          inputTokens: response.usage?.promptTokens || 0,
-          outputTokens: response.usage?.completionTokens || 0,
-          totalTokens: response.usage?.totalTokens || 0
-        };
-        designCache.set(fingerprint, {
-          effects,
-          timestamp: Date.now(),
-          usage
-        });
-        emitEvent(transitionId, "tool_result", {
-          tool: "llm_design_transition",
-          result: { fingerprint, effectCount: effects.length, usage },
-          success: true
-        });
-        emitEvent(transitionId, "message", {
-          content: `Designed ${effects.length} effect(s) for ${transitionId} (${usage.totalTokens} tokens)`,
-          role: "assistant",
-          isComplete: true
-        });
-        return JSON.stringify({
-          success: true,
-          transitionId,
-          effects,
-          cached: false,
-          usage,
-          recommendedPatterns: recommendations.map((r) => r.pattern)
-        });
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        emitEvent(transitionId, "error", {
-          error: errorMessage,
-          code: "DESIGN_TRANSITION_ERROR"
-        });
-        return JSON.stringify({
-          success: false,
-          transitionId,
-          error: errorMessage
-        });
-      }
-    },
-    {
-      name: "design_transition",
-      description: `Design rich render-ui effects for a single orbital transition.
-
-Takes the transition context (from/to state, event, entity, domain) and produces
-polished render-ui effects using the full pattern catalog.
-
-USE THIS TOOL WHEN:
-- Generating INIT transitions (always compose header + stats + content)
-- Generating CREATE/EDIT transitions (form with proper fields)
-- Generating VIEW transitions (detail with tabs for related entities)
-- Enhancing existing render-ui effects that are too basic
-
-The tool uses a specialized design skill with pattern catalog, layout composition,
-and domain-aware pattern selection to produce rich UI.
-
-RETURNS: { success, effects: [["render-ui", slot, config], ...], transitionId, usage }
-
-The effects array contains ONLY render-ui tuples. Non-UI effects (persist, emit, set)
-are NOT included \u2014 you must preserve those from the original transition.
-
-INTEGRATION: After calling this tool, use extract_chunk to get the orbital,
-replace the render-ui effects in the target transition (keep persist/emit/set effects),
-then apply_chunk to merge back into schema.json.`,
-      schema: DesignTransitionSchema
-    }
-  );
-  return {
-    tool: designTransitionTool,
-    setEventCallback
-  };
-}
 function createGitHubTools(config) {
   const { token, owner = "", repo = "", workDir } = config;
   const integrationConfig = {
@@ -3693,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)
@@ -3717,6 +4385,8 @@ async function createSkillAgent(options) {
     threadId: providedThreadId,
     provider = "anthropic",
     model,
+    subagentProvider = "anthropic",
+    subagentModel = "claude-sonnet-4-20250514",
     verbose = false,
     skillLoader,
     skillRefLoader
@@ -3813,20 +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 DESIGN_SKILLS = ["kflow-design", "kflow-lean-design"];
   const isOrbitalSkill = primarySkill.name === "kflow-orbitals";
+  const isOrbitalBatchSkill = ORBITAL_BATCH_SKILLS.includes(primarySkill.name);
   const isLeanSkill = LEAN_SKILLS.includes(primarySkill.name);
-  const isDesignSkill = DESIGN_SKILLS.includes(primarySkill.name);
-  const needsChunkingTools = ORBITAL_SKILLS.includes(primarySkill.name) || isDesignSkill;
+  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;
@@ -3838,16 +4512,32 @@ ${skillContents}`;
       console.log(`[SkillAgent] Orbital tools enabled for kflow-orbitals skill`);
     }
   }
-  if (isLeanSkill) {
-    domainOrbitalTools = createDomainOrbitalTools({ workDir });
+  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] Domain orbital tools enabled for ${primarySkill.name} skill`);
+      console.log(`[SkillAgent] Batch orbital tools enabled for kflow-orbitals-batch skill`);
     }
   }
-  const needsDesignTool = isDesignSkill || ORBITAL_SKILLS.includes(primarySkill.name);
-  const designTool = needsDesignTool ? createDesignTransitionTool() : null;
-  if (designTool && verbose) {
-    console.log(`[SkillAgent] Design transition tool enabled for ${primarySkill.name} skill`);
+  if (isLeanSkill) {
+    domainOrbitalTools = createDomainOrbitalTools({
+      workDir,
+      provider: subagentProvider,
+      model: subagentModel
+    });
+    if (verbose) {
+      console.log(`[SkillAgent] Domain orbital tools enabled for ${primarySkill.name} skill (provider: ${subagentProvider})`);
+    }
   }
   const githubTools = options.githubConfig ? createGitHubToolsArray({
     token: options.githubConfig.token,
@@ -3861,8 +4551,9 @@ ${skillContents}`;
   const tools = [
     executeTool,
     finishTaskTool,
-    ...isOrbitalSkill ? [] : [validateSchemaTool],
+    ...isOrbitalSkill || isOrbitalBatchSkill ? [] : [validateSchemaTool],
     ...orbitalTool ? [orbitalTool] : [],
+    ...orbitalBatchTool ? [orbitalBatchTool] : [],
     ...domainOrbitalTools ? [
       domainOrbitalTools.generateOrbitalDomain,
       domainOrbitalTools.constructCombinedDomain
@@ -3872,7 +4563,6 @@ ${skillContents}`;
       chunkingTools.extractChunk,
       chunkingTools.applyChunk
     ] : [],
-    ...designTool ? [designTool.tool] : [],
     ...githubTools || []
   ];
   const checkpointer = sessions.getCheckpointer(threadId);