@almadar/agent 1.3.3 → 1.6.1

package/dist/agent/index.js

@@ -1,5 +1,5 @@
 import { AgentDomainCategorySchema, isOrbitalDefinition, isEntityReference, getTraitName } from '@almadar/core/types';
-import { getFullOrbitalPrompt, getRequirementsTraitPrompt, getKeyBehaviorsReference, getSExprQuickRef, getCommonErrorsSection, getArchitectureSection } from '@almadar/skills';
+import { getSubagentSystemPrompt, getRequirementsTraitPrompt, getKeyBehaviorsReference, getSExprQuickRef, getCommonErrorsSection, getArchitectureSection, getFullOrbitalPrompt } 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, createRequirementsClient } from '@almadar/llm';
@@ -7,13 +7,16 @@ import { FilesystemBackend, createDeepAgent } from 'deepagents';
 import { MemorySaver } from '@langchain/langgraph';
 export { Command } from '@langchain/langgraph';
 import { v4 } from 'uuid';
-import { exec, spawn } from 'child_process';
+import { exec, spawn, execSync } from 'child_process';
 import * as path from 'path';
+import path__default from 'path';
 import { promisify } from 'util';
 import * as fs4 from 'fs/promises';
 import * as domain_language_star from '@almadar/core/domain-language';
 import * as fs3 from 'fs';
+import fs3__default from 'fs';
 import crypto, { randomUUID } from 'crypto';
+import os from 'os';
 import { GitHubIntegration } from '@almadar/integrations';
 import { BaseCheckpointSaver } from '@langchain/langgraph-checkpoint';
 
@@ -212,20 +215,40 @@ ${guidance}
 
 ${CACHE_BREAK}
 
-## Current Orbital Unit
+## Current Orbital Unit (INPUT)
 Name: ${orbital.name}
 Entity: ${entityName}
 Persistence: ${persistence}
 Fields: ${fieldNames}
 Traits: ${orbital.traits.map(getTraitName).join(", ")}
 ${contextSection}
-Generate a complete FullOrbitalUnit with:
+
+## Required Output Structure
+Generate a complete FullOrbitalUnit with this EXACT structure:
+
+\`\`\`json
+{
+  "name": "${orbital.name}",
+  "entity": {                    // \u2190 REQUIRED FIELD
+    "name": "${entityName}",
+    "collection": "${entityName.toLowerCase()}s",
+    "persistence": "${persistence}",
+    "fields": [ ... ]
+  },
+  "traits": [ ... ],
+  "pages": [ ... ]
+}
+\`\`\`
+
+**CRITICAL:** The "entity" field is REQUIRED at the orbital level. Do NOT omit it.
+
+Additional requirements:
 - Full field definitions with types and validation
 - Trait state machines with transitions and effects
 - Business rule validation using "guard" (singular, NOT "guards") S-expression on SAVE transitions
 - Pages with trait references
 - domainContext with category, vocabulary, and requestFragment
-- design with style and uxHints (flowPattern, listPattern, formPattern)
+- design with style and uxHints
 `;
   return {
     prompt,
@@ -265,7 +288,7 @@ ${guidance}`,
   const userBlocks = [
     {
       type: "text",
-      text: `## Current Orbital Unit
+      text: `## Current Orbital Unit (INPUT)
 Name: ${orbital.name}
 Entity: ${entityName}
 Persistence: ${persistence}
@@ -273,7 +296,40 @@ Fields: ${fieldNames}
 Traits: ${orbital.traits.map(getTraitName).join(", ")}
 ${contextSection}${connectivitySection ? `
 ${connectivitySection}` : ""}
-Generate a complete FullOrbitalUnit with:
+
+## REQUIRED OUTPUT - VERIFICATION CHECKLIST
+
+Before generating output, verify:
+- [ ] "entity" field is present at the TOP LEVEL of the orbital object
+- [ ] entity.name = "${entityName}"
+- [ ] entity.collection = "${entityName.toLowerCase()}s"
+- [ ] entity.persistence = "${persistence}"
+- [ ] entity.fields array has at least ${inlineEntity?.fields.length || 1} field(s)
+- [ ] Full orbital structure includes: name, entity, traits, pages, domainContext, design
+
+## Output Structure (Generate This Exact JSON)
+
+\`\`\`json
+{
+  "name": "${orbital.name}",
+  "entity": {                    // \u2190 THIS FIELD IS MANDATORY
+    "name": "${entityName}",
+    "collection": "${entityName.toLowerCase()}s",
+    "persistence": "${persistence}",
+    "fields": [${inlineEntity?.fields.map((f) => `
+      { "name": "${f.name}", "type": "${f.type}"${f.required ? ', "required": true' : ""} }`).join(",") || ""}
+    ]
+  },
+  "traits": [ ... trait definitions with state machines ... ],
+  "pages": [ ... page definitions ... ],
+  "domainContext": { ... domain info ... },
+  "design": { ... styling info ... }
+}
+\`\`\`
+
+**MANDATORY:** If the output does not have an "entity" field at the orbital level, it is INVALID.
+
+Additional requirements:
 - Full field definitions with types and validation
 - Trait state machines with transitions and effects
 - Business rule validation using "guard" (singular, NOT "guards") S-expression on SAVE transitions
@@ -1157,6 +1213,16 @@ var init_orbital_batch_subagent = __esm({
     });
   }
 });
+var DEFAULT_INTERRUPT_CONFIG = {
+  // Shell commands always require approval
+  execute: true
+};
+function getInterruptConfig(_skill) {
+  const config = { ...DEFAULT_INTERRUPT_CONFIG };
+  return config;
+}
+
+// src/tools/execute.ts
 var DANGEROUS_COMMANDS = [
   "rm",
   "rmdir",
@@ -1273,7 +1339,7 @@ function validateCommandPaths(command, workDir) {
   }
   return null;
 }
-function createExecuteTool(workDir) {
+function createExecuteTool(workDir, auditLog) {
   const normalizedWorkDir = path.resolve(workDir);
   return tool(
     async ({ command, timeout = 6e4 }) => {
@@ -2606,7 +2672,8 @@ async function generateFullOrbital(client, orbital, options = {}) {
     traitCount: orbital.traits.length,
     hasRequirements: !!requirements
   }));
-  const systemPrompt = requirements ? getRequirementsAwareFullOrbitalPrompt(requirements) : getFullOrbitalPrompt();
+  const basePrompt = getSubagentSystemPrompt();
+  const systemPrompt = requirements ? getRequirementsAwareFullOrbitalPrompt(requirements, basePrompt) : basePrompt;
   const useCache = client.getProvider() === "anthropic";
   let result;
   let fingerprint;
@@ -2677,8 +2744,7 @@ Return valid JSON matching the FullOrbitalUnit schema.`;
     logs
   };
 }
