@almadar/agent 1.3.2 → 1.6.0

package/dist/index.js

@@ -1,15 +1,18 @@
 import { AgentDomainCategorySchema, isOrbitalDefinition, getTraitName, isPageReferenceString, isPageReferenceObject, isEntityReference } from '@almadar/core/types';
-import { getFullOrbitalPrompt, getRequirementsTraitPrompt, getKeyBehaviorsReference, getSExprQuickRef, getCommonErrorsSection, getArchitectureSection, getMinimalTypeReference } from '@almadar/skills';
+import { getSubagentSystemPrompt, getRequirementsTraitPrompt, getKeyBehaviorsReference, getSExprQuickRef, getCommonErrorsSection, getArchitectureSection, getMinimalTypeReference, getFullOrbitalPrompt } from '@almadar/skills';
 import { tool } from '@langchain/core/tools';
 import { z } from 'zod';
 import { LLMClient, isStructuredOutputAvailable, getStructuredOutputClient, createRequirementsClient, ANTHROPIC_MODELS, createAnthropicClient, OPENROUTER_MODELS, createOpenRouterClient, KIMI_MODELS, createKimiClient, OPENAI_MODELS, createOpenAIClient, DEEPSEEK_MODELS, createDeepSeekClient } from '@almadar/llm';
-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 crypto, { randomUUID } from 'crypto';
+import fs3__default from 'fs';
+import crypto, { createHash, randomUUID, createHmac, timingSafeEqual } from 'crypto';
+import os from 'os';
 import { GitHubIntegration } from '@almadar/integrations';
 import '@langchain/core/messages';
 import { FilesystemBackend, createDeepAgent } from 'deepagents';
