@almadar/agent 1.3.3 → 1.6.1

package/dist/tools/index.js

@@ -1,15 +1,18 @@
 import { AgentDomainCategorySchema, isOrbitalDefinition, isEntityReference, getTraitName } from '@almadar/core/types';
 import { tool } from '@langchain/core/tools';
 import { z } from 'zod';
-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 { isStructuredOutputAvailable, getStructuredOutputClient, LLMClient } from '@almadar/llm';
 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 { getKeyBehaviorsReference, getSExprQuickRef, getCommonErrorsSection, getArchitectureSection, getFullOrbitalPrompt, getRequirementsTraitPrompt } from '@almadar/skills';
+import { getKeyBehaviorsReference, getSExprQuickRef, getCommonErrorsSection, getArchitectureSection, getSubagentSystemPrompt, getRequirementsTraitPrompt, getFullOrbitalPrompt } from '@almadar/skills';
+import os from 'os';
 import { GitHubIntegration } from '@almadar/integrations';
 
 var __defProp = Object.defineProperty;
@@ -207,20 +210,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,
@@ -260,7 +283,7 @@ ${guidance}`,
   const userBlocks = [
     {
       type: "text",
-      text: `## Current Orbital Unit
+      text: `## Current Orbital Unit (INPUT)
 Name: ${orbital.name}
 Entity: ${entityName}
 Persistence: ${persistence}
@@ -268,7 +291,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
@@ -303,6 +359,28 @@ var init_cache = __esm({
     init_prompt_assembler();
   }
 });
+
+// src/agent/interrupt-config.ts
+var CRITICAL_COMMAND_PATTERNS = [
+  /\bpnpm\s+publish\b/,
+  /\bnpm\s+publish\b/,
+  /\bgit\s+push\b.*\bmain\b/,
+  /\bgit\s+push\b.*\bmaster\b/,
+  /\bgit\s+push\b.*--force\b/,
+  /\brm\s+-rf\b/,
+  /\brmdir\b/,
+  /firebase\s+deploy/,
+  /gcloud\s+.*deploy/,
+  /\.env\b/
+];
+function classifyCommand(command) {
+  for (const pattern of CRITICAL_COMMAND_PATTERNS) {
+    if (pattern.test(command)) return "critical";
+  }
+  return "sensitive";
+}
+
+// src/tools/execute.ts
 var DANGEROUS_COMMANDS = [
   "rm",
   "rmdir",
@@ -419,14 +497,26 @@ function validateCommandPaths(command, workDir) {
   }
   return null;
 }
-function createExecuteTool(workDir) {
+function createExecuteTool(workDir, auditLog) {
   const normalizedWorkDir = path.resolve(workDir);
   return tool(
     async ({ command, timeout = 6e4 }) => {
       const validationError = validateCommandPaths(command, workDir);
       if (validationError) {
+        auditLog?.append({
+          event: "EXECUTE_BLOCKED",
+          command,
+          reason: validationError,
+          gate: classifyCommand(command)
+        });
         return validationError;
       }
+      auditLog?.append({
+        event: "EXECUTE_START",
+        command,
+        gate: classifyCommand(command),
+        workDir: normalizedWorkDir
+      });
       return new Promise((resolve2) => {
         const parts = command.split(" ");
         const cmd = parts[0];
@@ -469,6 +559,13 @@ function createExecuteTool(workDir) {
 
 Stderr:
 ${stderr}` : "");
