@almadar/agent 1.6.0 → 1.6.2

package/dist/agent/index.js

@@ -2,7 +2,7 @@ import { AgentDomainCategorySchema, isOrbitalDefinition, isEntityReference, getT
 import { getSubagentSystemPrompt, getRequirementsTraitPrompt, getKeyBehaviorsReference, getSExprQuickRef, getCommonErrorsSection, getArchitectureSection, getFullOrbitalPrompt } from '@almadar/skills';
 import { tool } from '@langchain/core/tools';
 import { z } from 'zod';
-import { LLMClient, ANTHROPIC_MODELS, createAnthropicClient, OPENROUTER_MODELS, createOpenRouterClient, KIMI_MODELS, createKimiClient, OPENAI_MODELS, createOpenAIClient, DEEPSEEK_MODELS, createDeepSeekClient, createRequirementsClient } from '@almadar/llm';
+import { LLMClient, ANTHROPIC_MODELS, createAnthropicClient, OPENROUTER_MODELS, createOpenRouterClient, KIMI_MODELS, createKimiClient, OPENAI_MODELS, createOpenAIClient, DEEPSEEK_MODELS, createDeepSeekClient } from '@almadar/llm';
 import { FilesystemBackend, createDeepAgent } from 'deepagents';
 import { MemorySaver } from '@langchain/langgraph';
 export { Command } from '@langchain/langgraph';
@@ -11,7 +11,7 @@ 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 fs5 from 'fs/promises';
 import * as domain_language_star from '@almadar/core/domain-language';
 import * as fs3 from 'fs';
 import fs3__default from 'fs';
@@ -1408,12 +1408,12 @@ ${output}`);
       description: `Execute a shell command in the workspace directory.
 
 IMPORTANT: You are restricted to your workspace directory. Use RELATIVE paths only:
-- ./schema.json (NOT /schema.json or absolute paths)
+- ./schema.orb (NOT /schema.orb or absolute paths)
 - ./app (NOT /app or absolute paths)
 
 Examples:
-- orbital validate ./schema.json --json
-- npx kflow compile ./schema.json -o ./app --verify
+- orbital validate ./schema.orb --json
+- npx kflow compile ./schema.orb -o ./app --verify
 - cd ./app && npm install
 
 Commands using absolute paths outside your workspace will be blocked.`,
@@ -1427,7 +1427,7 @@ Commands using absolute paths outside your workspace will be blocked.`,
 var execAsync = promisify(exec);
 var MAX_VALIDATION_ATTEMPTS = 5;
 function createValidateSchemaTool(workDir) {
-  const schemaPath = path.join(workDir, "schema.json");
+  const schemaPath = path.join(workDir, "schema.orb");
   let validationAttempts = 0;
   return tool(
     async () => {
@@ -1443,7 +1443,7 @@ function createValidateSchemaTool(workDir) {
       }
       try {
         try {
-          await fs4.access(schemaPath);
+          await fs5.access(schemaPath);
         } catch {
           return JSON.stringify({
             success: false,
@@ -1452,7 +1452,7 @@ function createValidateSchemaTool(workDir) {
             errors: [{
               code: "FILE_NOT_FOUND",
               path: "",
-              message: "File not found: schema.json. Create it first with write_file."
+              message: "File not found: schema.orb. Create it first with write_file."
             }]
           });
         }
@@ -1513,7 +1513,7 @@ function createValidateSchemaTool(workDir) {
     },
     {
       name: "validate_schema",
-      description: `Validate the schema.json file in the workspace.
+      description: `Validate the schema.orb file in the workspace.
 
 Runs validation using \`npx @almadar/cli validate --json\`.
 
@@ -2039,14 +2039,14 @@ function checkCompositionQuality(schema) {
 async function collectOrbitalsFromDir(workDir) {
   const orbitalsDir = path.join(workDir, ".orbitals");
   try {
-    const dirStat = await fs4.stat(orbitalsDir);
+    const dirStat = await fs5.stat(orbitalsDir);
     if (!dirStat.isDirectory()) {
       return [];
     }
   } catch {
     return [];
   }
-  const files = await fs4.readdir(orbitalsDir);
+  const files = await fs5.readdir(orbitalsDir);
   const jsonFiles = files.filter((f) => f.endsWith(".json"));
   if (jsonFiles.length === 0) {
     return [];
@@ -2054,7 +2054,7 @@ async function collectOrbitalsFromDir(workDir) {
   const orbitals = [];
   for (const file of jsonFiles) {
     try {
-      const content = await fs4.readFile(path.join(orbitalsDir, file), "utf-8");
+      const content = await fs5.readFile(path.join(orbitalsDir, file), "utf-8");
       orbitals.push(JSON.parse(content));
     } catch {
     }
@@ -2108,7 +2108,7 @@ function createFinishTaskTool(workDir) {
         } else {
           const domainPath = path.join(workDir, "domain.txt");
           try {
-            const domainText = await fs4.readFile(domainPath, "utf-8");
+            const domainText = await fs5.readFile(domainPath, "utf-8");
             if (domainText.trim()) {
               source = "domain";
               const appName = input.summary?.match(/Generated \d+ orbitals?:?\s*(.+)/)?.[1] || "Application";
@@ -2141,8 +2141,8 @@ function createFinishTaskTool(workDir) {
           compositionWarnings = checkCompositionQuality(combinedSchema);
         }
         if (combinedSchema) {
-          const schemaPath = path.join(workDir, "schema.json");
-          await fs4.writeFile(schemaPath, JSON.stringify(combinedSchema, null, 2));
+          const schemaPath = path.join(workDir, "schema.orb");
+          await fs5.writeFile(schemaPath, JSON.stringify(combinedSchema, null, 2));
           validationResult = await validateSchemaWithCLI(schemaPath);
         }
       }
@@ -2163,25 +2163,16 @@ function createFinishTaskTool(workDir) {
           propCorrections: propCorrections || 0,
           compositionWarnings: compositionWarnings || []
         },
-        schemaPath: combinedSchema ? path.join(workDir, "schema.json") : input.schemaPath,
+        schemaPath: combinedSchema ? path.join(workDir, "schema.orb") : input.schemaPath,
         nextAction: "NONE - Task is complete. Output a brief success message to the user."
       };
     },
     {
       name: "finish_task",
-      description: `Signal that the orbital generation workflow is COMPLETE.
-
-\u26A0\uFE0F IMPORTANT: After calling this tool, STOP. Do not make any more tool calls.
-
-WHAT IT DOES:
-1. Automatically collects orbitals from .orbitals/ directory
-2. Combines them into a single OrbitalSchema
-3. Validates the combined schema
-4. Writes schema.json to workspace
-5. Returns success with stats`,
+      description: `Complete workflow: collect orbitals from .orbitals/, combine into schema, validate, write schema.orb. STOP after calling.`,
       schema: z.object({
-        summary: z.string().describe("Brief summary of what was accomplished"),
-        schemaPath: z.string().optional().describe("Path to the combined schema file if already written")
+        summary: z.string().describe("What was accomplished"),
+        schemaPath: z.string().optional().describe("Schema file path if already written")
       })
     }
   );
@@ -2195,7 +2186,7 @@ function generateFingerprint(spec) {
     entity: spec.entity,
     pages: spec.pages,
     traits: spec.traits.sort(),
-    patterns: spec.patterns.sort(),
+    patterns: spec.patterns?.sort() || [],
     emits: spec.emits?.sort() || [],
     listens: spec.listens?.map((l) => `${l.event}:${l.triggers}`).sort() || []
   });
@@ -2332,7 +2323,7 @@ ${relations}` : ""}
 ${pagesInfo}
 
 **Behaviors**: ${spec.traits.join(", ")}
-**UI Patterns**: ${spec.patterns.join(", ")}
+**UI Patterns**: ${spec.patterns?.join(", ") || "auto-detect from traits"}
 ${emitsInfo}
 ${listensInfo}
 
@@ -2364,7 +2355,7 @@ var GenerateOrbitalDomainSchema = z.object({
       isInitial: z.boolean().optional()
     })),
     traits: z.array(z.string()),
-    patterns: z.array(z.string()),
+    patterns: z.array(z.string()).optional(),
     domainContext: z.object({
       request: z.string(),
       requestFragment: z.string().optional(),
@@ -2510,7 +2501,7 @@ function createGenerateOrbitalDomainTool(options = {}) {
           cached: false,
           domainWritten: true,
           usage,
-          domainText
+          domainLength: domainText.length
         });
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
@@ -2788,6 +2779,88 @@ ${sections.join("\n\n")}
 `;
 }
 
+// src/evals/utils/compact-orbital.ts
+function compactField(f) {
+  let desc = `${f.name}:${f.type}`;
+  if (f.required) desc += "*";
+  if (f.values) desc += `(${f.values.length})`;
+  if (f.relation) desc += `\u2192${f.relation.entity}`;
+  return desc;
+}
+function getStateName(state) {
+  return typeof state === "string" ? state : state.name;
+}
+function getTraitRef(ref) {
+  return typeof ref === "string" ? ref : ref.ref;
+}
+function compactOrbital(orbital) {
+  const lines = [];
+  lines.push(`orbital: ${orbital.name}`);
+  if (orbital.entity) {
+    const e = orbital.entity;
+    const fieldSummary = e.fields?.map(compactField).join(", ") || "none";
+    const collection = e.collection ? ` (${e.collection})` : "";
+    lines.push(`  entity: ${e.name}${collection} [${fieldSummary}] ${e.fields?.length || 0} fields`);
+  }
+  if (orbital.traits) {
+    for (const trait of orbital.traits) {
+      const sm = trait.stateMachine;
+      if (sm) {
+        const stateNames = sm.states?.map(getStateName) || [];
+        const stateList = stateNames.join("\u2192");
+        const stateCount = stateNames.length;
+        const eventCount = sm.events?.length || 0;
+        const transCount = sm.transitions?.length || 0;
+        lines.push(`  trait: ${trait.name} [${stateList}] ${stateCount} states, ${eventCount} events, ${transCount} transitions`);
+      } else {
+        lines.push(`  trait: ${trait.name}`);
+      }
+    }
+  }
+  if (orbital.pages) {
+    for (const page of orbital.pages) {
+      const traitRefs = page.traits?.map(getTraitRef).join(", ") || "none";
+      lines.push(`  page: ${page.path} \u2192 ${traitRefs}`);
+    }
+  }
+  if (orbital.emits?.length) {
+    lines.push(`  emits: ${orbital.emits.join(", ")}`);
+  }
+  if (orbital.listens?.length) {
+    lines.push(`  listens: ${orbital.listens.map((l) => `${l.event} \u2192 ${l.triggers}`).join(", ")}`);
+  }
+  return lines.join("\n");
+}
+function compactSchema(schema) {
+  const lines = [];
+  if (schema.name) {
+    lines.push(`schema: ${schema.name} v${schema.version || "1.0.0"}`);
+  }
+  const orbitals = schema.orbitals || [];
+  lines.push(`orbitals: ${orbitals.length}`);
+  for (const orbital of orbitals) {
+    lines.push(compactOrbital(orbital));
+  }
+  return lines.join("\n");
+}
+function compactOrbitalResult(result) {
+  if (!result.orbital) {
+    return JSON.stringify({ success: false, error: "Generation failed" });
+  }
+  const orbital = result.orbital;
+  const summary = compactOrbital(orbital);
+  const validationLine = result.validation ? result.validation.valid ? "  validation: valid" : `  validation: INVALID (${result.validation.errors?.map((e) => e.message).join("; ") || "unknown errors"})` : "";
+  const usageLine = result.usage ? `  tokens: ${result.usage.totalTokens || 0}` : "";
+  const compactLines = [
+    `success: true`,
+    `fingerprint: ${result.fingerprint || "none"}`,
+    summary,
+    validationLine,
+    usageLine
+  ].filter(Boolean);
+  return compactLines.join("\n");
+}
+
 // src/tools/orbital-subagent.ts
 function getEntityName3(entity) {
   if (isEntityReference(entity)) {
@@ -2809,8 +2882,8 @@ var OrbitalInputSchema = z.object({
         })
       )
     }),
-    traits: z.array(z.string()),
-    patterns: z.array(z.string()),
+    traits: z.array(z.string()).default([]),
+    patterns: z.array(z.string()).optional(),
     pages: z.array(
       z.object({
         name: z.string(),
@@ -2997,7 +3070,16 @@ function createOrbitalSubagentTool(options = {}) {
             });
           }
         }
-        return JSON.stringify({
+        if (options.workDir && finalOrbital) {
+          const orbitalsDir = path.join(options.workDir, ".orbitals");
+          fs3.mkdirSync(orbitalsDir, { recursive: true });
+          const safeFileName = orbitalUnit.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+          fs3.writeFileSync(
+            path.join(orbitalsDir, `${safeFileName}.json`),
+            JSON.stringify(finalOrbital, null, 2)
+          );
+        }
+        return compactOrbitalResult({
           success: true,
           orbital: finalOrbital,
           fingerprint: result.fingerprint,
@@ -3019,15 +3101,19 @@ function createOrbitalSubagentTool(options = {}) {
     },
     {
       name: "generate_orbital",
-      description: `Generate a full orbital schema from an OrbitalUnit.
+      description: `Generate ONE orbital schema from a single OrbitalUnit.
 
 Spawns a subagent to expand a lightweight OrbitalUnit into a complete
 FullOrbitalUnit with all sections, layouts, and configurations.
 
+IMPORTANT: This tool generates exactly ONE orbital per call. Each orbital
+must have exactly ONE entity. For multi-entity apps, call this tool
+SEPARATELY for each orbital (e.g., 4 entities = 4 calls).
+
 USAGE:
-1. Decompose user request into OrbitalUnits
-2. For each orbital, call generate_orbital with embedded context
-3. Collect results and merge into final schema`,
+1. Decompose user request into OrbitalUnits (one per entity)
+2. Call generate_orbital ONCE PER ORBITAL \u2014 do NOT batch multiple orbitals
+3. After all orbitals are generated, call finish_task`,
       schema: OrbitalInputSchema
     }
   );
@@ -3094,7 +3180,7 @@ var CHUNKS_DIR = ".chunks";
 async function ensureChunksDir(workspaceDir) {
   const chunksPath = path.join(workspaceDir, CHUNKS_DIR);
   try {
-    await fs4.mkdir(chunksPath, { recursive: true });
+    await fs5.mkdir(chunksPath, { recursive: true });
   } catch {
   }
   return chunksPath;
@@ -3118,7 +3204,7 @@ function createQuerySchemaStructureTool(workDir) {
     async ({ file }) => {
       const filePath = path.isAbsolute(file) ? file : path.join(workDir, file);
       try {
-        const content = await fs4.readFile(filePath, "utf-8");
+        const content = await fs5.readFile(filePath, "utf-8");
         const schema = JSON.parse(content);
         const stats = fs3.statSync(filePath);
         const structure = {
@@ -3147,7 +3233,7 @@ function createQuerySchemaStructureTool(workDir) {
 
 USE THIS FIRST before extracting chunks to understand what orbitals and traits exist.`,
       schema: z.object({
-        file: z.string().describe('Path to schema file (e.g., "schema.json")')
+        file: z.string().describe('Path to schema file (e.g., "schema.orb")')
       })
     }
   );
@@ -3157,7 +3243,7 @@ function createExtractChunkTool(workDir) {
     async ({ file, type, name, parentOrbital, includeTraits = true }) => {
       const filePath = path.isAbsolute(file) ? file : path.join(workDir, file);
       try {
-        const content = await fs4.readFile(filePath, "utf-8");
+        const content = await fs5.readFile(filePath, "utf-8");
         const schema = JSON.parse(content);
         const chunkId = randomUUID().slice(0, 8);
         const chunksDir = await ensureChunksDir(workDir);
@@ -3208,7 +3294,7 @@ function createExtractChunkTool(workDir) {
           chunkData.inlineTrait = orbital.traits[inlineTraitIndex];
         }
         const chunkContent = JSON.stringify(chunkData, null, 2);
-        await fs4.writeFile(chunkFile, chunkContent);
+        await fs5.writeFile(chunkFile, chunkContent);
         const relativeChunkFile = path.relative(workDir, chunkFile);
         return JSON.stringify({
           success: true,
@@ -3246,14 +3332,14 @@ function createApplyChunkTool(workDir) {
       const chunkFilePath = path.join(workDir, CHUNKS_DIR, chunkFileName);
       try {
         try {
-          await fs4.access(chunkFilePath);
+          await fs5.access(chunkFilePath);
         } catch {
           return JSON.stringify({ error: `Chunk file not found: ${chunkFileName}.` });
         }
-        const chunkContent = await fs4.readFile(chunkFilePath, "utf-8");
+        const chunkContent = await fs5.readFile(chunkFilePath, "utf-8");
         const chunkData = JSON.parse(chunkContent);
         const { meta } = chunkData;
-        const schemaContent = await fs4.readFile(meta.sourceFile, "utf-8");
+        const schemaContent = await fs5.readFile(meta.sourceFile, "utf-8");
         const schema = JSON.parse(schemaContent);
         if (meta.type === "orbital" && chunkData.orbital) {
           schema.orbitals[meta.orbitalIndex] = chunkData.orbital;
@@ -3284,8 +3370,8 @@ function createApplyChunkTool(workDir) {
           }
         }
         const output = JSON.stringify(schema, null, 2);
-        await fs4.writeFile(meta.sourceFile, output);
-        await fs4.unlink(chunkFilePath);
+        await fs5.writeFile(meta.sourceFile, output);
+        await fs5.unlink(chunkFilePath);
         return JSON.stringify({
           success: true,
           message: `Changes merged into ${path.basename(meta.sourceFile)}`,
@@ -3648,12 +3734,70 @@ function quickComplexityCheck(prompt) {
     estimatedOrbitals: estimatedCounts[estimate.estimatedLevel]
   };
 }
+function categorizeError(error) {
+  const message = error.message?.toLowerCase() || "";
+  const code = error.code?.toLowerCase() || "";
+  if (message.includes("binding") || code.includes("binding")) {
+    return "binding";
+  }
+  if (message.includes("state") || code.includes("state")) {
+    return "state-machine";
+  }
+  if (message.includes("required") || message.includes("missing")) {
+    return "schema";
+  }
+  return "other";
+}
+function getErrorSpecificGuidance(errors) {
+  const types = new Set(errors.map(categorizeError));
+  const guidance = [];
+  if (types.has("binding")) {
+    guidance.push(`
+## BINDING ERROR FIXES
+
+Invalid bindings detected. Fix these patterns:
+
+\u274C INVALID:
+- "@count" - missing entity reference
+- "@count:status=active" - wrong syntax
+- "@entity" - missing field
+
+\u2705 VALID:
+- "@entity.count" - entity field reference
+- "@entity.status" - enum field reference  
+- "@payload.data" - payload reference
+- "@state.current" - state reference
+
+Replace invalid bindings with proper entity.field references.`);
+  }
+  if (types.has("state-machine")) {
+    guidance.push(`
+## STATE MACHINE FIXES
+
+Check for:
+- Unreachable states (no incoming transitions)
+- Missing transitions for events
+- Invalid state names
+
+Ensure every state (except initial) has at least one incoming transition.`);
+  }
+  if (types.has("schema")) {
+    guidance.push(`
+## SCHEMA FIXES
+
+Check for:
+- Required fields (name, type for entity fields)
+- Missing entity definitions
+- Invalid type values`);
+  }
+  return guidance.join("\n");
+}
 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")
+    (e) => e.severity === "error" || e.code?.includes("ENTITY") || e.code?.includes("REQUIRED")
   );
-  const warningErrors = errors.filter((e) => !criticalErrors.includes(e));
+  const warningErrors = errors.filter((e) => e.severity === "warning");
   const orbitalErrors = /* @__PURE__ */ new Map();
   errors.forEach((error, index) => {
     let pathStr;
@@ -3679,6 +3823,8 @@ async function createFixPlan(schema, errors, config) {
     const orbital = schema.orbitals[orbitalIndex];
     if (orbital) {
       affectedOrbitals.push(orbital.name);
+      const stepErrors = errorIndices.map((i) => errors[i]);
+      const errorType = categorizeError(stepErrors[0]);
       const midPoint = Math.ceil(errorIndices.length / 2);
       const batches = [
         errorIndices.slice(0, midPoint),
@@ -3691,7 +3837,8 @@ async function createFixPlan(schema, errors, config) {
           orbitalIndex,
           errorIndices: batch,
           provider: batchIndex === 0 ? "deepseek" : "qwen",
-          dependencies: []
+          dependencies: [],
+          errorType
         });
       });
     }
@@ -3716,13 +3863,14 @@ async function createFixPlan(schema, errors, config) {
     console.log(`[Fixing] Plan created in ${Date.now() - planStart}ms`);
     console.log(`[Fixing] Strategy: ${parallelizationStrategy}`);
     console.log(`[Fixing] Steps: ${executionOrder.length}`);
+    console.log(`[Fixing] Error types: ${[...new Set(executionOrder.map((s) => s.errorType))].join(", ")}`);
   }
   return plan;
 }
 async function executeFixStep(schema, step, errors, config) {
   const orbital = schema.orbitals[step.orbitalIndex];
   if (!orbital) {
-    return { success: false, updatedOrbital: null };
+    return { success: false, updatedOrbital: null, fixed: false };
   }
   const client = step.provider === "deepseek" ? new LLMClient({
     provider: "deepseek",
@@ -3732,58 +3880,30 @@ async function executeFixStep(schema, step, errors, config) {
     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
+  const errorGuidance = getErrorSpecificGuidance(stepErrors);
+  const skillContext = config.skillContent || "";
+  const systemPrompt = `You are an expert at fixing OrbitalSchema validation errors.
+${skillContext ? "\n" + skillContext.slice(0, 2e3) + "\n" : ""}
+${errorGuidance}
+
+CRITICAL RULES:
+1. Preserve ALL valid content - only fix the errors
+2. Return the COMPLETE orbital with all fields (entity, traits, pages)
+3. Ensure the entity field is present with proper name, collection, and fields
+4. Use valid binding formats: @entity.field, @payload.field, @state.field
 
 Return ONLY the fixed orbital as valid JSON.`;
-  const userPrompt = `Fix these validation errors in orbital "${orbital.name}":
+  const userPrompt = `Fix these errors in orbital "${orbital.name}":
 
-ERRORS:
-${stepErrors.map((e) => {
-    const path8 = Array.isArray(e.path) ? e.path.join(".") : e.path;
-    return `- Path: ${path8}
+ERRORS TO FIX:
+${stepErrors.map((e) => `- Path: ${Array.isArray(e.path) ? e.path.join(".") : e.path}
   Code: ${e.code}
-  Message: ${e.message}`;
-  }).join("\n")}
+  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).`;
+Return the COMPLETE fixed orbital as JSON. Include all fields (entity, traits, pages).`;
   try {
     const result = await client.call({
       systemPrompt,
@@ -3791,14 +3911,27 @@ Return the COMPLETE fixed orbital as JSON with all fields (entity, traits, pages
       maxTokens: 8192,
       skipSchemaValidation: true
     });
+    const fixedOrbital = result;
+    const hasEntity = fixedOrbital.entity && typeof fixedOrbital.entity === "object";
+    const hasName = typeof fixedOrbital.name === "string";
+    const hasTraits = Array.isArray(fixedOrbital.traits);
+    const isValid = Boolean(hasEntity && hasName && hasTraits);
+    if (!isValid && config.verbose) {
+      console.log(`[Fixing] Fix validation failed: entity=${hasEntity}, name=${hasName}, traits=${hasTraits}`);
+    }
     return {
-      success: true,
-      updatedOrbital: result
+      success: isValid,
+      updatedOrbital: result,
+      fixed: isValid
     };
   } catch (error) {
+    if (config.verbose) {
+      console.log(`[Fixing] Fix execution failed: ${error instanceof Error ? error.message : "Unknown"}`);
+    }
     return {
       success: false,
-      updatedOrbital: null
+      updatedOrbital: null,
+      fixed: false
     };
   }
 }
@@ -3816,22 +3949,22 @@ async function executeFixPlan(schema, plan, errors, config) {
       Promise.all(qwenSteps.map((step) => executeFixStep(schema, step, errors, config)))
     ]);
     deepseekSteps.forEach((step, i) => {
-      if (deepseekResults[i].success) {
+      if (deepseekResults[i].success && deepseekResults[i].fixed) {
         updatedSchema.orbitals[step.orbitalIndex] = deepseekResults[i].updatedOrbital;
       }
     });
     qwenSteps.forEach((step, i) => {
-      if (qwenResults[i].success) {
+      if (qwenResults[i].success && qwenResults[i].fixed) {
         updatedSchema.orbitals[step.orbitalIndex] = qwenResults[i].updatedOrbital;
       }
     });
   } else {
     for (const step of plan.executionOrder) {
       if (config.verbose) {
-        console.log(`[Fixing] Executing: ${step.description}`);
+        console.log(`[Fixing] Executing: ${step.description} (${step.errorType})`);
       }
       const result = await executeFixStep(schema, step, errors, config);
-      if (result.success) {
+      if (result.success && result.fixed) {
         updatedSchema.orbitals[step.orbitalIndex] = result.updatedOrbital;
       }
     }
@@ -3876,10 +4009,10 @@ function validateSchema(schema) {
     }
   }
 }
-async function orchestrateFixing(schema, config = {}) {
+async function orchestrateFixingV2(schema, config = {}) {
   const totalStart = Date.now();
   if (config.verbose) {
-    console.log("[Fixing] Starting Plan-Then-Execute fixing workflow");
+    console.log("[Fixing V2] Starting enhanced Plan-Then-Execute fixing workflow");
   }
   const initialValidation = validateSchema(schema);
   if (initialValidation.valid) {
@@ -3902,6 +4035,12 @@ async function orchestrateFixing(schema, config = {}) {
       }
     };
   }
+  if (config.verbose) {
+    console.log(`[Fixing V2] Found ${initialValidation.errors.length} errors to fix`);
+    initialValidation.errors.forEach((e) => {
+      console.log(`  - ${e.code}: ${e.message}`);
+    });
+  }
   const planStart = Date.now();
   const plan = await createFixPlan(schema, initialValidation.errors, config);
   const planMs = Date.now() - planStart;
@@ -3909,17 +4048,21 @@ async function orchestrateFixing(schema, config = {}) {
   let fixedSchema = await executeFixPlan(schema, plan, initialValidation.errors, config);
   const executeMs = Date.now() - executeStart;
   const verifyStart = Date.now();
-  const finalValidation = validateSchema(fixedSchema);
+  let 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})...`);
+      console.log(`[Fixing V2] Retrying (${retries + 1}/${maxRetries})...`);
+      console.log(`[Fixing V2] Remaining errors: ${finalValidation.errors.length}`);
     }
     const retryPlan = await createFixPlan(fixedSchema, finalValidation.errors, config);
     fixedSchema = await executeFixPlan(fixedSchema, retryPlan, finalValidation.errors, config);
     const retryValidation = validateSchema(fixedSchema);
+    if (config.verbose) {
+      console.log(`[Fixing V2] After retry: ${retryValidation.errors.length} errors remaining`);
+    }
     if (retryValidation.valid || retryValidation.errors.length < finalValidation.errors.length) {
       finalValidation.errors = retryValidation.errors;
       finalValidation.valid = retryValidation.valid;
@@ -3928,11 +4071,11 @@ async function orchestrateFixing(schema, config = {}) {
   }
   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"}`);
+    console.log("[Fixing V2] === Summary ===");
+    console.log(`[Fixing V2] Plan: ${planMs}ms, Execute: ${executeMs}ms, Verify: ${verifyMs}ms`);
+    console.log(`[Fixing V2] Total: ${totalMs}ms`);
+    console.log(`[Fixing V2] Errors: ${initialValidation.errors.length} \u2192 ${finalValidation.errors.length}`);
+    console.log(`[Fixing V2] Success: ${finalValidation.valid ? "YES" : "PARTIAL"}`);
   }
   return {
     success: finalValidation.valid,
@@ -3979,9 +4122,25 @@ function createOrchestratedGenerationTool(options) {
           version: "1.0.0",
           orbitals: result.orbitals
         };
+        if (options.workDir) {
+          const schemaPath = path.join(options.workDir, "schema.orb");
+          fs3.writeFileSync(schemaPath, JSON.stringify(schema, null, 2));
+          const orbitalsDir = path.join(options.workDir, ".orbitals");
+          fs3.mkdirSync(orbitalsDir, { recursive: true });
+          for (const orbital of result.orbitals) {
+            const name = ("name" in orbital ? String(orbital.name) : "unknown").replace(/[^a-zA-Z0-9_-]/g, "_");
+            fs3.writeFileSync(
+              path.join(orbitalsDir, `${name}.json`),
+              JSON.stringify(orbital, null, 2)
+            );
+          }
+        }
+        const summary = compactSchema(schema);
         return {
           success: true,
-          schema,
+          summary,
+          orbitalCount: result.orbitals.length,
+          schemaPath: options.workDir ? path.join(options.workDir, "schema.orb") : void 0,
           complexity: result.complexity,
           provider: result.provider,
           timing: result.timing
@@ -3999,16 +4158,9 @@ function createOrchestratedGenerationTool(options) {
     },
     {
       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.`,
+      description: `Generate an OrbitalSchema with automatic complexity-based provider routing.`,
       schema: z.object({
-        prompt: z.string().describe("User prompt describing the application to generate")
+        prompt: z.string().describe("App description prompt")
       })
     }
   );
@@ -4083,7 +4235,7 @@ function createOrchestratedFixingTool(options) {
         console.log(`[OrchestratedFixing] Found ${initialValidation.errors.length} errors to fix`);
       }
       try {
-        const result = await orchestrateFixing(typedSchema, {
+        const result = await orchestrateFixingV2(typedSchema, {
           maxRetries,
           verbose,
           skillContent
@@ -5342,7 +5494,19 @@ ${skillContents}`;
     }
   }
   const memoryContext = buildMemoryContext(userPreferences, projectContext);
-  const systemPrompt = [
+  const useOrchestration = options.useOrchestration ?? false;
+  const systemPrompt = useOrchestration ? `You are an orbital schema generator. You MUST use tools to complete your task. Do NOT respond with text \u2014 ONLY call tools.
+
+Your workflow has exactly 2 steps:
+
+STEP 1: Call the "orchestrated_generation" tool with the user's full request as the "prompt" parameter.
+STEP 2: After orchestrated_generation completes, call the "finish_task" tool to assemble and return the final schema.
+
+IMPORTANT:
+- You MUST call orchestrated_generation as your FIRST action. Do not plan, analyze, or discuss \u2014 just call the tool.
+- Do NOT call generate_orbital directly \u2014 orchestrated_generation handles that internally.
+- Do NOT generate any orbital JSON yourself \u2014 the tools handle all generation.
+- After calling orchestrated_generation, ALWAYS call finish_task to finalize.` : [
     BASE_SYSTEM_PROMPT,
     "\n## Skill Instructions\n\n" + skillInstructions,
     references ? "\n## Reference Documentation\n\n" + references : "",
@@ -5364,14 +5528,14 @@ ${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
+        verbose,
+        workDir
       });
       if (verbose) {
         console.log(`[SkillAgent] Orchestrated generation enabled for ${primarySkill.name}`);
@@ -5399,7 +5563,8 @@ ${skillContents}`;
     const orbitalResult = createOrbitalSubagentTool({
       requirements: options.requirements,
       provider: subagentProvider,
-      model: subagentModel
+      model: subagentModel,
+      workDir
     });
     orbitalTool = orbitalResult.tool;
     setOrbitalEventCallback = orbitalResult.setEventCallback;
@@ -5597,2061 +5762,6 @@ function getBudgetWarningMessage(eventCount, budget) {
   return null;
 }
 
-// src/agent/react-reflection.ts
-var ReActEngine = class {
-  constructor(options = {}) {
-    this.sessions = /* @__PURE__ */ new Map();
-    this.options = {
-      maxIterations: options.maxIterations ?? 10,
-      enableReflection: options.enableReflection ?? true,
-      enableAutoCorrect: options.enableAutoCorrect ?? true,
-      memoryManager: options.memoryManager,
-      onStep: options.onStep ?? (() => {
-      }),
-      onError: options.onError ?? (() => {
-      })
-    };
-  }
-  /**
-   * Start a new ReAct session
-   */
-  startSession(userRequest) {
-    const sessionId = `react_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
-    const session = {
-      sessionId,
-      userRequest,
-      currentStep: 0,
-      steps: [],
-      maxIterations: this.options.maxIterations,
-      state: "REASONING"
-    };
-    this.sessions.set(sessionId, session);
-    return session;
-  }
-  /**
-   * Execute REASON step
-   */
-  async reason(sessionId, context) {
-    const session = this.getSession(sessionId);
-    const thought = await this.generateThought(context);
-    const step = {
-      stepNumber: ++session.currentStep,
-      state: "REASONING",
-      thought,
-      timestamp: /* @__PURE__ */ new Date()
-    };
-    session.steps.push(step);
-    session.state = "ACTING";
-    this.options.onStep(step);
-    return step;
-  }
-  /**
-   * Execute ACT step
-   */
-  async act(sessionId, action, actionInput) {
-    const session = this.getSession(sessionId);
-    const previousStep = session.steps[session.steps.length - 1];
-    const step = {
-      stepNumber: ++session.currentStep,
-      state: "ACTING",
-      thought: previousStep?.thought ?? "",
-      action,
-      actionInput,
-      timestamp: /* @__PURE__ */ new Date()
-    };
-    session.steps.push(step);
-    session.state = "OBSERVING";
-    this.options.onStep(step);
-    return step;
-  }
-  /**
-   * Execute OBSERVE step
-   */
-  async observe(sessionId, observation) {
-    const session = this.getSession(sessionId);
-    const previousStep = session.steps[session.steps.length - 1];
-    const step = {
-      stepNumber: ++session.currentStep,
-      state: "OBSERVING",
-      thought: previousStep?.thought ?? "",
-      action: previousStep?.action,
-      actionInput: previousStep?.actionInput,
-      observation,
-      timestamp: /* @__PURE__ */ new Date()
-    };
-    session.steps.push(step);
-    session.state = this.options.enableReflection ? "REFLECTING" : "COMPLETE";
-    this.options.onStep(step);
-    return step;
-  }
-  /**
-   * Execute REFLECT step
-   */
-  async reflect(sessionId, result) {
-    const session = this.getSession(sessionId);
-    const previousStep = session.steps[session.steps.length - 1];
-    const reflection = await this.performReflection(session, result);
-    const step = {
-      stepNumber: ++session.currentStep,
-      state: "REFLECTING",
-      thought: previousStep?.thought ?? "",
-      action: previousStep?.action,
-      actionInput: previousStep?.actionInput,
-      observation: previousStep?.observation,
-      reflection: reflection.notes,
-      timestamp: /* @__PURE__ */ new Date()
-    };
-    session.steps.push(step);
-    if (reflection.shouldCorrect && this.options.enableAutoCorrect) {
-      session.state = "CORRECTING";
-    } else {
-      session.state = "COMPLETE";
-    }
-    this.options.onStep(step);
-    return { step, reflection };
-  }
-  /**
-   * Execute CORRECT step (auto-correction)
-   */
-  async correct(sessionId, correctionAction, correctionInput) {
-    const session = this.getSession(sessionId);
-    const previousStep = session.steps[session.steps.length - 1];
-    const step = {
-      stepNumber: ++session.currentStep,
-      state: "CORRECTING",
-      thought: `Correcting: ${previousStep?.reflection}`,
-      action: correctionAction,
-      actionInput: correctionInput,
-      timestamp: /* @__PURE__ */ new Date()
-    };
-    session.steps.push(step);
-    session.state = "OBSERVING";
-    this.options.onStep(step);
-    if (this.options.memoryManager) {
-      await this.storeCorrection(session, step);
-    }
-    return step;
-  }
-  /**
-   * Handle errors with context preservation
-   */
-  async handleError(sessionId, error, context) {
-    const session = this.getSession(sessionId);
-    const step = {
-      stepNumber: ++session.currentStep,
-      state: "REFLECTING",
-      thought: "",
-      error: error.message,
-      timestamp: /* @__PURE__ */ new Date()
-    };
-    session.steps.push(step);
-    this.options.onError(error, step);
-    if (this.options.memoryManager) {
-      await this.storeError(session, error, context);
-    }
-    return step;
-  }
-  /**
-   * Get session by ID
-   */
-  getSession(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-    return session;
-  }
-  /**
-   * Get reflection metrics
-   */
-  getReflectionMetrics(sessionId) {
-    const session = this.getSession(sessionId);
-    const reflections = session.steps.filter((s) => s.state === "REFLECTING");
-    const corrections = session.steps.filter((s) => s.state === "CORRECTING").length;
-    const errors = session.steps.filter((s) => s.error).length;
-    return {
-      totalSteps: session.currentStep,
-      corrections,
-      errors,
-      averageConfidence: reflections.length > 0 ? 0.8 : 0
-      // Simplified
-    };
-  }
-  // ============================================================================
-  // Private Helpers
-  // ============================================================================
-  async generateThought(context) {
-    return `I need to analyze the request: "${context.request}". Previous attempts: ${context.previousSteps?.length ?? 0}.`;
-  }
-  async performReflection(session, result) {
-    const hasErrors = result === null || typeof result === "object" && result !== null && "error" in result;
-    if (hasErrors) {
-      return {
-        shouldCorrect: true,
-        correctionStrategy: "retry_with_validation",
-        confidence: 0.3,
-        notes: "Result contains errors, correction needed"
-      };
-    }
-    if (session.currentStep >= session.maxIterations) {
-      return {
-        shouldCorrect: false,
-        confidence: 0.9,
-        notes: "Max iterations reached, completing task"
-      };
-    }
-    return {
-      shouldCorrect: false,
-      confidence: 0.9,
-      notes: "Result looks good"
-    };
-  }
-  async storeCorrection(session, step) {
-    if (!this.options.memoryManager) return;
-    console.log(`[ReAct] Storing correction for session ${session.sessionId}`);
-  }
-  async storeError(session, error, context) {
-    if (!this.options.memoryManager) return;
-    console.log(`[ReAct] Storing error for session ${session.sessionId}: ${error.message}`);
-  }
-};
-function createReActEngine(options) {
-  return new ReActEngine(options);
-}
-
-// src/agent/hitl-v2.ts
-var HITLv2Manager = class {
-  constructor(options = {}) {
-    this.pendingInterrupts = /* @__PURE__ */ new Map();
-    this.responses = /* @__PURE__ */ new Map();
-    this.checkpoints = /* @__PURE__ */ new Map();
-    this.options = {
-      defaultTimeoutMs: options.defaultTimeoutMs ?? 3e5,
-      // 5 minutes
-      memoryManager: options.memoryManager,
-      onInterrupt: options.onInterrupt,
-      onResponse: options.onResponse
-    };
-  }
-  // ============================================================================
-  // Interrupt Creation
-  // ============================================================================
-  /**
-   * Create a confirmation interrupt
-   */
-  async confirm(sessionId, question, options = {}) {
-    const payload = {
-      question,
-      severity: options.severity ?? "info",
-      defaultValue: options.defaultValue
-    };
-    const request = await this.createInterrupt(
-      sessionId,
-      "confirm",
-      "Confirmation Required",
-      question,
-      payload,
-      options.timeoutMs,
-      options.context
-    );
-    return this.waitForResponse(request);
-  }
-  /**
-   * Create an edit interrupt
-   */
-  async edit(sessionId, content, options = {}) {
-    const payload = {
-      content,
-      format: options.format ?? "text",
-      schema: options.schema
-    };
-    const request = await this.createInterrupt(
-      sessionId,
-      "edit",
-      options.title ?? "Edit Content",
-      options.description ?? "Please review and edit the content",
-      payload,
-      options.timeoutMs,
-      options.context
-    );
-    return this.waitForResponse(request);
-  }
-  /**
-   * Create a selection interrupt
-   */
-  async select(sessionId, options, config = {}) {
-    const payload = {
-      options,
-      multiple: config.multiple
-    };
-    const request = await this.createInterrupt(
-      sessionId,
-      "select",
-      config.title ?? "Make a Selection",
-      config.description ?? "Please select an option",
-      payload,
-      config.timeoutMs,
-      config.context
-    );
-    return this.waitForResponse(request);
-  }
-  /**
-   * Create a text input interrupt
-   */
-  async text(sessionId, options = {}) {
-    const payload = {
-      placeholder: options.placeholder,
-      multiline: options.multiline,
-      maxLength: options.maxLength
-    };
-    const request = await this.createInterrupt(
-      sessionId,
-      "text",
-      options.title ?? "Input Required",
-      options.description ?? "Please provide input",
-      payload,
-      options.timeoutMs,
-      options.context
-    );
-    return this.waitForResponse(request);
-  }
-  // ============================================================================
-  // Response Handling
-  // ============================================================================
-  /**
-   * Submit a response to an interrupt
-   */
-  async submitResponse(interruptId, response, userId) {
-    const request = this.pendingInterrupts.get(interruptId);
-    if (!request) {
-      throw new Error(`Interrupt not found or expired: ${interruptId}`);
-    }
-    const responseRecord = {
-      interruptId,
-      response,
-      respondedAt: /* @__PURE__ */ new Date(),
-      userId
-    };
-    this.responses.set(interruptId, responseRecord);
-    this.pendingInterrupts.delete(interruptId);
-    if (this.options.memoryManager) {
-      await this.storeInteraction(request, responseRecord);
-    }
-    this.options.onResponse?.(request, responseRecord);
-  }
-  /**
-   * Cancel an interrupt
-   */
-  cancelInterrupt(interruptId, reason) {
-    const request = this.pendingInterrupts.get(interruptId);
-    if (!request) return;
-    this.pendingInterrupts.delete(interruptId);
-    console.log(`[HITLv2] Interrupt ${interruptId} cancelled: ${reason ?? "No reason"}`);
-  }
-  // ============================================================================
-  // Time-Travel Debugging
-  // ============================================================================
-  /**
-   * Save a checkpoint for time-travel
-   */
-  saveCheckpoint(checkpointId, state) {
-    this.checkpoints.set(checkpointId, JSON.parse(JSON.stringify(state)));
-  }
-  /**
-   * Restore a checkpoint
-   */
-  restoreCheckpoint(checkpointId) {
-    const checkpoint = this.checkpoints.get(checkpointId);
-    if (!checkpoint) return null;
-    return JSON.parse(JSON.stringify(checkpoint));
-  }
-  /**
-   * List available checkpoints
-   */
-  listCheckpoints() {
-    return Array.from(this.checkpoints.keys());
-  }
-  /**
-   * Rewind to checkpoint and continue
-   */
-  async rewindToCheckpoint(checkpointId, sessionId, modifyFn) {
-    let state = this.restoreCheckpoint(checkpointId);
-    if (!state) return null;
-    if (modifyFn) {
-      state = modifyFn(state);
-    }
-    console.log(`[HITLv2] Session ${sessionId} rewound to checkpoint ${checkpointId}`);
-    return state;
-  }
-  // ============================================================================
-  // Analytics
-  // ============================================================================
-  /**
-   * Get interrupt statistics
-   */
-  getStats() {
-    const responses = Array.from(this.responses.values());
-    const totalResponseTime = responses.reduce((sum, r) => {
-      const request = this.pendingInterrupts.get(r.interruptId);
-      if (!request) return sum;
-      return sum + (r.respondedAt.getTime() - request.createdAt.getTime());
-    }, 0);
-    return {
-      pendingCount: this.pendingInterrupts.size,
-      totalHandled: this.responses.size,
-      checkpointsCount: this.checkpoints.size,
-      averageResponseTimeMs: responses.length > 0 ? totalResponseTime / responses.length : 0
-    };
-  }
-  /**
-   * Get pending interrupts for a session
-   */
-  getPendingForSession(sessionId) {
-    return Array.from(this.pendingInterrupts.values()).filter((req) => req.sessionId === sessionId);
-  }
-  // ============================================================================
-  // Private Helpers
-  // ============================================================================
-  async createInterrupt(sessionId, type, title, description, payload, timeoutMs, partialContext) {
-    const interruptId = `int_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
-    const checkpointId = `chk_${interruptId}`;
-    const request = {
-      interruptId,
-      sessionId,
-      type,
-      title,
-      description,
-      context: {
-        checkpointId,
-        currentState: partialContext?.currentState ?? "unknown",
-        previousActions: partialContext?.previousActions ?? [],
-        relevantMemory: partialContext?.relevantMemory
-      },
-      payload,
-      timeoutMs: timeoutMs ?? this.options.defaultTimeoutMs,
-      createdAt: /* @__PURE__ */ new Date()
-    };
-    this.pendingInterrupts.set(interruptId, request);
-    setTimeout(() => {
-      if (this.pendingInterrupts.has(interruptId)) {
-        this.cancelInterrupt(interruptId, "Timeout");
-      }
-    }, request.timeoutMs);
-    this.options.onInterrupt?.(request);
-    return request;
-  }
-  async waitForResponse(request) {
-    return new Promise((resolve2, reject) => {
-      const checkInterval = setInterval(() => {
-        const response = this.responses.get(request.interruptId);
-        if (response) {
-          clearInterval(checkInterval);
-          resolve2(response.response);
-          this.responses.delete(request.interruptId);
-        }
-        if (!this.pendingInterrupts.has(request.interruptId)) {
-          clearInterval(checkInterval);
-          reject(new Error("Interrupt cancelled or expired"));
-        }
-      }, 100);
-    });
-  }
-  async storeInteraction(request, response) {
-    if (!this.options.memoryManager) return;
-    console.log(`[HITLv2] Storing interaction: ${request.type} \u2192 ${JSON.stringify(response.response).slice(0, 50)}`);
-  }
-};
-function createHITLv2Manager(options) {
-  return new HITLv2Manager(options);
-}
-
-// src/memory/agentic-search.ts
-var AgenticSearchEngine = class {
-  constructor(memoryManager) {
-    this.memoryManager = memoryManager;
-  }
-  /**
-   * Perform agentic search through memory
-   */
-  async search(params) {
-    const startTime = Date.now();
-    const strategy = params.strategy ?? "hybrid";
-    const depth = params.depth ?? 3;
-    const limit = params.limit ?? 10;
-    let results = [];
-    switch (strategy) {
-      case "temporal":
-        results = await this.temporalSearch(params, depth, limit);
-        break;
-      case "semantic":
-        results = await this.semanticSearch(params, depth, limit);
-        break;
-      case "pattern":
-        results = await this.patternSearch(params, depth, limit);
-        break;
-      case "hybrid":
-      default:
-        results = await this.hybridSearch(params, depth, limit);
-        break;
-    }
-    results.sort((a, b) => b.relevance - a.relevance);
-    const insights = this.generateInsights(results, params.query);
-    const duration = Date.now() - startTime;
-    return {
-      results: results.slice(0, limit),
-      insights,
-      metadata: {
-        strategy,
-        depth,
-        duration,
-        totalResults: results.length
-      }
-    };
-  }
-  // ============================================================================
-  // Search Strategies
-  // ============================================================================
-  /**
-   * Temporal search - "What did I do last week?"
-   * Navigates memory by time relationships
-   */
-  async temporalSearch(params, _depth, limit) {
-    const results = [];
-    const isRecentQuery = /recent|last|latest|newest/i.test(params.query);
-    /week|month|day|ago/i.test(params.query);
-    const sessions = await this.memoryManager.getUserGenerationHistory(params.userId, limit * 2);
-    for (const session of sessions) {
-      let relevance = 0.5;
-      let reasoning = "Recent generation session";
-      if (isRecentQuery) {
-        const daysAgo = (Date.now() - session.createdAt.getTime()) / (1e3 * 60 * 60 * 24);
-        relevance = Math.max(0.1, 1 - daysAgo / 30);
-        reasoning = `Created ${Math.round(daysAgo)} days ago`;
-      }
-      const sessionText = `${session.prompt} ${session.entities.join(" ")} ${session.patterns.join(" ")}`.toLowerCase();
-      const queryTerms = params.query.toLowerCase().split(/\s+/);
-      const termMatches = queryTerms.filter((term) => sessionText.includes(term)).length;
-      relevance += termMatches * 0.1;
-      if (relevance > 0.3) {
-        results.push({
-          type: "session",
-          data: session,
-          relevance: Math.min(1, relevance),
-          reasoning,
-          source: "generation_history",
-          timestamp: session.createdAt
-        });
-      }
-    }
-    return results;
-  }
-  /**
-   * Semantic search - "How did I handle user roles?"
-   * Reasoning-based understanding of structure
-   */
-  async semanticSearch(params, _depth, limit) {
-    const results = [];
-    const concepts = this.extractConcepts(params.query);
-    const prefs = await this.memoryManager.getUserPreferences(params.userId);
-    if (prefs) {
-      let relevance = 0.3;
-      const matchedConcepts = [];
-      if (concepts.naming && prefs.namingConvention) {
-        relevance += 0.2;
-        matchedConcepts.push(`uses ${prefs.namingConvention}`);
-      }
-      if (concepts.patterns && prefs.preferredPatterns.length > 0) {
-        const matched = prefs.preferredPatterns.filter(
-          (p) => concepts.patterns?.some((cp) => p.toLowerCase().includes(cp.toLowerCase()))
-        );
-        relevance += matched.length * 0.1;
-        matchedConcepts.push(`patterns: ${matched.join(", ")}`);
-      }
-      if (concepts.entities && prefs.commonEntities.length > 0) {
-        const matched = prefs.commonEntities.filter(
-          (e) => concepts.entities?.some((ce) => e.toLowerCase().includes(ce.toLowerCase()))
-        );
-        relevance += matched.length * 0.1;
-        matchedConcepts.push(`entities: ${matched.join(", ")}`);
-      }
-      if (relevance > 0.4) {
-        results.push({
-          type: "preference",
-          data: prefs,
-          relevance: Math.min(1, relevance),
-          reasoning: `User preferences match query concepts: ${matchedConcepts.join("; ")}`,
-          source: "user_preferences",
-          timestamp: prefs.learnedAt
-        });
-      }
-    }
-    if (params.appId) {
-      const project = await this.memoryManager.getProjectContext(params.appId);
-      if (project) {
-        let relevance = 0.3;
-        const projectText = `${project.projectName ?? ""} ${project.description ?? ""} ${project.existingEntities.join(" ")}`.toLowerCase();
-        const queryTerms = params.query.toLowerCase().split(/\s+/);
-        const termMatches = queryTerms.filter((term) => projectText.includes(term)).length;
-        relevance += termMatches * 0.15;
-        if (relevance > 0.4) {
-          results.push({
-            type: "project",
-            data: project,
-            relevance: Math.min(1, relevance),
-            reasoning: `Project context contains ${termMatches} matching terms`,
-            source: "project_context",
-            timestamp: project.lastUpdatedAt
-          });
-        }
-      }
-    }
-    const sessions = await this.memoryManager.getUserGenerationHistory(params.userId, limit);
-    for (const session of sessions) {
-      const sessionText = `${session.prompt} ${session.entities.join(" ")}`.toLowerCase();
-      let relevance = 0.3;
-      if (concepts.entities) {
-        const entityMatches = session.entities.filter(
-          (e) => concepts.entities?.some((ce) => e.toLowerCase().includes(ce.toLowerCase()))
-        );
-        relevance += entityMatches.length * 0.15;
-      }
-      if (concepts.patterns) {
-        const patternMatches = session.patterns.filter(
-          (p) => concepts.patterns?.some((cp) => p.toLowerCase().includes(cp.toLowerCase()))
-        );
-        relevance += patternMatches.length * 0.1;
-      }
-      const queryTerms = params.query.toLowerCase().split(/\s+/);
-      const termMatches = queryTerms.filter((term) => sessionText.includes(term)).length;
-      relevance += termMatches * 0.05;
-      if (relevance > 0.4) {
-        results.push({
-          type: "session",
-          data: session,
-          relevance: Math.min(1, relevance),
-          reasoning: `Session contains relevant entities, patterns, or keywords`,
-          source: "generation_history",
-          timestamp: session.createdAt
-        });
-      }
-    }
-    return results;
-  }
-  /**
-   * Pattern search - "Show me all list views I've built"
-   * Searches for specific patterns and effects
-   */
-  async patternSearch(params, _depth, limit) {
-    const results = [];
-    const patternTerms = ["list", "form", "detail", "card", "table", "chart", "map", "calendar"];
-    const matchedTerms = patternTerms.filter(
-      (term) => params.query.toLowerCase().includes(term)
-    );
-    const patterns = await this.memoryManager.getUserPatterns(params.userId);
-    for (const pattern of patterns) {
-      let relevance = 0.3;
-      let reasoning = `Pattern usage: ${pattern.usageCount} times`;
-      if (matchedTerms.some((term) => pattern.patternId.toLowerCase().includes(term))) {
-        relevance += 0.3;
-        reasoning += ", matches query pattern type";
-      }
-      const successRate = pattern.usageCount > 0 ? pattern.successCount / pattern.usageCount : 0;
-      relevance += successRate * 0.2;
-      if (relevance > 0.4) {
-        results.push({
-          type: "pattern",
-          data: pattern,
-          relevance: Math.min(1, relevance),
-          reasoning: `${reasoning}, ${Math.round(successRate * 100)}% success rate`,
-          source: "pattern_affinity",
-          timestamp: pattern.lastUsedAt
-        });
-      }
-    }
-    const sessions = await this.memoryManager.getUserGenerationHistory(params.userId, limit);
-    for (const session of sessions) {
-      const matchingPatterns = session.patterns.filter(
-        (p) => matchedTerms.some((term) => p.toLowerCase().includes(term))
-      );
-      if (matchingPatterns.length > 0) {
-        results.push({
-          type: "session",
-          data: session,
-          relevance: 0.5 + matchingPatterns.length * 0.1,
-          reasoning: `Session uses patterns: ${matchingPatterns.join(", ")}`,
-          source: "generation_history",
-          timestamp: session.createdAt
-        });
-      }
-    }
-    return results;
-  }
-  /**
-   * Hybrid search - combines all strategies
-   */
-  async hybridSearch(params, depth, limit) {
-    const [temporal, semantic, pattern] = await Promise.all([
-      this.temporalSearch(params, depth, Math.ceil(limit / 2)),
-      this.semanticSearch(params, depth, Math.ceil(limit / 2)),
-      this.patternSearch(params, depth, Math.ceil(limit / 2))
-    ]);
-    const seen = /* @__PURE__ */ new Set();
-    const combined = [];
-    for (const result of [...temporal, ...semantic, ...pattern]) {
-      const key = `${result.type}-${JSON.stringify(result.data)}`;
-      if (!seen.has(key)) {
-        seen.add(key);
-        combined.push(result);
-      }
-    }
-    return combined;
-  }
-  // ============================================================================
-  // Helpers
-  // ============================================================================
-  /**
-   * Extract semantic concepts from query
-   */
-  extractConcepts(query) {
-    const lower = query.toLowerCase();
-    return {
-      naming: /naming|case|pascal|camel|snake/i.test(lower),
-      validation: /validat|schema|required|optional/i.test(lower),
-      patterns: ["entity", "list", "form", "detail", "card"].filter((p) => lower.includes(p)),
-      entities: this.extractEntityNames(lower),
-      actions: ["create", "update", "delete", "list", "view"].filter((a) => lower.includes(a))
-    };
-  }
-  /**
-   * Extract potential entity names from query
-   */
-  extractEntityNames(query) {
-    const words = query.split(/\s+/);
-    const entities = [];
-    for (const word of words) {
-      const clean = word.replace(/[^a-zA-Z]/g, "");
-      if (clean.length > 2 && clean[0] === clean[0].toUpperCase()) {
-        entities.push(clean);
-      }
-    }
-    return entities;
-  }
-  /**
-   * Generate insights from search results
-   */
-  generateInsights(results, query) {
-    const summary = `Found ${results.length} relevant memory items for "${query}"`;
-    const patternResults = results.filter((r) => r.type === "pattern");
-    const patterns = patternResults.length > 0 ? patternResults.slice(0, 3).map((r) => r.data.patternId) : ["No dominant patterns identified"];
-    const sessions = results.filter((r) => r.type === "session");
-    const trends = [];
-    if (sessions.length > 0) {
-      const timestamps = sessions.filter((s) => s.timestamp).map((s) => s.timestamp.getTime()).sort((a, b) => b - a);
-      if (timestamps.length >= 2) {
-        const avgGap = (timestamps[0] - timestamps[timestamps.length - 1]) / (timestamps.length - 1);
-        const daysGap = avgGap / (1e3 * 60 * 60 * 24);
-        if (daysGap < 7) {
-          trends.push("High activity - multiple sessions per week");
-        } else if (daysGap > 30) {
-          trends.push("Sporadic usage - sessions spread out over time");
-        }
-      }
-    }
-    const suggestions = [];
-    if (patterns.length > 0 && !patterns[0].includes("No dominant")) {
-      suggestions.push(`Consider reusing pattern: ${patterns[0]}`);
-    }
-    const projectResults = results.filter((r) => r.type === "project");
-    if (projectResults.length > 0) {
-      suggestions.push("Review existing project conventions for consistency");
-    }
-    const interruptResults = results.filter((r) => r.type === "interrupt");
-    if (interruptResults.length > 3) {
-      suggestions.push("High interrupt frequency - consider adjusting auto-approval settings");
-    }
-    if (suggestions.length === 0) {
-      suggestions.push("No specific suggestions based on current memory");
-    }
-    return { summary, patterns, trends, suggestions };
-  }
-};
-function createAgenticSearchEngine(memoryManager) {
-  return new AgenticSearchEngine(memoryManager);
-}
-var PreferenceLearner = class {
-  constructor(options) {
-    this.llmClient = options.llmClient ?? createRequirementsClient();
-    this.memoryManager = options.memoryManager;
-    this.confidenceThreshold = options.confidenceThreshold ?? 0.7;
-  }
-  /**
-   * Analyze a session and infer user preferences
-   */
-  async analyzeSession(session) {
-    const prompt = this.buildAnalysisPrompt(session);
-    const content = await this.llmClient.call({
-      systemPrompt: "You analyze generation sessions and infer user preferences. Respond with JSON.",
-      userPrompt: prompt
-    });
-    return this.parseAnalysisResponse(content);
-  }
-  /**
-   * Learn from a session and update preferences if confidence is high
-   */
-  async learnFromSession(session) {
-    let preferences = await this.memoryManager.getUserPreferences(session.userId);
-    if (!preferences) {
-      preferences = {
-        id: session.userId,
-        userId: session.userId,
-        namingConvention: "PascalCase",
-        validationStyle: "strict",
-        preferredPatterns: [],
-        commonEntities: [],
-        commonTraits: [],
-        learnedAt: /* @__PURE__ */ new Date(),
-        confidence: 0.5
-      };
-    }
-    const analysis = await this.analyzeSession(session);
-    let updated = false;
-    for (const inference of analysis.inferences) {
-      if (inference.confidence >= this.confidenceThreshold) {
-        switch (inference.field) {
-          case "namingConvention":
-            if (this.isValidNamingConvention(inference.value)) {
-              preferences.namingConvention = inference.value;
-              updated = true;
-            }
-            break;
-          case "validationStyle":
-            if (this.isValidValidationStyle(inference.value)) {
-              preferences.validationStyle = inference.value;
-              updated = true;
-            }
-            break;
-          case "preferredPatterns":
-            if (Array.isArray(inference.value)) {
-              preferences.preferredPatterns = [
-                .../* @__PURE__ */ new Set([...preferences.preferredPatterns, ...inference.value])
-              ].slice(0, 10);
-              updated = true;
-            }
-            break;
-          case "commonEntities":
-            if (Array.isArray(inference.value)) {
-              preferences.commonEntities = [
-                .../* @__PURE__ */ new Set([...preferences.commonEntities, ...inference.value])
-              ].slice(0, 20);
-              updated = true;
-            }
-            break;
-        }
-      }
-    }
-    if (updated) {
-      preferences.confidence = Math.min(1, preferences.confidence + 0.05);
-      await this.memoryManager.updateUserPreferences(session.userId, preferences);
-    }
-    return updated ? preferences : null;
-  }
-  /**
-   * Batch learn from multiple sessions
-   */
-  async batchLearn(sessions) {
-    if (sessions.length === 0) return null;
-    const userId = sessions[0].userId;
-    let preferences = await this.memoryManager.getUserPreferences(userId);
-    if (!preferences) {
-      preferences = {
-        id: userId,
-        userId,
-        namingConvention: "PascalCase",
-        validationStyle: "strict",
-        preferredPatterns: [],
-        commonEntities: [],
-        commonTraits: [],
-        learnedAt: /* @__PURE__ */ new Date(),
-        confidence: 0.5
-      };
-    }
-    const allPatterns = /* @__PURE__ */ new Set();
-    const allEntities = /* @__PURE__ */ new Set();
-    for (const session of sessions) {
-      session.patterns.forEach((p) => allPatterns.add(p));
-      session.entities.forEach((e) => allEntities.add(e));
-    }
-    preferences.preferredPatterns = [...allPatterns].slice(0, 10);
-    preferences.commonEntities = [...allEntities].slice(0, 20);
-    preferences.confidence = Math.min(1, 0.5 + sessions.length * 0.05);
-    const aggregatePrompt = this.buildAggregatePrompt(sessions);
-    const content = await this.llmClient.call({
-      systemPrompt: "You analyze generation sessions and infer user preferences. Respond with JSON.",
-      userPrompt: aggregatePrompt
-    });
-    const analysis = this.parseAnalysisResponse(content);
-    for (const inference of analysis.inferences) {
-      if (inference.confidence >= this.confidenceThreshold) {
-        if (inference.field === "namingConvention" && this.isValidNamingConvention(inference.value)) {
-          preferences.namingConvention = inference.value;
-        }
-        if (inference.field === "validationStyle" && this.isValidValidationStyle(inference.value)) {
-          preferences.validationStyle = inference.value;
-        }
-      }
-    }
-    await this.memoryManager.updateUserPreferences(userId, preferences);
-    return preferences;
-  }
-  // ==========================================================================
-  // Prompt Building
-  // ==========================================================================
-  buildAnalysisPrompt(session) {
-    return `Analyze this generation session and infer the user's preferences.
-
-Session Details:
-- Prompt: "${session.prompt}"
-- Generated Entities: ${session.entities.join(", ")}
-- Used Patterns: ${session.patterns.join(", ")}
-- Skill: ${session.skill}
-
-Schema Excerpt:
-${JSON.stringify(session.generatedSchema, null, 2).slice(0, 2e3)}
-
-Analyze and infer:
-1. Naming convention preference (PascalCase, camelCase, snake_case)
-2. Validation style (strict, minimal, none)
-3. Preferred UI patterns
-4. Common entity types
-
-Respond in JSON format:
-{
-  "inferences": [
-    {
-      "field": "namingConvention",
-      "value": "PascalCase",
-      "confidence": 0.85,
-      "reasoning": "User consistently uses PascalCase for entity names"
-    }
-  ],
-  "isHighConfidence": true
-}`;
-  }
-  buildAggregatePrompt(sessions) {
-    const summaries = sessions.slice(0, 10).map((s) => ({
-      prompt: s.prompt.slice(0, 100),
-      entities: s.entities,
-      patterns: s.patterns
-    }));
-    return `Analyze these ${sessions.length} generation sessions and infer the user's aggregate preferences.
-
-Session Summaries:
-${JSON.stringify(summaries, null, 2)}
-
-Infer the user's overall:
-1. Naming convention preference (PascalCase, camelCase, snake_case)
-2. Validation style (strict, minimal, none)
-
-Respond in JSON format:
-{
-  "inferences": [
-    {
-      "field": "namingConvention",
-      "value": "PascalCase",
-      "confidence": 0.9,
-      "reasoning": "Used PascalCase in 8 out of 10 sessions"
-    }
-  ],
-  "isHighConfidence": true
-}`;
-  }
-  // ==========================================================================
-  // Response Parsing
-  // ==========================================================================
-  parseAnalysisResponse(content) {
-    try {
-      const jsonMatch = content.match(/\{[\s\S]*\}/);
-      if (!jsonMatch) {
-        return { inferences: [], isHighConfidence: false };
-      }
-      const parsed = JSON.parse(jsonMatch[0]);
-      if (Array.isArray(parsed.inferences)) {
-        return {
-          inferences: parsed.inferences.filter(
-            (inf) => inf.field && inf.value !== void 0 && typeof inf.confidence === "number"
-          ),
-          isHighConfidence: parsed.isHighConfidence ?? false
-        };
-      }
-      return { inferences: [], isHighConfidence: false };
-    } catch {
-      return { inferences: [], isHighConfidence: false };
-    }
-  }
-  // ==========================================================================
-  // Validation Helpers
-  // ==========================================================================
-  isValidNamingConvention(value) {
-    return typeof value === "string" && ["PascalCase", "camelCase", "snake_case"].includes(value);
-  }
-  isValidValidationStyle(value) {
-    return typeof value === "string" && ["strict", "minimal", "none"].includes(value);
-  }
-};
-function createPreferenceLearner(options) {
-  return new PreferenceLearner(options);
-}
-
-// src/agent/memory-integration.ts
-var MemoryIntegrationEngine = class {
-  constructor(options) {
-    this.metrics = { queries: 0, hits: 0, totalLatencyMs: 0 };
-    this.options = {
-      enableEpisodic: true,
-      enableSemantic: true,
-      enableProcedural: true,
-      ...options
-    };
-    this.searchEngine = createAgenticSearchEngine(options.memoryManager);
-    this.preferenceLearner = createPreferenceLearner({
-      memoryManager: options.memoryManager
-    });
-    if (!options.memoryManager) {
-      throw new Error("MemoryManager is required for MemoryIntegrationEngine");
-    }
-  }
-  // ============================================================================
-  // Episodic Memory: Past Sessions
-  // ============================================================================
-  /**
-   * Retrieve similar past generation sessions
-   */
-  async retrieveSimilarSessions(request, limit = 5) {
-    if (!this.options.enableEpisodic) return [];
-    const start = Date.now();
-    try {
-      const results = await this.searchEngine.search({
-        userId: this.options.userId,
-        query: request,
-        strategy: "semantic",
-        limit
-      });
-      const sessions = results.results.filter((r) => r.type === "session").map((r) => {
-        const session = r.data;
-        return {
-          sessionId: session.id ?? "unknown",
-          request: session.request ?? "",
-          schema: session.schemaSnapshot ? JSON.parse(session.schemaSnapshot) : null,
-          success: session.success ?? false,
-          similarity: r.relevance
-        };
-      });
-      this.recordMetrics(true, Date.now() - start);
-      return sessions;
-    } catch (error) {
-      this.recordMetrics(false, Date.now() - start);
-      console.warn("[Memory] Failed to retrieve similar sessions:", error);
-      return [];
-    }
-  }
-  /**
-   * Record a new generation session to episodic memory
-   */
-  async recordSession(request, result) {
-    if (!this.options.enableEpisodic) return;
-    await this.options.memoryManager.recordGeneration(
-      this.options.userId,
-      {
-        threadId: `thread_${Date.now()}`,
-        prompt: request,
-        skill: "kflow-orbitals",
-        generatedSchema: result.schema,
-        entities: [],
-        patterns: [],
-        success: result.success,
-        validationResult: result.validationResult
-      }
-    );
-  }
-  // ============================================================================
-  // Semantic Memory: Patterns & Preferences
-  // ============================================================================
-  /**
-   * Get learned user preferences
-   */
-  async getUserPreferences() {
-    if (!this.options.enableSemantic) {
-      return {
-        namingConvention: "PascalCase",
-        preferredPatterns: [],
-        commonEntities: []
-      };
-    }
-    try {
-      const prefs = await this.options.memoryManager.getUserPreferences(
-        this.options.userId
-      );
-      if (!prefs) {
-        return {
-          namingConvention: "PascalCase",
-          preferredPatterns: [],
-          commonEntities: []
-        };
-      }
-      return {
-        namingConvention: prefs.namingConvention ?? "PascalCase",
-        preferredPatterns: prefs.preferredPatterns ?? [],
-        commonEntities: prefs.commonEntities ?? []
-      };
-    } catch (error) {
-      console.warn("[Memory] Failed to get user preferences:", error);
-      return {
-        namingConvention: "PascalCase",
-        preferredPatterns: [],
-        commonEntities: []
-      };
-    }
-  }
-  /**
-   * Learn from user feedback
-   */
-  async learnFromFeedback(feedback) {
-    if (!this.options.enableSemantic) return;
-    await this.options.memoryManager.updatePatternAffinity(
-      this.options.userId,
-      feedback.pattern,
-      feedback.outcome,
-      { entityType: feedback.entityType }
-    );
-  }
-  /**
-   * Infer preferences from usage patterns
-   */
-  async inferPreferences() {
-    if (!this.options.enableSemantic) {
-      return { confidence: 0 };
-    }
-    try {
-      const sessions = await this.options.memoryManager.getUserGenerationHistory(
-        this.options.userId,
-        5
-      );
-      if (sessions.length === 0) {
-        return { confidence: 0 };
-      }
-      const analysis = await this.preferenceLearner.analyzeSession(sessions[0]);
-      const namingInference = analysis.inferences.find((i) => i.field === "namingConvention");
-      const validationInference = analysis.inferences.find((i) => i.field === "validationStyle");
-      return {
-        namingConvention: namingInference?.value,
-        validationStyle: validationInference?.value,
-        confidence: analysis.isHighConfidence ? 0.8 : 0.5
-      };
-    } catch (error) {
-      console.warn("[Memory] Failed to infer preferences:", error);
-      return { confidence: 0 };
-    }
-  }
-  // ============================================================================
-  // Procedural Memory: Domain Workflows
-  // ============================================================================
-  /**
-   * Get project context (domain-specific knowledge)
-   */
-  async getProjectContext() {
-    if (!this.options.enableProcedural || !this.options.projectId) {
-      return void 0;
-    }
-    try {
-      const context = await this.options.memoryManager.getProjectContext(
-        this.options.projectId
-      );
-      if (!context) return void 0;
-      return {
-        domain: context.domain ?? "business",
-        existingEntities: context.existingEntities ?? [],
-        conventions: context.conventions ?? []
-      };
-    } catch (error) {
-      console.warn("[Memory] Failed to get project context:", error);
-      return void 0;
-    }
-  }
-  /**
-   * Update project context with new conventions
-   */
-  async updateProjectContext(update) {
-    if (!this.options.enableProcedural || !this.options.projectId) return;
-    await this.options.memoryManager.updateProjectContext(
-      this.options.projectId,
-      {
-        userId: this.options.userId,
-        domain: update.domain,
-        conventions: update.conventions,
-        existingEntities: update.existingEntities
-      }
-    );
-  }
-  // ============================================================================
-  // Combined Memory Context
-  // ============================================================================
-  /**
-   * Build complete memory context for a generation request
-   */
-  async buildContext(request) {
-    const start = Date.now();
-    const [
-      userPreferences,
-      similarSessions,
-      projectContext,
-      inferredPrefs
-    ] = await Promise.all([
-      this.getUserPreferences(),
-      this.retrieveSimilarSessions(request, 3),
-      this.getProjectContext(),
-      this.inferPreferences()
-    ]);
-    if (inferredPrefs.confidence > 0.7) {
-      if (inferredPrefs.namingConvention) {
-        userPreferences.namingConvention = inferredPrefs.namingConvention;
-      }
-    }
-    const latencyMs = Date.now() - start;
-    console.log(`[Memory] Context built in ${latencyMs}ms:`, {
-      similarSessions: similarSessions.length,
-      hasProjectContext: !!projectContext,
-      userPreferences: Object.keys(userPreferences).length
-    });
-    return {
-      userPreferences,
-      similarSessions,
-      projectContext,
-      learnedPatterns: []
-      // Would be populated from pattern affinity
-    };
-  }
-  // ============================================================================
-  // Metrics
-  // ============================================================================
-  /**
-   * Get memory quality metrics
-   */
-  getMetrics() {
-    const totalQueries = this.metrics.queries;
-    const hits = this.metrics.hits;
-    return {
-      recallAccuracy: totalQueries > 0 ? hits / totalQueries : 0,
-      precision: 0.85,
-      // Simplified metric
-      latencyMs: totalQueries > 0 ? this.metrics.totalLatencyMs / totalQueries : 0,
-      cacheHitRate: 0.3
-      // Simplified metric
-    };
-  }
-  recordMetrics(hit, latencyMs) {
-    this.metrics.queries++;
-    if (hit) this.metrics.hits++;
-    this.metrics.totalLatencyMs += latencyMs;
-  }
-};
-function createMemoryIntegration(options) {
-  return new MemoryIntegrationEngine(options);
-}
-
-// src/tools/composition.ts
-var WorkflowEngine = class {
-  constructor(executor) {
-    this.workflows = /* @__PURE__ */ new Map();
-    this.executor = executor;
-  }
-  /**
-   * Register a workflow definition
-   */
-  registerWorkflow(definition) {
-    this.workflows.set(definition.name, definition);
-  }
-  /**
-   * Execute a workflow by name
-   */
-  async executeWorkflow(workflowName, inputs) {
-    const definition = this.workflows.get(workflowName);
-    if (!definition) {
-      throw new Error(`Workflow not found: ${workflowName}`);
-    }
-    return this.runWorkflow(definition, inputs);
-  }
-  /**
-   * Execute a workflow definition directly
-   */
-  async runWorkflow(definition, inputs) {
-    const workflowId = `wf_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
-    const startTime = Date.now();
-    const context = {
-      workflowId,
-      inputs,
-      outputs: {},
-      stepResults: /* @__PURE__ */ new Map(),
-      metadata: {
-        startTime,
-        stepsCompleted: 0,
-        stepsFailed: 0
-      }
-    };
-    const steps = definition.steps.map((s) => ({ ...s, status: "pending" }));
-    try {
-      const executionOrder = this.resolveDependencies(steps);
-      for (const stepId of executionOrder) {
-        const step = steps.find((s) => s.id === stepId);
-        if (step.condition && !step.condition(context)) {
-          step.status = "skipped";
-          continue;
-        }
-        await this.executeStep(step, context, definition);
-        if (step.status === "error" && definition.onError === "stop") {
-          break;
-        }
-      }
-      const durationMs = Date.now() - startTime;
-      return {
-        success: context.metadata.stepsFailed === 0,
-        workflowId,
-        context,
-        steps,
-        durationMs
-      };
-    } catch (error) {
-      return {
-        success: false,
-        workflowId,
-        context,
-        steps,
-        durationMs: Date.now() - startTime,
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  /**
-   * Execute independent steps in parallel
-   */
-  async executeParallel(steps, context) {
-    const promises = steps.map(async (step) => {
-      const startTime = Date.now();
-      try {
-        const input = typeof step.input === "function" ? step.input(context) : step.input;
-        const output = await this.executor.execute(step.tool, input);
-        return {
-          stepId: step.id,
-          success: true,
-          output,
-          durationMs: Date.now() - startTime
-        };
-      } catch (error) {
-        return {
-          stepId: step.id,
-          success: false,
-          error: error instanceof Error ? error.message : String(error),
-          durationMs: Date.now() - startTime
-        };
-      }
-    });
-    return Promise.all(promises);
-  }
-  /**
-   * Create a workflow builder for fluent API
-   */
-  createWorkflow(name, description) {
-    return new WorkflowBuilder(this, name, description);
-  }
-  // ============================================================================
-  // Private Helpers
-  // ============================================================================
-  async executeStep(step, context, definition) {
-    step.status = "running";
-    step.startTime = Date.now();
-    const maxRetries = definition.maxRetries ?? 0;
-    let attempt = 0;
-    while (attempt <= maxRetries) {
-      try {
-        const input = typeof step.input === "function" ? step.input(context) : step.input;
-        const output = await this.executor.execute(step.tool, input);
-        step.output = output;
-        step.status = "success";
-        step.endTime = Date.now();
-        context.stepResults.set(step.id, { success: true, output });
-        context.outputs[step.id] = output;
-        context.metadata.stepsCompleted++;
-        return;
-      } catch (error) {
-        attempt++;
-        if (attempt > maxRetries) {
-          step.error = error instanceof Error ? error.message : String(error);
-          step.status = "error";
-          step.endTime = Date.now();
-          context.stepResults.set(step.id, { success: false, error: step.error });
-          context.metadata.stepsFailed++;
-          return;
-        }
-        await new Promise((r) => setTimeout(r, 1e3 * attempt));
-      }
-    }
-  }
-  resolveDependencies(steps) {
-    const visited = /* @__PURE__ */ new Set();
-    const result = [];
-    const visit = (stepId) => {
-      if (visited.has(stepId)) return;
-      visited.add(stepId);
-      const step = steps.find((s) => s.id === stepId);
-      if (!step) return;
-      if (step.dependsOn) {
-        for (const dep of step.dependsOn) {
-          visit(dep);
-        }
-      }
-      result.push(stepId);
-    };
-    for (const step of steps) {
-      visit(step.id);
-    }
-    return result;
-  }
-};
-var WorkflowBuilder = class {
-  constructor(engine, name, description) {
-    this.engine = engine;
-    this.definition = {
-      name,
-      description,
-      inputs: {},
-      steps: [],
-      onError: "stop",
-      maxRetries: 0
-    };
-  }
-  input(name, type, required = true, defaultValue) {
-    this.definition.inputs[name] = { type, required, default: defaultValue };
-    return this;
-  }
-  step(id, tool14, input, options = {}) {
-    this.definition.steps.push({
-      id,
-      name: id,
-      tool: tool14,
-      input,
-      dependsOn: options.dependsOn,
-      condition: options.condition,
-      status: "pending"
-    });
-    return this;
-  }
-  parallel(steps) {
-    for (const step of steps) {
-      this.definition.steps.push({
-        id: step.id,
-        name: step.id,
-        tool: step.tool,
-        input: step.input,
-        status: "pending"
-      });
-    }
-    return this;
-  }
-  onError(policy) {
-    this.definition.onError = policy;
-    return this;
-  }
-  retry(maxRetries) {
-    this.definition.maxRetries = maxRetries;
-    return this;
-  }
-  build() {
-    return this.definition;
-  }
-  async execute(inputs) {
-    return this.engine.runWorkflow(this.definition, inputs);
-  }
-};
-
-// src/agent/react-workflow-integration.ts
-var ReActWorkflowExecutor = class {
-  constructor(options) {
-    this.telemetry = [];
-    this.options = {
-      ...options,
-      enableTelemetry: options.enableTelemetry ?? true,
-      maxExecutionMs: options.maxExecutionMs ?? 6e4
-    };
-    this.workflowEngine = new WorkflowEngine(options.toolExecutor);
-  }
-  /**
-   * Execute a workflow action within a ReAct session
-   * This replaces simple tool calls with full workflows
-   */
-  async executeWorkflowAction(session, action, context) {
-    const startTime = Date.now();
-    const errors = [];
-    let totalRetries = 0;
-    this.workflowEngine.registerWorkflow({
-      name: action.name,
-      description: `Workflow for ${action.name}`,
-      inputs: Object.keys(context).reduce((acc, key) => {
-        acc[key] = { type: "unknown", required: false };
-        return acc;
-      }, {}),
-      steps: action.workflow.steps.map((step) => ({
-        id: step.id,
-        name: step.id,
-        tool: step.tool,
-        input: step.input,
-        dependsOn: step.dependsOn,
-        status: "pending"
-      })),
-      onError: "retry",
-      maxRetries: 3
-    });
-    try {
-      const result = await this.executeWithTimeout(
-        action.name,
-        context,
-        this.options.maxExecutionMs
-      );
-      const stepsExecuted = result.steps.filter(
-        (s) => s.status === "success" || s.status === "error"
-      ).length;
-      totalRetries = this.telemetry.filter(
-        (t) => t.sessionId === session.sessionId && t.actionName === action.name
-      ).reduce((sum, t) => sum + t.retryCount, 0);
-      if (result.success && this.options.memoryManager) {
-        await this.storeWorkflowResult(session, action.name, result);
-      }
-      return {
-        success: result.success,
-        output: result.context.outputs,
-        stepsExecuted,
-        durationMs: result.durationMs || Date.now() - startTime,
-        retries: totalRetries,
-        errors: result.error ? [result.error] : errors
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      errors.push(errorMessage);
-      return {
-        success: false,
-        output: null,
-        stepsExecuted: 0,
-        durationMs: Date.now() - startTime,
-        retries: totalRetries,
-        errors
-      };
-    }
-  }
-  /**
-   * Execute workflow with timeout
-   */
-  async executeWithTimeout(workflowName, inputs, timeoutMs) {
-    const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(() => reject(new Error("Workflow execution timeout")), timeoutMs);
-    });
-    const executionPromise = this.workflowEngine.executeWorkflow(workflowName, inputs);
-    return Promise.race([executionPromise, timeoutPromise]);
-  }
-  /**
-   * Store workflow result in memory for learning
-   */
-  async storeWorkflowResult(session, actionName, result) {
-    if (!this.options.memoryManager) return;
-    await this.options.memoryManager.recordGeneration(
-      session.sessionId,
-      // Use session ID as user ID proxy
-      {
-        threadId: session.sessionId,
-        prompt: `Workflow: ${actionName}`,
-        skill: "react-workflow",
-        generatedSchema: result.context.outputs,
-        entities: [],
-        patterns: [],
-        success: result.success
-      }
-    );
-  }
-  /**
-   * Record telemetry for a workflow step
-   */
-  recordTelemetry(event) {
-    if (!this.options.enableTelemetry) return;
-    this.telemetry.push(event);
-    if (this.telemetry.length > 1e3) {
-      this.telemetry = this.telemetry.slice(-500);
-    }
-  }
-  /**
-   * Get telemetry for analysis
-   */
-  getTelemetry(sessionId) {
-    if (sessionId) {
-      return this.telemetry.filter((t) => t.sessionId === sessionId);
-    }
-    return [...this.telemetry];
-  }
-  /**
-   * Get workflow performance metrics
-   */
-  getMetrics() {
-    const events = this.telemetry;
-    const uniqueWorkflows = new Set(events.map((e) => e.actionName)).size;
-    const successCount = events.filter((e) => e.success).length;
-    const successRate = events.length > 0 ? successCount / events.length : 0;
-    const avgDuration = events.length > 0 ? events.reduce((sum, e) => sum + e.durationMs, 0) / events.length : 0;
-    const avgRetries = events.length > 0 ? events.reduce((sum, e) => sum + e.retryCount, 0) / events.length : 0;
-    const toolUsage = events.reduce((acc, e) => {
-      acc[e.tool] = (acc[e.tool] || 0) + 1;
-      return acc;
-    }, {});
-    return {
-      totalWorkflows: uniqueWorkflows,
-      successRate,
-      avgDurationMs: avgDuration,
-      avgRetries,
-      toolUsage
-    };
-  }
-};
-var ReActWorkflowEngine = class {
-  constructor(options) {
-    this.reactEngine = new ReActEngine(options.reactOptions);
-    this.workflowExecutor = new ReActWorkflowExecutor(options.workflowOptions);
-  }
-  /**
-   * Start a new session
-   */
-  startSession(userRequest) {
-    return this.reactEngine.startSession(userRequest);
-  }
-  /**
-   * Execute REASON step
-   */
-  async reason(sessionId, context) {
-    return this.reactEngine.reason(sessionId, context);
-  }
-  /**
-   * Execute ACT step with workflow support
-   * 
-   * This is the key integration point - replaces simple tool calls
-   * with full workflows that have retry, parallel execution, etc.
-   */
-  async act(sessionId, action, actionInput, workflowAction) {
-    const session = this.reactEngine.getSession(sessionId);
-    if (!workflowAction) {
-      const step2 = await this.reactEngine.act(sessionId, action, actionInput);
-      return { step: step2 };
-    }
-    const workflowResult = await this.workflowExecutor.executeWorkflowAction(
-      session,
-      workflowAction,
-      actionInput
-    );
-    const step = {
-      stepNumber: ++session.currentStep,
-      state: "ACTING",
-      thought: `Executing workflow: ${workflowAction.name}`,
-      action: workflowAction.name,
-      actionInput,
-      observation: workflowResult.success ? `Workflow completed successfully (${workflowResult.stepsExecuted} steps)` : `Workflow failed: ${workflowResult.errors.join(", ")}`,
-      timestamp: /* @__PURE__ */ new Date()
-    };
-    session.steps.push(step);
-    session.state = workflowResult.success ? "OBSERVING" : "REFLECTING";
-    return { step, workflowResult };
-  }
-  /**
-   * Execute OBSERVE step
-   */
-  async observe(sessionId, observation) {
-    return this.reactEngine.observe(sessionId, observation);
-  }
-  /**
-   * Execute REFLECT step
-   */
-  async reflect(sessionId, result) {
-    return this.reactEngine.reflect(sessionId, result);
-  }
-  /**
-   * Execute CORRECT step
-   */
-  async correct(sessionId, correctionAction, correctionInput) {
-    return this.reactEngine.correct(sessionId, correctionAction, correctionInput);
-  }
-  /**
-   * Get session
-   */
-  getSession(sessionId) {
-    return this.reactEngine.getSession(sessionId);
-  }
-  /**
-   * Get workflow metrics
-   */
-  getWorkflowMetrics() {
-    return this.workflowExecutor.getMetrics();
-  }
-};
-function createReActWorkflowExecutor(options) {
-  return new ReActWorkflowExecutor(options);
-}
-function createReActWorkflowEngine(options) {
-  return new ReActWorkflowEngine(options);
-}
-
-// src/agent/hitl-workflow-integration.ts
-var HITLWorkflowEngine = class {
-  constructor(options) {
-    this.gateHistory = /* @__PURE__ */ new Map();
-    this.options = {
-      ...options,
-      defaultTimeoutMs: options.defaultTimeoutMs ?? 3e5,
-      // 5 minutes
-      enableAutoApprove: options.enableAutoApprove ?? true
-    };
-    this.hitlManager = options.hitlManager;
-    this.workflowEngine = new WorkflowEngine(options.toolExecutor);
-  }
-  /**
-   * Execute a workflow with human gates
-   */
-  async executeWorkflow(sessionId, workflow, initialContext) {
-    const startTime = Date.now();
-    const gatesPassed = [];
-    const branchesTaken = [];
-    let wasInterrupted = false;
-    try {
-      let context = await this.executeInitialSteps(
-        workflow.initialSteps,
-        initialContext
-      );
-      for (const gate of workflow.gates) {
-        if (gate.condition && !gate.condition(context)) {
-          continue;
-        }
-        if (this.options.enableAutoApprove && gate.autoApprove) {
-          if (gate.autoApprove.condition(context)) {
-            const autoResult = {
-              gateId: gate.id,
-              approved: true,
-              response: { autoApproved: true, reason: gate.autoApprove.reason },
-              respondedAt: Date.now(),
-              autoApproved: true
-            };
-            gatesPassed.push(autoResult);
-            continue;
-          }
-        }
-        wasInterrupted = true;
-        const gateResult = await this.executeHumanGate(sessionId, gate);
-        gatesPassed.push(gateResult);
-        if (!gateResult.approved) {
-          return {
-            success: false,
-            output: null,
-            gatesPassed,
-            branchesTaken,
-            durationMs: Date.now() - startTime,
-            wasInterrupted
-          };
-        }
-        context = {
-          ...context,
-          [`gate_${gate.id}`]: gateResult.response
-        };
-      }
-      let branchExecuted = false;
-      for (const branch of workflow.branches) {
-        if (branch.condition(context)) {
-          branchesTaken.push(branch.id);
-          if (branch.gate) {
-            wasInterrupted = true;
-            const branchGateResult = await this.executeHumanGate(
-              sessionId,
-              branch.gate
-            );
-            gatesPassed.push(branchGateResult);
-            if (!branchGateResult.approved) {
-              continue;
-            }
-          }
-          context = await this.executeBranchSteps(branch.steps, context);
-          branchExecuted = true;
-          break;
-        }
-      }
-      if (!branchExecuted && workflow.fallbackBranch) {
-        branchesTaken.push(workflow.fallbackBranch.id);
-        context = await this.executeBranchSteps(
-          workflow.fallbackBranch.steps,
-          context
-        );
-      }
-      this.gateHistory.set(sessionId, gatesPassed);
-      return {
-        success: true,
-        output: context,
-        gatesPassed,
-        branchesTaken,
-        durationMs: Date.now() - startTime,
-        wasInterrupted
-      };
-    } catch (error) {
-      return {
-        success: false,
-        output: error instanceof Error ? error.message : String(error),
-        gatesPassed,
-        branchesTaken,
-        durationMs: Date.now() - startTime,
-        wasInterrupted
-      };
-    }
-  }
-  /**
-   * Execute initial workflow steps
-   */
-  async executeInitialSteps(steps, context) {
-    let result = { ...context };
-    for (const step of steps) {
-      const output = await this.options.toolExecutor.execute(
-        step.tool,
-        this.interpolateInput(step.input, result)
-      );
-      result = { ...result, [step.tool]: output };
-    }
-    return result;
-  }
-  /**
-   * Execute a human gate
-   */
-  async executeHumanGate(sessionId, gate) {
-    const timeoutMs = gate.timeoutMs ?? this.options.defaultTimeoutMs;
-    switch (gate.type) {
-      case "approval":
-        return this.executeApprovalGate(sessionId, gate, timeoutMs);
-      case "edit":
-        return this.executeEditGate(sessionId, gate, timeoutMs);
-      case "select":
-        return this.executeSelectGate(sessionId, gate, timeoutMs);
-      case "custom":
-        return this.executeCustomGate(sessionId, gate, timeoutMs);
-      default:
-        throw new Error(`Unknown gate type: ${gate.type}`);
-    }
-  }
-  /**
-   * Execute approval gate
-   */
-  async executeApprovalGate(sessionId, gate, timeoutMs) {
-    const approved = await this.hitlManager.confirm(sessionId, gate.description, {
-      severity: "info",
-      timeoutMs,
-      context: {
-        checkpointId: `gate_${gate.id}`,
-        currentState: "awaiting_approval",
-        previousActions: []
-      }
-    });
-    return {
-      gateId: gate.id,
-      approved,
-      response: { approved },
-      respondedAt: Date.now(),
-      autoApproved: false
-    };
-  }
-  /**
-   * Execute edit gate
-   */
-  async executeEditGate(sessionId, gate, timeoutMs) {
-    const content = gate.payload?.content || "";
-    const edited = await this.hitlManager.edit(sessionId, content, {
-      format: gate.payload?.format || "text",
-      title: gate.title,
-      description: gate.description,
-      timeoutMs
-    });
-    return {
-      gateId: gate.id,
-      approved: true,
-      response: { edited, content: edited },
-      respondedAt: Date.now(),
-      autoApproved: false
-    };
-  }
-  /**
-   * Execute select gate
-   */
-  async executeSelectGate(sessionId, gate, timeoutMs) {
-    const options = gate.payload?.options || [];
-    const selected = await this.hitlManager.select(sessionId, options, {
-      multiple: gate.payload?.multiple || false,
-      timeoutMs
-    });
-    return {
-      gateId: gate.id,
-      approved: true,
-      response: { selected },
-      respondedAt: Date.now(),
-      autoApproved: false
-    };
-  }
-  /**
-   * Execute custom gate
-   */
-  async executeCustomGate(sessionId, gate, timeoutMs) {
-    const request = {
-      interruptId: `custom_${gate.id}_${Date.now()}`,
-      sessionId,
-      type: "text",
-      title: gate.title,
-      description: gate.description,
-      context: {
-        checkpointId: `gate_${gate.id}`,
-        currentState: "custom_gate",
-        previousActions: []
-      },
-      payload: gate.payload || {},
-      timeoutMs,
-      createdAt: /* @__PURE__ */ new Date()
-    };
-    const response = await this.waitForResponse(request);
-    return {
-      gateId: gate.id,
-      approved: true,
-      response,
-      respondedAt: Date.now(),
-      autoApproved: false
-    };
-  }
-  /**
-   * Execute branch steps
-   */
-  async executeBranchSteps(steps, context) {
-    return this.executeInitialSteps(steps, context);
-  }
-  /**
-   * Wait for interrupt response
-   */
-  async waitForResponse(request) {
-    return new Promise((resolve2) => {
-      setTimeout(() => {
-        resolve2({ timeout: true });
-      }, request.timeoutMs || 3e5);
-    });
-  }
-  /**
-   * Interpolate input with context
-   */
-  interpolateInput(input, context) {
-    const result = {};
-    for (const [key, value] of Object.entries(input)) {
-      if (typeof value === "string" && value.startsWith("{{") && value.endsWith("}}")) {
-        const path8 = value.slice(2, -2).trim();
-        result[key] = this.getValueFromPath(context, path8);
-      } else {
-        result[key] = value;
-      }
-    }
-    return result;
-  }
-  /**
-   * Get value from path
-   */
-  getValueFromPath(obj, path8) {
-    const parts = path8.split(".");
-    let current = obj;
-    for (const part of parts) {
-      if (current && typeof current === "object") {
-        current = current[part];
-      } else {
-        return void 0;
-      }
-    }
-    return current;
-  }
-  /**
-   * Get gate history for a session
-   */
-  getGateHistory(sessionId) {
-    return this.gateHistory.get(sessionId) || [];
-  }
-  /**
-   * Clear gate history
-   */
-  clearGateHistory(sessionId) {
-    if (sessionId) {
-      this.gateHistory.delete(sessionId);
-    } else {
-      this.gateHistory.clear();
-    }
-  }
-};
-function createSchemaGenerationHITLWorkflow(complexity) {
-  const needsReview = complexity === "complex";
-  return {
-    name: "schema-generation-with-review",
-    initialSteps: [
-      { tool: "analyzeRequirements", input: { text: "{{requirements}}" } },
-      { tool: "extractEntities", input: { from: "{{analyzeRequirements}}" } }
-    ],
-    gates: [
-      {
-        id: "complexity-check",
-        type: "approval",
-        title: "Complex Schema Detected",
-        description: `This appears to be a ${complexity} schema. Review before proceeding?`,
-        condition: () => needsReview,
-        autoApprove: {
-          condition: () => !needsReview,
-          reason: "Simple schema, auto-approved"
-        }
-      }
-    ],
-    branches: [
-      {
-        id: "generate-full",
-        condition: () => true,
-        steps: [
-          { tool: "generateOrbital", input: { entities: "{{extractEntities}}" } },
-          { tool: "validateSchema", input: { schema: "{{generateOrbital}}" } }
-        ],
-        gate: needsReview ? {
-          id: "schema-review",
-          type: "edit",
-          title: "Review Generated Schema",
-          description: "Please review and edit the generated schema if needed.",
-          payload: { format: "json" }
-        } : void 0
-      }
-    ]
-  };
-}
-function createMultiStageApprovalWorkflow(stages) {
-  return {
-    name: "multi-stage-approval",
-    initialSteps: [],
-    gates: stages.map((stage, index) => ({
-      id: `approval-${index}`,
-      type: "approval",
-      title: `${stage.name} Approval Required`,
-      description: `Waiting for approval from ${stage.approver}`
-    })),
-    branches: [
-      {
-        id: "approved",
-        condition: () => true,
-        steps: [{ tool: "finalize", input: {} }]
-      }
-    ]
-  };
-}
-function createHITLWorkflowEngine(options) {
-  return new HITLWorkflowEngine(options);
-}
-
 // src/agent/workflow-tool-wrapper.ts
 function createWorkflowToolWrapper(options = {}) {
   const {
@@ -7765,6 +5875,6 @@ function createEvalWorkflowWrapper(options = {}) {
   };
 }
 
-export { EVENT_BUDGETS, HITLWorkflowEngine, HITLv2Manager, MemoryIntegrationEngine, ReActEngine, ReActWorkflowEngine, ReActWorkflowExecutor, SessionManager, createEvalWorkflowWrapper, createHITLWorkflowEngine, createHITLv2Manager, createMemoryIntegration, createMultiStageApprovalWorkflow, createReActEngine, createReActWorkflowEngine, createReActWorkflowExecutor, createSchemaGenerationHITLWorkflow, createSkillAgent, createWorkflowToolWrapper, getBudgetWarningMessage, getEventBudget, getInterruptConfig, resumeSkillAgent };
+export { EVENT_BUDGETS, SessionManager, createEvalWorkflowWrapper, createSkillAgent, createWorkflowToolWrapper, getBudgetWarningMessage, getEventBudget, getInterruptConfig, resumeSkillAgent };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map