@@ -254,20 +257,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,
@@ -307,7 +330,7 @@ ${guidance}`,
   const userBlocks = [
     {
       type: "text",
-      text: `## Current Orbital Unit
+      text: `## Current Orbital Unit (INPUT)
 Name: ${orbital.name}
 Entity: ${entityName}
 Persistence: ${persistence}
@@ -315,7 +338,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
@@ -1505,7 +1561,9 @@ var GenerateRequestSchema = z.object({
     owner: z.string().optional(),
     /** Repository name (e.g., 'hello-world') */
     repo: z.string().optional()
-  }).optional()
+  }).optional(),
+  /** Optional: Use orchestrated generation with complexity-based provider routing (default: true) */
+  useOrchestration: z.boolean().optional()
 }).strict();
 var ResumeRequestSchema = z.object({
   /** Required: Thread ID to resume */
@@ -1571,6 +1629,40 @@ function isSSESubagentEvent(event) {
 function isSSEGenerationLogEvent(event) {
   return event.type === "generation_log";
 }
+
+// src/agent/interrupt-config.ts
+var TOOL_GATES = {
+  // Always requires interrupt (handled by deepagents interruptOn)
+  execute: "sensitive"
+};
+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";
+}
+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",
@@ -1687,14 +1779,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];
@@ -1737,6 +1841,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 {
@@ -3113,7 +3224,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;
@@ -3184,8 +3296,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) {
@@ -3811,27 +3922,27 @@ var CombineSchemaInputSchema = z.object({
   validate: z.boolean().optional().default(true)
 });
 async function autoCollectOrbitals(workDir) {
-  const fs6 = await import('fs');
-  const path7 = await import('path');
-  const orbitalsDir = path7.join(workDir, ".orbitals");
-  if (!fs6.existsSync(orbitalsDir)) {
-    const files2 = fs6.readdirSync(workDir).filter(
+  const fs8 = await import('fs');
+  const path9 = await import('path');
+  const orbitalsDir = path9.join(workDir, ".orbitals");
+  if (!fs8.existsSync(orbitalsDir)) {
+    const files2 = fs8.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 = fs6.readFileSync(path7.join(workDir, f), "utf-8");
+      const content = fs8.readFileSync(path9.join(workDir, f), "utf-8");
       return JSON.parse(content);
     });
   }
-  const files = fs6.readdirSync(orbitalsDir).filter((f) => f.endsWith(".json"));
+  const files = fs8.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 = fs6.readFileSync(path7.join(orbitalsDir, f), "utf-8");
+    const content = fs8.readFileSync(path9.join(orbitalsDir, f), "utf-8");
     return JSON.parse(content);
   });
 }
@@ -4153,6 +4264,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 path9 = Array.isArray(e.path) ? e.path.join(".") : e.path;
+    return `- Path: ${path9}
+  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 = {
@@ -5662,16 +6592,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.
 
@@ -5878,6 +6798,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;
@@ -5937,10 +6881,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 ? [
@@ -5952,8 +6896,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({
@@ -6792,11 +7742,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,
@@ -6865,6 +7815,119 @@ function createSchemaGenerationWorkflow(engine) {
 function createWorkflowEngine(executor) {
   return new WorkflowEngine(executor);
 }
+
+// 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;
+    }
+  };
+}
 var FirestoreStore = class extends BaseStore {
   constructor(options) {
     super();
@@ -7022,9 +8085,9 @@ var FirestoreStore = class extends BaseStore {
     let query = this.db.collection(this.collection);
     if (op.matchConditions) {
       for (const condition of op.matchConditions) {
-        const path7 = condition.path.filter((p) => p !== "*").join("/");
+        const path9 = condition.path.filter((p) => p !== "*").join("/");
         if (condition.matchType === "prefix") {
-          query = query.where("namespaceKey", ">=", path7).where("namespaceKey", "<", path7 + "\uFFFF");
+          query = query.where("namespaceKey", ">=", path9).where("namespaceKey", "<", path9 + "\uFFFF");
         }
       }
     }
@@ -9574,11 +10637,502 @@ async function reviewSamples(sampler, options = {}) {
 function createOnlineEvalSampler(config) {
   return new OnlineEvalSampler(config);
 }
+var GENESIS_HASH = createHash("sha256").update("IC-AGI-GENESIS").digest("hex");
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value) ?? "null";
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  const pairs = keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`);
+  return `{${pairs.join(",")}}`;
+}
+function computeEntryHash(entry) {
+  const content = stableStringify({
+    data: entry.data,
+    index: entry.index,
+    prev_hash: entry.prevHash,
+    timestamp: entry.timestamp
+  });
+  return createHash("sha256").update(content).digest("hex");
+}
+var AuditLog = class {
+  constructor() {
+    this.entries = [];
+  }
+  /**
+   * Append a new entry to the chain.
+   * The timestamp is set here — callers cannot supply it.
+   */
+  append(data) {
+    const prevHash = this.entries.length > 0 ? this.entries[this.entries.length - 1].entryHash : GENESIS_HASH;
+    const partial = {
+      index: this.entries.length,
+      timestamp: Date.now() / 1e3,
+      data,
+      prevHash
+    };
+    const entry = { ...partial, entryHash: computeEntryHash(partial) };
+    this.entries.push(entry);
+    return entry;
+  }
+  /**
+   * Verify the integrity of the entire chain.
+   * Recomputes every entry hash and checks chain linkage.
+   * Returns false immediately on the first mismatch.
+   */
+  verify() {
+    for (let i = 0; i < this.entries.length; i++) {
+      const entry = this.entries[i];
+      if (entry.entryHash !== computeEntryHash(entry)) return false;
+      const expectedPrev = i === 0 ? GENESIS_HASH : this.entries[i - 1].entryHash;
+      if (entry.prevHash !== expectedPrev) return false;
+    }
+    return true;
+  }
+  /** Return entries, optionally filtered by source, event type, or count limit. */
+  getEntries(filter) {
+    let results = this.entries;
+    if (filter?.source) results = results.filter((e) => e.data["source"] === filter.source);
+    if (filter?.event) results = results.filter((e) => e.data["event"] === filter.event);
+    if (filter?.limit) results = results.slice(-filter.limit);
+    return results;
+  }
+  getEntry(index) {
+    return this.entries[index];
+  }
+  get length() {
+    return this.entries.length;
+  }
+};
+var MAX_TTL_SECONDS = 3600;
+var MAX_BUDGET = 100;
+function signablePayload(token) {
+  const payload = JSON.stringify({
+    budget: token.budget,
+    expires_at: token.expiresAt,
+    issued_at: token.issuedAt,
+    issued_to: token.issuedTo,
+    scope: [...token.scope].sort(),
+    token_id: token.tokenId
+  });
+  return Buffer.from(payload);
+}
+function issueToken(params, signingKey) {
+  const issuedAt = Date.now() / 1e3;
+  const ttl = Math.min(params.ttlSeconds ?? 60, MAX_TTL_SECONDS);
+  const budget = Math.min(params.budget ?? 1, MAX_BUDGET);
+  const token = {
+    tokenId: randomUUID(),
+    issuedTo: params.issuedTo,
+    scope: [...params.scope].sort(),
+    issuedAt,
+    expiresAt: issuedAt + ttl,
+    budget,
+    uses: 0,
+    revoked: false,
+    metadata: params.metadata ?? {},
+    signature: ""
+  };
+  token.signature = createHmac("sha256", signingKey).update(signablePayload(token)).digest("hex");
+  return token;
+}
+function verifyToken(token, signingKey) {
+  if (!token.signature) return false;
+  const expected = createHmac("sha256", signingKey).update(signablePayload(token)).digest("hex");
+  const a = Buffer.from(token.signature, "hex");
+  const b = Buffer.from(expected, "hex");
+  if (a.length !== b.length) return false;
+  return timingSafeEqual(a, b);
+}
+function isTokenValid(token) {
+  return !token.revoked && Date.now() / 1e3 <= token.expiresAt && token.uses < token.budget;
+}
+function consumeToken(token) {
+  if (!isTokenValid(token)) return false;
+  token.uses++;
+  return true;
+}
+function revokeToken(token) {
+  token.revoked = true;
+}
+var ThresholdAuthorizer = class {
+  /**
+   * @param k         Minimum approvals required (must be >= 2, P2)
+   * @param approverIds List of registered approver IDs (length >= k)
+   * @param auditLog  Optional audit chain for all voting events
+   */
+  constructor(k, approverIds, auditLog) {
+    this.requests = /* @__PURE__ */ new Map();
+    if (k < 2) throw new Error("Threshold must be >= 2 \u2014 no unilateral authority (P2)");
+    if (k > approverIds.length) throw new Error("Threshold cannot exceed number of approvers");
+    this.k = k;
+    this.n = approverIds.length;
+    this.approverIds = new Set(approverIds);
+    this.auditLog = auditLog;
+  }
+  /**
+   * Create a new approval request for a critical action.
+   * The request window is 5 minutes (300s).
+   */
+  createRequest(actionDescription, requester, criticality = "critical") {
+    const req = {
+      requestId: randomUUID(),
+      actionDescription,
+      criticality,
+      requester,
+      createdAt: Date.now() / 1e3,
+      ttlSeconds: 300,
+      approvals: /* @__PURE__ */ new Map(),
+      resolved: false,
+      resolution: null
+    };
+    this.requests.set(req.requestId, req);
+    this.auditLog?.append({
+      event: "APPROVAL_REQUEST_CREATED",
+      requestId: req.requestId,
+      action: actionDescription,
+      requester,
+      criticality
+    });
+    return req;
+  }
+  /**
+   * Submit a vote for a pending request.
+   * Auto-resolves the request when threshold is reached (approve)
+   * or when threshold becomes mathematically unreachable (deny).
+   *
+   * @throws if request not found, already resolved, expired, approver not registered, or double-vote
+   */
+  submitVote(requestId, approverId, vote) {
+    const req = this.requests.get(requestId);
+    if (!req) throw new Error(`Request ${requestId} not found`);
+    if (req.resolved) throw new Error(`Request ${requestId} already resolved (P4)`);
+    if (this.isExpired(requestId)) {
+      req.resolved = true;
+      req.resolution = "expired";
+      this.auditLog?.append({ event: "REQUEST_EXPIRED", requestId });
+      throw new Error(`Request ${requestId} has expired`);
+    }
+    if (!this.approverIds.has(approverId)) {
+      throw new Error(`Approver ${approverId} is not registered`);
+    }
+    if (req.approvals.has(approverId)) {
+      throw new Error(`Approver ${approverId} has already voted`);
+    }
+    req.approvals.set(approverId, vote);
+    this.auditLog?.append({ event: "VOTE_SUBMITTED", requestId, approverId, vote });
+    const yesVotes = [...req.approvals.values()].filter(Boolean).length;
+    const noVotes = [...req.approvals.values()].filter((v) => !v).length;
+    if (yesVotes >= this.k) {
+      req.resolved = true;
+      req.resolution = "approved";
+      this.auditLog?.append({ event: "REQUEST_APPROVED", requestId, approvals: yesVotes });
+    }
+    if (!req.resolved && noVotes > this.n - this.k) {
+      req.resolved = true;
+      req.resolution = "denied";
+      this.auditLog?.append({ event: "REQUEST_DENIED", requestId, denials: noVotes });
+    }
+    return {
+      status: req.resolved ? req.resolution : "pending",
+      approvals: yesVotes,
+      denials: noVotes,
+      threshold: this.k,
+      remaining: Math.max(0, this.k - yesVotes)
+    };
+  }
+  /** Returns true iff the request is resolved and approved (P1). */
+  isApproved(requestId) {
+    const req = this.requests.get(requestId);
+    return !!req?.resolved && req.resolution === "approved";
+  }
+  /** Returns true iff the request is resolved and denied (P3). */
+  isDenied(requestId) {
+    const req = this.requests.get(requestId);
+    return !!req?.resolved && req.resolution === "denied";
+  }
+  isExpired(requestId) {
+    const req = this.requests.get(requestId);
+    if (!req) return true;
+    return Date.now() / 1e3 > req.createdAt + req.ttlSeconds;
+  }
+  getRequest(requestId) {
+    return this.requests.get(requestId);
+  }
+};
+
+// src/security/rate-limiter.ts
+var SlidingWindowCounter = class {
+  constructor(max, windowSeconds, cooldownSeconds) {
+    this.max = max;
+    this.windowSeconds = windowSeconds;
+    this.cooldownSeconds = cooldownSeconds;
+    this.timestamps = [];
+    this.cooldownUntil = 0;
+  }
+  allow(now = Date.now() / 1e3) {
+    if (now < this.cooldownUntil) return false;
+    this.evict(now);
+    if (this.timestamps.length >= this.max) {
+      this.cooldownUntil = now + this.cooldownSeconds;
+      return false;
+    }
+    this.timestamps.push(now);
+    return true;
+  }
+  remaining(now = Date.now() / 1e3) {
+    this.evict(now);
+    return Math.max(0, this.max - this.timestamps.length);
+  }
+  get inCooldown() {
+    return Date.now() / 1e3 < this.cooldownUntil;
+  }
+  reset() {
+    this.timestamps = [];
+    this.cooldownUntil = 0;
+  }
+  evict(now) {
+    const cutoff = now - this.windowSeconds;
+    while (this.timestamps.length > 0 && (this.timestamps[0] ?? 0) < cutoff) {
+      this.timestamps.shift();
+    }
+  }
+};
+var RateLimiter = class {
+  constructor(config = {}, auditLog) {
+    this.counters = /* @__PURE__ */ new Map();
+    this.config = {
+      maxRequests: config.maxRequests ?? 20,
+      windowSeconds: config.windowSeconds ?? 60,
+      cooldownSeconds: config.cooldownSeconds ?? 30
+    };
+    this.global = new SlidingWindowCounter(
+      this.config.maxRequests * 10,
+      this.config.windowSeconds,
+      this.config.cooldownSeconds
+    );
+    this.auditLog = auditLog;
+  }
+  /**
+   * Check whether the (entity, scope) pair is allowed to proceed.
+   * Checks the global counter first, then the per-entity counter.
+   */
+  allow(entity, scope = "*") {
+    if (!this.global.allow()) {
+      this.auditLog?.append({ event: "GLOBAL_RATE_LIMIT", entity, scope });
+      return false;
+    }
+    const key = `${entity}:${scope}`;
+    if (!this.counters.has(key)) {
+      this.counters.set(
+        key,
+        new SlidingWindowCounter(
+          this.config.maxRequests,
+          this.config.windowSeconds,
+          this.config.cooldownSeconds
+        )
+      );
+    }
+    const counter = this.counters.get(key);
+    if (!counter.allow()) {
+      this.auditLog?.append({ event: "ENTITY_RATE_LIMIT", entity, scope });
+      return false;
+    }
+    return true;
+  }
+  remaining(entity, scope = "*") {
+    const key = `${entity}:${scope}`;
+    return this.counters.get(key)?.remaining() ?? this.config.maxRequests;
+  }
+  inCooldown(entity, scope = "*") {
+    const key = `${entity}:${scope}`;
+    return this.counters.get(key)?.inCooldown ?? false;
+  }
+  reset(entity, scope = "*") {
+    const key = `${entity}:${scope}`;
+    this.counters.get(key)?.reset();
+    this.auditLog?.append({ event: "RATE_LIMIT_RESET", entity, scope });
+  }
+  /** Reset all counters including global (test utility). */
+  resetAll() {
+    this.counters.clear();
+    this.global.reset();
+  }
+};
+
+// src/security/circuit-breaker.ts
+var CircuitState = /* @__PURE__ */ ((CircuitState2) => {
+  CircuitState2["CLOSED"] = "CLOSED";
+  CircuitState2["OPEN"] = "OPEN";
+  CircuitState2["HALF_OPEN"] = "HALF_OPEN";
+  return CircuitState2;
+})(CircuitState || {});
+var CircuitBreaker = class {
+  constructor(config = {}, auditLog) {
+    this.circuits = /* @__PURE__ */ new Map();
+    this.config = {
+      failureThreshold: config.failureThreshold ?? 3,
+      successThreshold: config.successThreshold ?? 2,
+      recoveryTimeoutSeconds: config.recoveryTimeoutSeconds ?? 30,
+      errorRateWindow: config.errorRateWindow ?? 120,
+      errorRateThreshold: config.errorRateThreshold ?? 0.5
+    };
+    this.auditLog = auditLog;
+  }
+  getOrCreate(workerId) {
+    if (!this.circuits.has(workerId)) {
+      this.circuits.set(workerId, {
+        workerId,
+        state: "CLOSED" /* CLOSED */,
+        consecutiveFailures: 0,
+        consecutiveSuccesses: 0,
+        totalRequests: 0,
+        totalFailures: 0,
+        lastFailureTime: 0,
+        openedAt: 0,
+        lastTransitionTime: Date.now() / 1e3,
+        recent: []
+      });
+    }
+    return this.circuits.get(workerId);
+  }
+  /** Compute error rate for the worker within the configured window. Prunes stale entries. */
+  errorRate(circuit, now = Date.now() / 1e3) {
+    const cutoff = now - this.config.errorRateWindow;
+    circuit.recent = circuit.recent.filter((r) => r.timestamp >= cutoff);
+    if (circuit.recent.length === 0) return 0;
+    const failures = circuit.recent.filter((r) => !r.success).length;
+    return failures / circuit.recent.length;
+  }
+  transition(circuit, newState) {
+    const oldState = circuit.state;
+    circuit.state = newState;
+    circuit.lastTransitionTime = Date.now() / 1e3;
+    if (newState === "OPEN" /* OPEN */) circuit.openedAt = circuit.lastTransitionTime;
+    if (newState === "CLOSED" /* CLOSED */) circuit.consecutiveFailures = 0;
+    this.auditLog?.append({
+      event: "CIRCUIT_TRANSITION",
+      workerId: circuit.workerId,
+      from: oldState,
+      to: newState
+    });
+  }
+  /**
+   * Check whether the worker is allowed to proceed.
+   * - CLOSED: always allowed
+   * - OPEN:   blocked until recovery timeout, then transitions to HALF_OPEN
+   * - HALF_OPEN: probe allowed through
+   */
+  allow(workerId) {
+    const now = Date.now() / 1e3;
+    const c = this.getOrCreate(workerId);
+    if (c.state === "CLOSED" /* CLOSED */) return true;
+    if (c.state === "OPEN" /* OPEN */) {
+      if (now - c.openedAt >= this.config.recoveryTimeoutSeconds) {
+        this.transition(c, "HALF_OPEN" /* HALF_OPEN */);
+        return true;
+      }
+      return false;
+    }
+    return true;
+  }
+  recordSuccess(workerId) {
+    const now = Date.now() / 1e3;
+    const c = this.getOrCreate(workerId);
+    c.consecutiveFailures = 0;
+    c.consecutiveSuccesses++;
+    c.totalRequests++;
+    c.recent.push({ timestamp: now, success: true });
+    if (c.state === "HALF_OPEN" /* HALF_OPEN */ && c.consecutiveSuccesses >= this.config.successThreshold) {
+      this.transition(c, "CLOSED" /* CLOSED */);
+    }
+  }
+  recordFailure(workerId) {
+    const now = Date.now() / 1e3;
+    const c = this.getOrCreate(workerId);
+    c.consecutiveFailures++;
+    c.consecutiveSuccesses = 0;
+    c.totalRequests++;
+    c.totalFailures++;
+    c.lastFailureTime = now;
+    c.recent.push({ timestamp: now, success: false });
+    if (c.state === "HALF_OPEN" /* HALF_OPEN */) {
+      this.transition(c, "OPEN" /* OPEN */);
+      return;
+    }
+    if (c.state === "CLOSED" /* CLOSED */) {
+      if (c.consecutiveFailures >= this.config.failureThreshold) {
+        this.transition(c, "OPEN" /* OPEN */);
+        return;
+      }
+      if (c.totalRequests >= 5 && this.errorRate(c, now) >= this.config.errorRateThreshold) {
+        this.transition(c, "OPEN" /* OPEN */);
+      }
+    }
+  }
+  getState(workerId) {
+    return this.getOrCreate(workerId).state;
+  }
+  getStats(workerId) {
+    const c = this.getOrCreate(workerId);
+    return {
+      state: c.state,
+      consecutiveFailures: c.consecutiveFailures,
+      totalRequests: c.totalRequests,
+      totalFailures: c.totalFailures
+    };
+  }
+};
+
+// src/tools/sandbox-executor.ts
+async function executeSandboxed(code, inputs = {}, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 5e3;
+  const memoryLimitMb = options.memoryLimitMb ?? 32;
+  let ivm;
+  try {
+    ivm = await import('isolated-vm');
+  } catch {
+    return executeSandboxedFallback(code, inputs, timeoutMs);
+  }
+  const isolate = new ivm.Isolate({ memoryLimit: memoryLimitMb });
+  try {
+    const context = await isolate.createContext();
+    const jail = context.global;
+    await jail.set("global", jail.derefInto());
+    await jail.set("inputs", new ivm.ExternalCopy(inputs).copyInto());
+    const script = await isolate.compileScript(code);
+    const result = await script.run(context, { timeout: timeoutMs });
+    return { success: true, value: result };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const timedOut = message.includes("Script execution timed out");
+    return { success: false, error: message, timedOut };
+  } finally {
+    isolate.dispose();
+  }
+}
+async function executeSandboxedFallback(code, inputs, timeoutMs) {
+  const vm = await import('vm');
+  const sandbox = { inputs, result: void 0 };
+  try {
+    vm.createContext(sandbox);
+    vm.runInContext(code, sandbox, { timeout: timeoutMs });
+    return { success: true, value: sandbox.result };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const timedOut = message.includes("timed out");
+    return { success: false, error: message, timedOut };
+  }
+}
 var export_applySectionUpdate = domain_language_exports.applySectionUpdate;
 var export_convertDomainToSchema = domain_language_exports.convertDomainToSchema;
 var export_convertSchemaToDomain = domain_language_exports.convertSchemaToDomain;
 var export_deleteSection = domain_language_exports.deleteSection;
 
-export { AgenticSearchEngine, ContinueRequestSchema, DEFAULT_COMPACTION_CONFIG, EVENT_BUDGETS, ExtractedRequirementsSchema, FirestoreCheckpointer, FirestoreSessionStore, FirestoreStore, GenerateRequestSchema, MCPClient, MCPClientManager, MCPResourceRegistry, MCPServer, MCPToolRegistry, MemoryManager, MemoryOrbitalSchema, MemorySessionBackend, MetricsCollector, ModelRouter, MultiUserManager, ObservabilityCollector, OnlineEvalSampler, PreferenceLearner, QwenCircuitBreaker, ResumeRequestSchema, SessionManager, StateSyncManager, WorkflowBuilder, WorkflowEngine, analyzeFailures, applyConservativeBias, export_applySectionUpdate as applySectionUpdate, combineOrbitals, combineOrbitalsToSchema, export_convertDomainToSchema as convertDomainToSchema, export_convertSchemaToDomain as convertSchemaToDomain, createAgentTools, createAgenticSearchEngine, createAlmadarMCPServer, createApplyChunkTool, createCombineSchemasTool, createCompactSystemPrompt, createConstructCombinedDomainTool, createDefaultMCPClientManager, createDomainOrbitalTools, createErrorFixerSubagent, createExecuteTool, createExtractChunkTool, createFinishTaskTool, createGenerateOrbitalDomainTool, createGenerateSchemaTool, createMCPClient, createMCPClientManager, createMCPServer, createModelRouter, createOnlineEvalSampler, createOrbitalSubagentTool, createPreferenceLearner, createQuerySchemaStructureTool, createSSEEvent, createSchemaChunkingTools, createSchemaGenerationWorkflow, createSchemaGeneratorSubagent, createSkillAgent, createSubagentConfigs, createSubagentEventWrapper, createSubagents, createSummaryPrompt, createSystemPrompt, createTestAnalyzerSubagent, createTraitEventWrapper, createTraitSubagentTool, createUserContext, createValidateSchemaTool, createWorkflowEngine, debounceSync, export_deleteSection as deleteSection, endObservabilitySession, estimateCacheSavings, estimateCombineComplexity, estimateOrbitalCount, estimateOrbitalCountBatch, estimateOrbitalCountHeuristic, estimateOrbitalCountLLM, estimateTokens, extractFileOperation, extractInterruptData, formatSSEEvent, formatSummary, generateFullOrbital, getBudgetWarningMessage, getCircuitBreaker, getEventBudget, getInterruptConfig, getModelRouter, getMultiUserManager, getObservabilityCollector, getPerformanceSnapshot, getStateSyncManager, hasDefiniteComplexIndicators, hasInterrupt, isAdmin, isCompleteEvent, isErrorEvent, isExecutionEvent, isFileOperation, isSSECompleteEvent, isSSEErrorEvent, isSSEGenerationLogEvent, isSSEInterruptEvent, isSSEMessageEvent, isSSEStartEvent, isSSESubagentEvent, isSSETodoDetailEvent, isSSETodoUpdateEvent, isSSEToolCallEvent, isSchemaEvent, isStartEvent, isTodoUpdate, makeSafeRoutingDecision, needsCompaction, parseDeepAgentEvent, parseSSEEvent, quickEstimate, recordEvent, requireOwnership, resetMultiUserManager, resetObservabilityCollector, resetStateSyncManager, resumeSkillAgent, reviewSamples, safeEstimate, startObservabilitySession, transformAgentEvent, transformAgentEventMulti, validateCommandPaths, withSync };
+export { AgenticSearchEngine, AuditLog, CRITICAL_COMMAND_PATTERNS, CircuitBreaker, CircuitState, ContinueRequestSchema, DEFAULT_COMPACTION_CONFIG, EVENT_BUDGETS, ExtractedRequirementsSchema, FirestoreCheckpointer, FirestoreSessionStore, FirestoreStore, GenerateRequestSchema, MCPClient, MCPClientManager, MCPResourceRegistry, MCPServer, MCPToolRegistry, MemoryManager, MemoryOrbitalSchema, MemorySessionBackend, MetricsCollector, ModelRouter, MultiUserManager, ObservabilityCollector, OnlineEvalSampler, PreferenceLearner, QwenCircuitBreaker, RateLimiter, ResumeRequestSchema, SessionManager, StateSyncManager, TOOL_GATES, ThresholdAuthorizer, WorkflowBuilder, WorkflowEngine, analyzeFailures, applyConservativeBias, export_applySectionUpdate as applySectionUpdate, classifyCommand, classifyComplexity, combineOrbitals, combineOrbitalsToSchema, consumeToken, export_convertDomainToSchema as convertDomainToSchema, export_convertSchemaToDomain as convertSchemaToDomain, createAgentTools, createAgenticSearchEngine, createAlmadarMCPServer, createApplyChunkTool, createCombineSchemasTool, createCompactSystemPrompt, createConstructCombinedDomainTool, createDefaultMCPClientManager, createDomainOrbitalTools, createErrorFixerSubagent, createEvalWorkflowWrapper, createExecuteTool, createExtractChunkTool, createFinishTaskTool, createGenerateOrbitalDomainTool, createGenerateSchemaTool, createMCPClient, createMCPClientManager, createMCPServer, createModelRouter, createOnlineEvalSampler, createOrbitalSubagentTool, createPreferenceLearner, createQuerySchemaStructureTool, createSSEEvent, createSchemaChunkingTools, createSchemaGenerationWorkflow, createSchemaGeneratorSubagent, createSkillAgent, createSubagentConfigs, createSubagentEventWrapper, createSubagents, createSummaryPrompt, createSystemPrompt, createTestAnalyzerSubagent, createTraitEventWrapper, createTraitSubagentTool, createUserContext, createValidateSchemaTool, createWorkflowEngine, createWorkflowToolWrapper, debounceSync, export_deleteSection as deleteSection, endObservabilitySession, estimateCacheSavings, estimateCombineComplexity, estimateComplexity, estimateOrbitalCount, estimateOrbitalCountBatch, estimateOrbitalCountHeuristic, estimateOrbitalCountLLM, estimateTokens, executeSandboxed, extractFileOperation, extractInterruptData, formatSSEEvent, formatSummary, generateFullOrbital, getBudgetWarningMessage, getCircuitBreaker, getEventBudget, getExecutionStrategy, getInterruptConfig, getModelRouter, getMultiUserManager, getObservabilityCollector, getPerformanceSnapshot, getStateSyncManager, hasDefiniteComplexIndicators, hasInterrupt, isAdmin, isCompleteEvent, isErrorEvent, isExecutionEvent, isFileOperation, isSSECompleteEvent, isSSEErrorEvent, isSSEGenerationLogEvent, isSSEInterruptEvent, isSSEMessageEvent, isSSEStartEvent, isSSESubagentEvent, isSSETodoDetailEvent, isSSETodoUpdateEvent, isSSEToolCallEvent, isSchemaEvent, isStartEvent, isTodoUpdate, isTokenValid, issueToken, makeSafeRoutingDecision, needsCompaction, parseDeepAgentEvent, parseSSEEvent, quickComplexityCheck, quickEstimate, recordEvent, requireOwnership, resetMultiUserManager, resetObservabilityCollector, resetStateSyncManager, resumeSkillAgent, reviewSamples, revokeToken, routeGeneration, safeEstimate, startObservabilitySession, transformAgentEvent, transformAgentEventMulti, validateCommandPaths, verifyToken, withSync };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map