-function getRequirementsAwareFullOrbitalPrompt(requirements) {
-  const basePrompt = getFullOrbitalPrompt();
+function getRequirementsAwareFullOrbitalPrompt(requirements, basePrompt = getSubagentSystemPrompt()) {
   const requirementsGuidance = getRequirementsTraitPrompt();
   const sections = [];
   if (requirements.guards && requirements.guards.length > 0) {
@@ -3248,6 +3314,825 @@ function createSchemaChunkingTools(workDir) {
     applyChunk: createApplyChunkTool(workDir)
   };
 }
+
+// src/orchestration/complexity-classifier.ts
+function classifyComplexity(orbitalCount) {
+  if (orbitalCount <= 0) {
+    throw new Error(`Invalid orbital count: ${orbitalCount}`);
+  }
+  if (orbitalCount === 1) {
+    return {
+      level: "simple",
+      orbitalCount,
+      recommendedProvider: "qwen",
+      reasoning: "Single orbital - Qwen 397B is fast and cost-effective"
+    };
+  }
+  if (orbitalCount <= 3) {
+    return {
+      level: "medium",
+      orbitalCount,
+      recommendedProvider: "qwen",
+      reasoning: "2-3 orbitals - Qwen 397B handles well with good speed/cost"
+    };
+  }
+  return {
+    level: "complex",
+    orbitalCount,
+    recommendedProvider: "multi-provider",
+    reasoning: "4+ orbitals - Multi-provider parallel for optimal speed"
+  };
+}
+function estimateComplexity(prompt) {
+  const lowerPrompt = prompt.toLowerCase();
+  const entityPatterns = [
+    /entity[:s]/g,
+    /entities:/g,
+    /- \w+:/g,
+    // List items like "- Task:"
+    /model[s]?:/g,
+    /table[s]?:/g
+  ];
+  let entityMatches = 0;
+  for (const pattern of entityPatterns) {
+    const matches = lowerPrompt.match(pattern);
+    if (matches) {
+      entityMatches += matches.length;
+    }
+  }
+  const featureIndicators = [
+    "dashboard",
+    "workflow",
+    "admin",
+    "portal",
+    "system",
+    "management",
+    "booking",
+    "appointment",
+    "inventory",
+    "e-commerce",
+    "healthcare",
+    "patient",
+    "doctor"
+  ];
+  let featureMatches = 0;
+  for (const indicator of featureIndicators) {
+    if (lowerPrompt.includes(indicator)) {
+      featureMatches++;
+    }
+  }
+  const lengthScore = prompt.length > 500 ? 2 : prompt.length > 200 ? 1 : 0;
+  const score = entityMatches + featureMatches + lengthScore;
+  if (score <= 2) {
+    return { estimatedLevel: "simple", confidence: score === 0 ? "low" : "medium" };
+  }
+  if (score <= 5) {
+    return { estimatedLevel: "medium", confidence: "medium" };
+  }
+  return { estimatedLevel: "complex", confidence: "high" };
+}
+function getExecutionStrategy(complexity) {
+  switch (complexity.level) {
+    case "simple":
+    case "medium":
+      return {
+        type: "single",
+        provider: "openrouter",
+        model: "qwen/qwen3.5-397b-a17b",
+        parallelization: 1
+      };
+    case "complex":
+      return {
+        type: "multi-provider",
+        provider: "mixed",
+        model: "deepseek-chat + qwen/qwen3.5-397b-a17b",
+        parallelization: 2
+      };
+  }
+}
+function buildOrbitalDefinition(unit) {
+  const traits = unit.traits.map((t) => ({
+    name: t,
+    category: "interaction",
+    linkedEntity: unit.entity,
+    stateMachine: {
+      states: [{ name: "Browsing", isInitial: true }],
+      events: [{ key: "INIT", name: "Initialize" }],
+      transitions: []
+    }
+  }));
+  const pages = [
+    {
+      name: `${unit.name}Page`,
+      path: `/${unit.entity.toLowerCase()}s`,
+      traits: traits.map((t) => ({ ref: t.name }))
+    }
+  ];
+  return {
+    name: unit.name,
+    entity: {
+      name: unit.entity,
+      collection: `${unit.entity.toLowerCase()}s`,
+      fields: [{ name: "id", type: "string", required: true }]
+    },
+    traits,
+    pages
+  };
+}
+function normalizeDecomposedUnit(unit) {
+  const u = unit;
+  let entityName;
+  if (typeof u.entity === "string") {
+    entityName = u.entity;
+  } else if (u.entity && typeof u.entity === "object") {
+    const entityObj = u.entity;
+    entityName = typeof entityObj.name === "string" ? entityObj.name : "Unknown";
+  } else {
+    entityName = "Unknown";
+  }
+  let traitNames = [];
+  if (Array.isArray(u.traits)) {
+    traitNames = u.traits.map((t) => {
+      if (typeof t === "string") return t;
+      if (t && typeof t === "object") {
+        const to = t;
+        return typeof to.name === "string" ? to.name : String(t);
+      }
+      return String(t);
+    });
+  }
+  return {
+    name: typeof u.name === "string" ? u.name : "Unnamed",
+    entity: entityName,
+    traits: traitNames
+  };
+}
+async function decomposeRequest(prompt, skillContent, _config) {
+  const client = new LLMClient({
+    provider: "anthropic",
+    model: "claude-sonnet-4-20250514"
+  });
+  const systemPrompt = `${skillContent}
+
+Your task is to decompose the user request into orbital units. Return ONLY a JSON array of orbital summaries. Each item should have: name (string), entity (string), traits (array of strings).`;
+  const userPrompt = `Decompose this request into orbital units:
+
+${prompt}
+
+Return ONLY a JSON array. Each object must have:
+- name: orbital name (e.g., "Task Management")
+- entity: entity name as a STRING (e.g., "Task")
+- traits: array of trait names as strings (e.g., ["TaskInteraction"])`;
+  const result = await client.call({
+    systemPrompt,
+    userPrompt,
+    maxTokens: 4096,
+    skipSchemaValidation: true
+  });
+  const rawUnits = Array.isArray(result) ? result : [result];
+  return rawUnits.map(normalizeDecomposedUnit);
+}
+async function generateWithSingleProvider(units, config) {
+  const client = new LLMClient({
+    provider: "openrouter",
+    model: "qwen/qwen3.5-397b-a17b"
+  });
+  if (config.verbose !== false) {
+    console.log(`[Router] Using single provider (Qwen) for ${units.length} orbitals`);
+  }
+  const orbitals = [];
+  for (const unit of units) {
+    if (config.verbose !== false) {
+      console.log(`[Router] Generating: ${unit.name}...`);
+    }
+    const startTime = Date.now();
+    try {
+      const orbitalDef = buildOrbitalDefinition(unit);
+      const result = await generateFullOrbital(client, orbitalDef, {
+        requirements: { entities: [unit.entity] },
+        maxTokens: 8192
+      });
+      if (config.verbose !== false) {
+        console.log(`[Router] \u2705 ${unit.name}: ${((Date.now() - startTime) / 1e3).toFixed(1)}s`);
+      }
+      orbitals.push(result.orbital);
+    } catch (error) {
+      if (config.verbose !== false) {
+        console.log(`[Router] \u274C ${unit.name}: Failed - ${error instanceof Error ? error.message.slice(0, 50) : "Unknown"}`);
+      }
+    }
+  }
+  return orbitals;
+}
+async function generateWithMultiProvider(units, config) {
+  if (config.verbose !== false) {
+    console.log(`[Router] Using multi-provider parallel for ${units.length} orbitals`);
+  }
+  const midpoint = Math.ceil(units.length / 2);
+  const deepseekUnits = units.slice(0, midpoint);
+  const qwenUnits = units.slice(midpoint);
+  if (config.verbose !== false) {
+    console.log(`[Router] Split: ${deepseekUnits.length} to DeepSeek, ${qwenUnits.length} to Qwen`);
+  }
+  const deepseekClient = new LLMClient({
+    provider: "deepseek",
+    model: "deepseek-chat"
+  });
+  const qwenClient = new LLMClient({
+    provider: "openrouter",
+    model: "qwen/qwen3.5-397b-a17b"
+  });
+  const [deepseekResults, qwenResults] = await Promise.all([
+    Promise.all(
+      deepseekUnits.map(async (unit) => {
+        if (config.verbose !== false) {
+          console.log(`[Router] [DeepSeek] Generating: ${unit.name}...`);
+        }
+        const startTime = Date.now();
+        try {
+          const orbitalDef = buildOrbitalDefinition(unit);
+          const result = await generateFullOrbital(deepseekClient, orbitalDef, {
+            requirements: { entities: [unit.entity] },
+            maxTokens: 8192
+          });
+          if (config.verbose !== false) {
+            console.log(`[Router] [DeepSeek] \u2705 ${unit.name}: ${((Date.now() - startTime) / 1e3).toFixed(1)}s`);
+          }
+          return result.orbital;
+        } catch (error) {
+          if (config.verbose !== false) {
+            console.log(`[Router] [DeepSeek] \u274C ${unit.name}: Failed`);
+          }
+          return null;
+        }
+      })
+    ),
+    Promise.all(
+      qwenUnits.map(async (unit) => {
+        if (config.verbose !== false) {
+          console.log(`[Router] [Qwen] Generating: ${unit.name}...`);
+        }
+        const startTime = Date.now();
+        try {
+          const orbitalDef = buildOrbitalDefinition(unit);
+          const result = await generateFullOrbital(qwenClient, orbitalDef, {
+            requirements: { entities: [unit.entity] },
+            maxTokens: 8192
+          });
+          if (config.verbose !== false) {
+            console.log(`[Router] [Qwen] \u2705 ${unit.name}: ${((Date.now() - startTime) / 1e3).toFixed(1)}s`);
+          }
+          return result.orbital;
+        } catch (error) {
+          if (config.verbose !== false) {
+            console.log(`[Router] [Qwen] \u274C ${unit.name}: Failed`);
+          }
+          return null;
+        }
+      })
+    )
+  ]);
+  return [...deepseekResults, ...qwenResults].filter((o) => o !== null);
+}
+async function routeGeneration(prompt, skillContent, config = {}) {
+  const totalStart = Date.now();
+  if (config.verbose !== false) {
+    console.log("[Router] Step 1: Decomposing request...");
+  }
+  const decomposeStart = Date.now();
+  const units = await decomposeRequest(prompt, skillContent);
+  const decomposeMs = Date.now() - decomposeStart;
+  if (config.verbose !== false) {
+    console.log(`[Router] \u2705 Decomposed into ${units.length} orbitals (${(decomposeMs / 1e3).toFixed(1)}s)`);
+  }
+  const complexity = classifyComplexity(units.length);
+  const strategy = getExecutionStrategy(complexity);
+  if (config.verbose !== false) {
+    console.log(`[Router] Complexity: ${complexity.level} (${units.length} orbitals)`);
+    console.log(`[Router] Strategy: ${strategy.type} (${strategy.provider})`);
+  }
+  const generateStart = Date.now();
+  let orbitals;
+  if (complexity.level === "complex") {
+    orbitals = await generateWithMultiProvider(units, config);
+  } else {
+    orbitals = await generateWithSingleProvider(units, config);
+  }
+  const generateMs = Date.now() - generateStart;
+  const totalMs = Date.now() - totalStart;
+  if (config.verbose !== false) {
+    console.log(`[Router] \u2705 Generated ${orbitals.length}/${units.length} orbitals`);
+    console.log(`[Router] Total time: ${(totalMs / 1e3).toFixed(1)}s`);
+  }
+  return {
+    orbitals,
+    complexity,
+    timing: {
+      decomposeMs,
+      generateMs,
+      totalMs
+    },
+    provider: strategy.provider
+  };
+}
+function quickComplexityCheck(prompt) {
+  const estimate = estimateComplexity(prompt);
+  const estimatedCounts = {
+    simple: 1,
+    medium: 2,
+    complex: 6
+  };
+  return {
+    likelyComplex: estimate.estimatedLevel === "complex",
+    confidence: estimate.confidence,
+    estimatedOrbitals: estimatedCounts[estimate.estimatedLevel]
+  };
+}
+async function createFixPlan(schema, errors, config) {
+  const planStart = Date.now();
+  const criticalErrors = errors.filter(
+    (e) => e.code?.includes("ENTITY") || e.code?.includes("REQUIRED") || e.code?.includes("JSON")
+  );
+  const warningErrors = errors.filter((e) => !criticalErrors.includes(e));
+  const orbitalErrors = /* @__PURE__ */ new Map();
+  errors.forEach((error, index) => {
+    let pathStr;
+    if (Array.isArray(error.path)) {
+      pathStr = error.path.join(".");
+    } else if (typeof error.path === "string") {
+      pathStr = error.path;
+    } else {
+      pathStr = String(error.path || "");
+    }
+    const match = pathStr.match(/orbitals\[(\d+)\]/);
+    const orbitalIndex = match ? parseInt(match[1], 10) : -1;
+    if (orbitalIndex >= 0) {
+      if (!orbitalErrors.has(orbitalIndex)) {
+        orbitalErrors.set(orbitalIndex, []);
+      }
+      orbitalErrors.get(orbitalIndex).push(index);
+    }
+  });
+  const executionOrder = [];
+  const affectedOrbitals = [];
+  for (const [orbitalIndex, errorIndices] of orbitalErrors) {
+    const orbital = schema.orbitals[orbitalIndex];
+    if (orbital) {
+      affectedOrbitals.push(orbital.name);
+      const midPoint = Math.ceil(errorIndices.length / 2);
+      const batches = [
+        errorIndices.slice(0, midPoint),
+        errorIndices.slice(midPoint)
+      ].filter((b) => b.length > 0);
+      batches.forEach((batch, batchIndex) => {
+        executionOrder.push({
+          id: `fix-${orbitalIndex}-${batchIndex}`,
+          description: `Fix ${batch.length} errors in ${orbital.name}`,
+          orbitalIndex,
+          errorIndices: batch,
+          provider: batchIndex === 0 ? "deepseek" : "qwen",
+          dependencies: []
+        });
+      });
+    }
+  }
+  let parallelizationStrategy = "single";
+  if (executionOrder.length >= 4) {
+    parallelizationStrategy = "multi-provider";
+  } else if (JSON.stringify(schema).length > 5e4) {
+    parallelizationStrategy = "chunked";
+  }
+  const plan = {
+    summary: {
+      totalErrors: errors.length,
+      criticalErrors: criticalErrors.length,
+      warningErrors: warningErrors.length,
+      affectedOrbitals: [...new Set(affectedOrbitals)]
+    },
+    executionOrder,
+    parallelizationStrategy
+  };
+  if (config.verbose) {
+    console.log(`[Fixing] Plan created in ${Date.now() - planStart}ms`);
+    console.log(`[Fixing] Strategy: ${parallelizationStrategy}`);
+    console.log(`[Fixing] Steps: ${executionOrder.length}`);
+  }
+  return plan;
+}
+async function executeFixStep(schema, step, errors, config) {
+  const orbital = schema.orbitals[step.orbitalIndex];
+  if (!orbital) {
+    return { success: false, updatedOrbital: null };
+  }
+  const client = step.provider === "deepseek" ? new LLMClient({
+    provider: "deepseek",
+    model: "deepseek-chat"
+  }) : new LLMClient({
+    provider: "openrouter",
+    model: "qwen/qwen3.5-397b-a17b"
+  });
+  const stepErrors = step.errorIndices.map((i) => errors[i]);
+  const skillContent = config.skillContent || "";
+  const hasBindingErrors = stepErrors.some(
+    (e) => e.message?.toLowerCase().includes("binding") || e.code?.toLowerCase().includes("binding")
+  );
+  const bindingGuidance = hasBindingErrors ? `
+## BINDING ERROR FIXES
+
+Common binding mistakes and fixes:
+
+\u274C INVALID:
+- "@count" \u2192 missing entity reference
+- "@status" \u2192 missing entity reference
+- "@count:status=active" \u2192 wrong syntax
+
+\u2705 VALID (from skill):
+- "@entity.count" - entity field reference
+- "@entity.status" - enum field reference  
+- "@payload.data" - event payload data
+- "@state" - current state name
+- "@now" - current timestamp
+
+Replace bare field names like "@count" with proper entity references like "@entity.count".
+` : "";
+  const systemPrompt = `${skillContent}
+
+${bindingGuidance}
+
+## FIXING INSTRUCTIONS
+
+You are fixing validation errors in an OrbitalSchema orbital.
+
+Rules:
+1. Preserve ALL valid content - only fix the reported errors
+2. Return the COMPLETE orbital with entity, traits, and pages
+3. Ensure entity has: name, collection, and fields array
+4. Use valid binding formats: @entity.field, @payload.field, @state
+
+Return ONLY the fixed orbital as valid JSON.`;
+  const userPrompt = `Fix these validation errors in orbital "${orbital.name}":
+
+ERRORS:
+${stepErrors.map((e) => {
+    const path8 = Array.isArray(e.path) ? e.path.join(".") : e.path;
+    return `- Path: ${path8}
+  Code: ${e.code}
+  Message: ${e.message}`;
+  }).join("\n")}
+
+CURRENT ORBITAL (JSON):
+${JSON.stringify(orbital, null, 2)}
+
+Return the COMPLETE fixed orbital as JSON with all fields (entity, traits, pages).`;
+  try {
+    const result = await client.call({
+      systemPrompt,
+      userPrompt,
+      maxTokens: 8192,
+      skipSchemaValidation: true
+    });
+    return {
+      success: true,
+      updatedOrbital: result
+    };
+  } catch (error) {
+    return {
+      success: false,
+      updatedOrbital: null
+    };
+  }
+}
+async function executeFixPlan(schema, plan, errors, config) {
+  const executeStart = Date.now();
+  const updatedSchema = { ...schema };
+  if (plan.parallelizationStrategy === "multi-provider") {
+    const deepseekSteps = plan.executionOrder.filter((s) => s.provider === "deepseek");
+    const qwenSteps = plan.executionOrder.filter((s) => s.provider === "qwen");
+    if (config.verbose) {
+      console.log(`[Fixing] Executing ${deepseekSteps.length} steps on DeepSeek, ${qwenSteps.length} on Qwen`);
+    }
+    const [deepseekResults, qwenResults] = await Promise.all([
+      Promise.all(deepseekSteps.map((step) => executeFixStep(schema, step, errors, config))),
+      Promise.all(qwenSteps.map((step) => executeFixStep(schema, step, errors, config)))
+    ]);
+    deepseekSteps.forEach((step, i) => {
+      if (deepseekResults[i].success) {
+        updatedSchema.orbitals[step.orbitalIndex] = deepseekResults[i].updatedOrbital;
+      }
+    });
+    qwenSteps.forEach((step, i) => {
+      if (qwenResults[i].success) {
+        updatedSchema.orbitals[step.orbitalIndex] = qwenResults[i].updatedOrbital;
+      }
+    });
+  } else {
+    for (const step of plan.executionOrder) {
+      if (config.verbose) {
+        console.log(`[Fixing] Executing: ${step.description}`);
+      }
+      const result = await executeFixStep(schema, step, errors, config);
+      if (result.success) {
+        updatedSchema.orbitals[step.orbitalIndex] = result.updatedOrbital;
+      }
+    }
+  }
+  if (config.verbose) {
+    console.log(`[Fixing] Execution completed in ${Date.now() - executeStart}ms`);
+  }
+  return updatedSchema;
+}
+function validateSchema(schema) {
+  const tempDir = path__default.join(os.tmpdir(), "almadar-fixing");
+  fs3__default.mkdirSync(tempDir, { recursive: true });
+  const tempFile = path__default.join(tempDir, `schema-${Date.now()}.orb`);
+  try {
+    fs3__default.writeFileSync(tempFile, JSON.stringify(schema, null, 2));
+    const output = execSync(`npx @almadar/cli validate --json "${tempFile}"`, {
+      encoding: "utf-8",
+      timeout: 3e4
+    });
+    fs3__default.unlinkSync(tempFile);
+    const result = JSON.parse(output);
+    return {
+      valid: result.valid,
+      errors: result.errors || []
+    };
+  } catch (error) {
+    try {
+      fs3__default.unlinkSync(tempFile);
+    } catch {
+    }
+    try {
+      const result = JSON.parse(error.stdout || "{}");
+      return {
+        valid: false,
+        errors: result.errors || []
+      };
+    } catch {
+      return {
+        valid: false,
+        errors: [{ code: "ERROR", message: error.message, path: [""], severity: "error" }]
+      };
+    }
+  }
+}
+async function orchestrateFixing(schema, config = {}) {
+  const totalStart = Date.now();
+  if (config.verbose) {
+    console.log("[Fixing] Starting Plan-Then-Execute fixing workflow");
+  }
+  const initialValidation = validateSchema(schema);
+  if (initialValidation.valid) {
+    return {
+      success: true,
+      fixedSchema: schema,
+      plan: {
+        summary: { totalErrors: 0, criticalErrors: 0, warningErrors: 0, affectedOrbitals: [] },
+        executionOrder: [],
+        parallelizationStrategy: "single"
+      },
+      stepsCompleted: 0,
+      stepsTotal: 0,
+      remainingErrors: [],
+      timing: {
+        planMs: 0,
+        executeMs: 0,
+        verifyMs: 0,
+        totalMs: Date.now() - totalStart
+      }
+    };
+  }
+  const planStart = Date.now();
+  const plan = await createFixPlan(schema, initialValidation.errors, config);
+  const planMs = Date.now() - planStart;
+  const executeStart = Date.now();
+  let fixedSchema = await executeFixPlan(schema, plan, initialValidation.errors, config);
+  const executeMs = Date.now() - executeStart;
+  const verifyStart = Date.now();
+  const finalValidation = validateSchema(fixedSchema);
+  const verifyMs = Date.now() - verifyStart;
+  let retries = 0;
+  const maxRetries = config.maxRetries || 2;
+  while (!finalValidation.valid && retries < maxRetries) {
+    if (config.verbose) {
+      console.log(`[Fixing] Retrying (${retries + 1}/${maxRetries})...`);
+    }
+    const retryPlan = await createFixPlan(fixedSchema, finalValidation.errors, config);
+    fixedSchema = await executeFixPlan(fixedSchema, retryPlan, finalValidation.errors, config);
+    const retryValidation = validateSchema(fixedSchema);
+    if (retryValidation.valid || retryValidation.errors.length < finalValidation.errors.length) {
+      finalValidation.errors = retryValidation.errors;
+      finalValidation.valid = retryValidation.valid;
+    }
+    retries++;
+  }
+  const totalMs = Date.now() - totalStart;
+  if (config.verbose) {
+    console.log("[Fixing] === Summary ===");
+    console.log(`[Fixing] Plan: ${planMs}ms, Execute: ${executeMs}ms, Verify: ${verifyMs}ms`);
+    console.log(`[Fixing] Total: ${totalMs}ms`);
+    console.log(`[Fixing] Errors: ${initialValidation.errors.length} \u2192 ${finalValidation.errors.length}`);
+    console.log(`[Fixing] Success: ${finalValidation.valid ? "YES" : "PARTIAL"}`);
+  }
+  return {
+    success: finalValidation.valid,
+    fixedSchema: finalValidation.valid ? fixedSchema : null,
+    plan,
+    stepsCompleted: plan.executionOrder.length - retries,
+    stepsTotal: plan.executionOrder.length,
+    remainingErrors: finalValidation.errors,
+    timing: {
+      planMs,
+      executeMs,
+      verifyMs,
+      totalMs
+    }
+  };
+}
+
+// src/tools/orchestrated-generation.ts
+function createOrchestratedGenerationTool(options) {
+  const { skillContent, verbose = false } = options;
+  return tool(
+    async ({ prompt }) => {
+      const startTime = Date.now();
+      if (verbose) {
+        console.log("[OrchestratedGeneration] Starting generation...");
+        console.log(`[OrchestratedGeneration] Prompt length: ${prompt.length} chars`);
+      }
+      const quickCheck = quickComplexityCheck(prompt);
+      if (verbose) {
+        console.log(`[OrchestratedGeneration] Quick check: ~${quickCheck.estimatedOrbitals} orbitals (${quickCheck.confidence} confidence)`);
+      }
+      try {
+        const result = await routeGeneration(prompt, skillContent, {
+          verbose
+        });
+        const totalTime = Date.now() - startTime;
+        if (verbose) {
+          console.log(`[OrchestratedGeneration] \u2705 Success: ${result.orbitals.length} orbitals`);
+          console.log(`[OrchestratedGeneration] Provider: ${result.provider}`);
+          console.log(`[OrchestratedGeneration] Total time: ${totalTime}ms`);
+        }
+        const schema = {
+          name: "GeneratedApp",
+          version: "1.0.0",
+          orbitals: result.orbitals
+        };
+        return {
+          success: true,
+          schema,
+          complexity: result.complexity,
+          provider: result.provider,
+          timing: result.timing
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (verbose) {
+          console.log(`[OrchestratedGeneration] \u274C Failed: ${errorMessage}`);
+        }
+        return {
+          success: false,
+          error: errorMessage
+        };
+      }
+    },
+    {
+      name: "generate_schema_orchestrated",
+      description: `Generate an OrbitalSchema using complexity-based provider routing.
+
+This tool automatically selects the best generation strategy:
+- Simple (1 orbital) \u2192 Fast single-provider generation
+- Medium (2-3 orbitals) \u2192 Efficient single-provider generation  
+- Complex (4+ orbitals) \u2192 Parallel multi-provider generation
+
+The tool handles decomposition, provider selection, and result combination automatically.`,
+      schema: z.object({
+        prompt: z.string().describe("User prompt describing the application to generate")
+      })
+    }
+  );
+}
+function validateSchema2(schema) {
+  const tempDir = path__default.join(os.tmpdir(), "almadar-fixing");
+  fs3__default.mkdirSync(tempDir, { recursive: true });
+  const tempFile = path__default.join(tempDir, `schema-${Date.now()}.orb`);
+  try {
+    fs3__default.writeFileSync(tempFile, JSON.stringify(schema, null, 2));
+    const output = execSync(`npx @almadar/cli validate --json "${tempFile}"`, {
+      encoding: "utf-8",
+      timeout: 3e4
+    });
+    fs3__default.unlinkSync(tempFile);
+    const result = JSON.parse(output);
+    return {
+      valid: result.valid,
+      errors: result.errors || []
+    };
+  } catch (error) {
+    try {
+      fs3__default.unlinkSync(tempFile);
+    } catch {
+    }
+    try {
+      const result = JSON.parse(error.stdout || "{}");
+      return {
+        valid: false,
+        errors: result.errors || []
+      };
+    } catch {
+      return {
+        valid: false,
+        errors: [{ code: "ERROR", message: error.message }]
+      };
+    }
+  }
+}
+function createOrchestratedFixingTool(options) {
+  const { skillContent, maxRetries = 2, verbose = false } = options;
+  return tool(
+    async ({ schema }) => {
+      const typedSchema = schema;
+      if (verbose) {
+        console.log("[OrchestratedFixing] Starting fixing workflow...");
+      }
+      const initialValidation = validateSchema2(typedSchema);
+      if (initialValidation.valid) {
+        if (verbose) {
+          console.log("[OrchestratedFixing] Schema is already valid");
+        }
+        return {
+          success: true,
+          schema: typedSchema,
+          fixSummary: {
+            totalErrors: 0,
+            errorsFixed: 0,
+            errorsRemaining: 0,
+            strategy: "none-needed",
+            stepsExecuted: 0
+          },
+          timing: {
+            planMs: 0,
+            executeMs: 0,
+            verifyMs: 0,
+            totalMs: 0
+          }
+        };
+      }
+      if (verbose) {
+        console.log(`[OrchestratedFixing] Found ${initialValidation.errors.length} errors to fix`);
+      }
+      try {
+        const result = await orchestrateFixing(typedSchema, {
+          maxRetries,
+          verbose,
+          skillContent
+        });
+        if (verbose) {
+          console.log(`[OrchestratedFixing] ${result.success ? "\u2705" : "\u26A0\uFE0F"} Fix complete`);
+          console.log(`[OrchestratedFixing] Errors: ${result.plan.summary.totalErrors} \u2192 ${result.remainingErrors.length}`);
+        }
+        return {
+          success: result.success,
+          schema: result.fixedSchema || typedSchema,
+          fixSummary: {
+            totalErrors: result.plan.summary.totalErrors,
+            errorsFixed: result.plan.summary.totalErrors - result.remainingErrors.length,
+            errorsRemaining: result.remainingErrors.length,
+            strategy: result.plan.parallelizationStrategy,
+            stepsExecuted: result.stepsCompleted
+          },
+          timing: result.timing
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (verbose) {
+          console.log(`[OrchestratedFixing] \u274C Failed: ${errorMessage}`);
+        }
+        return {
+          success: false,
+          schema: typedSchema,
+          error: errorMessage
+        };
+      }
+    },
+    {
+      name: "fix_schema_orchestrated",
+      description: `Fix validation errors in an OrbitalSchema using Plan-Then-Execute strategy.
+
+This tool:
+1. Validates the schema to identify errors
+2. Creates a fix plan based on error types
+3. Applies fixes using the fixing skill guidance
+4. Re-validates and retries if needed
+
+Works with single or multi-orbital schemas, automatically selecting the best strategy.`,
+      schema: z.object({
+        schema: z.object({}).describe("The OrbitalSchema to fix")
+      })
+    }
+  );
+}
 function createGitHubTools(config) {
   const { token, owner = "", repo = "", workDir } = config;
   const integrationConfig = {
@@ -4273,16 +5158,6 @@ var SessionManager = class {
   }
 };
 
-// src/agent/interrupt-config.ts
-var DEFAULT_INTERRUPT_CONFIG = {
-  // Shell commands always require approval
-  execute: true
-};
-function getInterruptConfig(_skill) {
-  const config = { ...DEFAULT_INTERRUPT_CONFIG };
-  return config;
-}
-
 // src/agent/skill-agent.ts
 var BASE_SYSTEM_PROMPT = `You are a KFlow agent that helps users create and manage application schemas.
 
@@ -4489,6 +5364,30 @@ ${skillContents}`;
   const isOrbitalBatchSkill = ORBITAL_BATCH_SKILLS.includes(primarySkill.name);
   const isLeanSkill = LEAN_SKILLS.includes(primarySkill.name);
   const needsChunkingTools = ORBITAL_SKILLS.includes(primarySkill.name);
+  const useOrchestration = options.useOrchestration ?? false;
+  let orchestratedGenerationTool;
+  let orchestratedFixingTool;
+  if (useOrchestration) {
+    if (isOrbitalSkill) {
+      orchestratedGenerationTool = createOrchestratedGenerationTool({
+        skillContent: primarySkill.content,
+        verbose
+      });
+      if (verbose) {
+        console.log(`[SkillAgent] Orchestrated generation enabled for ${primarySkill.name}`);
+      }
+    }
+    if (primarySkill.name === "kflow-orbital-fixing") {
+      orchestratedFixingTool = createOrchestratedFixingTool({
+        skillContent: primarySkill.content,
+        maxRetries: 2,
+        verbose
+      });
+      if (verbose) {
+        console.log(`[SkillAgent] Orchestrated fixing enabled for ${primarySkill.name}`);
+      }
+    }
+  }
   let orbitalTool;
   let setOrbitalEventCallback;
   let setOrbitalCompleteCallback;
@@ -4548,10 +5447,10 @@ ${skillContents}`;
   if (githubTools && verbose) {
     console.log(`[SkillAgent] GitHub tools enabled`);
   }
-  const tools = [
+  let tools = [
     executeTool,
     finishTaskTool,
-    ...isOrbitalSkill || isOrbitalBatchSkill ? [] : [validateSchemaTool],
+    validateSchemaTool,
     ...orbitalTool ? [orbitalTool] : [],
     ...orbitalBatchTool ? [orbitalBatchTool] : [],
     ...domainOrbitalTools ? [
@@ -4563,8 +5462,14 @@ ${skillContents}`;
       chunkingTools.extractChunk,
       chunkingTools.applyChunk
     ] : [],
-    ...githubTools || []
+    ...githubTools || [],
+    // Add orchestrated tools when enabled
+    ...orchestratedGenerationTool ? [orchestratedGenerationTool] : [],
+    ...orchestratedFixingTool ? [orchestratedFixingTool] : []
   ];
+  if (options.toolWrapper) {
+    tools = tools.map(options.toolWrapper);
+  }
   const checkpointer = sessions.getCheckpointer(threadId);
   const interruptConfig = options.noInterrupt ? void 0 : getInterruptConfig();
   const agent = createDeepAgent({
@@ -6127,11 +7032,11 @@ var WorkflowBuilder = class {
     this.definition.inputs[name] = { type, required, default: defaultValue };
     return this;
   }
-  step(id, tool12, input, options = {}) {
+  step(id, tool14, input, options = {}) {
     this.definition.steps.push({
       id,
       name: id,
-      tool: tool12,
+      tool: tool14,
       input,
       dependsOn: options.dependsOn,
       condition: options.condition,
@@ -6644,8 +7549,8 @@ var HITLWorkflowEngine = class {
     const result = {};
     for (const [key, value] of Object.entries(input)) {
       if (typeof value === "string" && value.startsWith("{{") && value.endsWith("}}")) {
-        const path6 = value.slice(2, -2).trim();
-        result[key] = this.getValueFromPath(context, path6);
+        const path8 = value.slice(2, -2).trim();
+        result[key] = this.getValueFromPath(context, path8);
       } else {
         result[key] = value;
       }
@@ -6655,8 +7560,8 @@ var HITLWorkflowEngine = class {
   /**
    * Get value from path
    */
-  getValueFromPath(obj, path6) {
-    const parts = path6.split(".");
+  getValueFromPath(obj, path8) {
+    const parts = path8.split(".");
     let current = obj;
     for (const part of parts) {
       if (current && typeof current === "object") {
@@ -6747,6 +7652,119 @@ function createHITLWorkflowEngine(options) {
   return new HITLWorkflowEngine(options);
 }
 
-export { EVENT_BUDGETS, HITLWorkflowEngine, HITLv2Manager, MemoryIntegrationEngine, ReActEngine, ReActWorkflowEngine, ReActWorkflowExecutor, SessionManager, createHITLWorkflowEngine, createHITLv2Manager, createMemoryIntegration, createMultiStageApprovalWorkflow, createReActEngine, createReActWorkflowEngine, createReActWorkflowExecutor, createSchemaGenerationHITLWorkflow, createSkillAgent, getBudgetWarningMessage, getEventBudget, getInterruptConfig, resumeSkillAgent };
+// src/agent/workflow-tool-wrapper.ts
+function createWorkflowToolWrapper(options = {}) {
+  const {
+    maxRetries = 3,
+    enableTelemetry = true,
+    timeoutMs = 6e4,
+    backoffMs = 1e3
+  } = options;
+  const telemetry = [];
+  return {
+    wrap: (tool14) => {
+      return {
+        ...tool14,
+        invoke: async (...args) => {
+          const startTime = Date.now();
+          let retries = 0;
+          let lastError;
+          for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+              if (Date.now() - startTime > timeoutMs) {
+                throw new Error(`Tool ${tool14.name} exceeded timeout of ${timeoutMs}ms`);
+              }
+              const result = await tool14.invoke(...args);
+              if (enableTelemetry) {
+                telemetry.push({
+                  toolName: tool14.name,
+                  durationMs: Date.now() - startTime,
+                  retries,
+                  success: true
+                });
+              }
+              return result;
+            } catch (error) {
+              lastError = error;
+              const errorMsg = lastError.message?.toLowerCase() || "";
+              const isValidationError = errorMsg.includes("expected object, received string") || errorMsg.includes("expected array, received") || errorMsg.includes("required") || errorMsg.includes("invalid") || errorMsg.includes("validation");
+              if (isValidationError) {
+                console.log(`[Workflow] ${tool14.name} validation error (not retryable): ${lastError.message}`);
+                if (enableTelemetry) {
+                  telemetry.push({
+                    toolName: tool14.name,
+                    durationMs: Date.now() - startTime,
+                    retries: 0,
+                    success: false,
+                    error: lastError.message
+                  });
+                }
+                return {
+                  error: lastError.message,
+                  status: "error",
+                  toolName: tool14.name,
+                  suggestion: "Check the tool input format and try again with corrected parameters"
+                };
+              }
+              if (attempt < maxRetries) {
+                retries++;
+                const waitMs = backoffMs * Math.pow(2, attempt);
+                console.log(`[Workflow Retry] ${tool14.name} attempt ${retries}/${maxRetries}, waiting ${waitMs}ms...`);
+                await new Promise((resolve2) => setTimeout(resolve2, waitMs));
+              }
+            }
+          }
+          if (enableTelemetry) {
+            telemetry.push({
+              toolName: tool14.name,
+              durationMs: Date.now() - startTime,
+              retries,
+              success: false,
+              error: lastError?.message
+            });
+          }
+          return {
+            error: lastError?.message || "Tool execution failed after retries",
+            status: "error",
+            toolName: tool14.name,
+            retries
+          };
+        }
+      };
+    },
+    getTelemetry: () => [...telemetry],
+    resetTelemetry: () => {
+      telemetry.length = 0;
+    }
+  };
+}
+function createEvalWorkflowWrapper(options = {}) {
+  const wrapper = createWorkflowToolWrapper(options);
+  return {
+    ...wrapper,
+    wrap: (tool14) => {
+      const wrapped = wrapper.wrap(tool14);
+      const originalInvoke = wrapped.invoke;
+      wrapped.invoke = async (...args) => {
+        console.log(`[Workflow] Starting ${tool14.name}...`);
+        try {
+          const result = await originalInvoke(...args);
+          const allMetrics = wrapper.getTelemetry();
+          const metrics = allMetrics[allMetrics.length - 1];
+          console.log(`[Workflow] ${tool14.name} completed (${metrics?.durationMs}ms, ${metrics?.retries} retries)`);
+          return result;
+        } catch (error) {
+          const allMetrics = wrapper.getTelemetry();
+          const metrics = allMetrics[allMetrics.length - 1];
+          console.log(`[Workflow] ${tool14.name} failed after ${metrics?.retries} retries`);
+          throw error;
+        }
+      };
+      return wrapped;
+    }
+  };
+}
+
+export { EVENT_BUDGETS, HITLWorkflowEngine, HITLv2Manager, MemoryIntegrationEngine, ReActEngine, ReActWorkflowEngine, ReActWorkflowExecutor, SessionManager, createEvalWorkflowWrapper, createHITLWorkflowEngine, createHITLv2Manager, createMemoryIntegration, createMultiStageApprovalWorkflow, createReActEngine, createReActWorkflowEngine, createReActWorkflowExecutor, createSchemaGenerationHITLWorkflow, createSkillAgent, createWorkflowToolWrapper, getBudgetWarningMessage, getEventBudget, getInterruptConfig, resumeSkillAgent };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map