+          auditLog?.append({
+            event: "EXECUTE_COMPLETE",
+            command,
+            exitCode: code,
+            outputLength: output.length,
+            success: code === 0
+          });
           if (code === 0) {
             resolve2(output || "Command completed successfully (no output)");
           } else {
@@ -1918,7 +2015,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;
@@ -1989,8 +2087,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) {
@@ -3302,27 +3399,27 @@ var CombineSchemaInputSchema = z.object({
   validate: z.boolean().optional().default(true)
 });
 async function autoCollectOrbitals(workDir) {
-  const fs5 = await import('fs');
-  const path6 = await import('path');
-  const orbitalsDir = path6.join(workDir, ".orbitals");
-  if (!fs5.existsSync(orbitalsDir)) {
-    const files2 = fs5.readdirSync(workDir).filter(
+  const fs7 = await import('fs');
+  const path8 = await import('path');
+  const orbitalsDir = path8.join(workDir, ".orbitals");
+  if (!fs7.existsSync(orbitalsDir)) {
+    const files2 = fs7.readdirSync(workDir).filter(
       (f) => f.endsWith(".json") && (f.startsWith("orbital-") || f.includes("orbital"))
     );
     if (files2.length === 0) {
       throw new Error("No orbitals found. Generate orbitals first using generate_orbital, or provide them directly.");
     }
     return files2.map((f) => {
-      const content = fs5.readFileSync(path6.join(workDir, f), "utf-8");
+      const content = fs7.readFileSync(path8.join(workDir, f), "utf-8");
       return JSON.parse(content);
     });
   }
-  const files = fs5.readdirSync(orbitalsDir).filter((f) => f.endsWith(".json"));
+  const files = fs7.readdirSync(orbitalsDir).filter((f) => f.endsWith(".json"));
   if (files.length === 0) {
     throw new Error("No orbitals found in .orbitals/ directory.");
   }
   return files.map((f) => {
-    const content = fs5.readFileSync(path6.join(orbitalsDir, f), "utf-8");
+    const content = fs7.readFileSync(path8.join(orbitalsDir, f), "utf-8");
     return JSON.parse(content);
   });
 }
@@ -3644,6 +3741,865 @@ 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 createComplexityCheckTool() {
+  return tool(
+    async ({ prompt }) => {
+      const check = quickComplexityCheck(prompt);
+      return {
+        estimatedOrbitals: check.estimatedOrbitals,
+        confidence: check.confidence,
+        likelyComplex: check.likelyComplex,
+        recommendedStrategy: check.likelyComplex ? "multi-provider-parallel" : "single-provider"
+      };
+    },
+    {
+      name: "check_complexity",
+      description: "Quickly estimate the complexity of a generation request without actually generating. Returns estimated orbital count and recommended strategy.",
+      schema: z.object({
+        prompt: z.string().describe("User prompt describing the application")
+      })
+    }
+  );
+}
+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 createValidateTool() {
+  return tool(
+    async ({ schema }) => {
+      const typedSchema = schema;
+      const result = validateSchema2(typedSchema);
+      return {
+        valid: result.valid,
+        errorCount: result.errors.length,
+        errors: result.errors
+      };
+    },
+    {
+      name: "validate_schema",
+      description: "Validate an OrbitalSchema and return any errors without attempting to fix them.",
+      schema: z.object({
+        schema: z.object({}).describe("The OrbitalSchema to validate")
+      })
+    }
+  );
+}
 function createGitHubTools(config) {
   const { token, owner = "", repo = "", workDir } = config;
   const integrationConfig = {
@@ -4017,6 +4973,6 @@ function createAgentTools(workDir) {
   };
 }
 
-export { createAgentTools, createApplyChunkTool, createCombineSchemasTool, createConstructCombinedDomainTool, createDomainOrbitalTools, createExecuteTool, createExtractChunkTool, createFinishTaskTool, createGenerateOrbitalDomainTool, createGenerateSchemaTool, createGitHubTools, createGitHubToolsArray, createOrbitalBatchSubagentTool, createOrbitalSubagentTool, createQuerySchemaStructureTool, createSchemaChunkingTools, createSubagentEventWrapper, createTraitEventWrapper, createTraitSubagentTool, createValidateSchemaTool, validateCommandPaths };
+export { createAgentTools, createApplyChunkTool, createCombineSchemasTool, createComplexityCheckTool, createConstructCombinedDomainTool, createDomainOrbitalTools, createExecuteTool, createExtractChunkTool, createFinishTaskTool, createGenerateOrbitalDomainTool, createGenerateSchemaTool, createGitHubTools, createGitHubToolsArray, createOrbitalBatchSubagentTool, createOrbitalSubagentTool, createOrchestratedFixingTool, createOrchestratedGenerationTool, createQuerySchemaStructureTool, createSchemaChunkingTools, createSubagentEventWrapper, createTraitEventWrapper, createTraitSubagentTool, createValidateSchemaTool, createValidateTool, validateCommandPaths };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map