@almadar/agent 1.3.1 → 1.3.3

package/dist/agent/index.js

@@ -2,7 +2,7 @@ import { AgentDomainCategorySchema, isOrbitalDefinition, isEntityReference, getT
 import { getFullOrbitalPrompt, getRequirementsTraitPrompt, getKeyBehaviorsReference, getSExprQuickRef, getCommonErrorsSection, getArchitectureSection } from '@almadar/skills';
 import { tool } from '@langchain/core/tools';
 import { z } from 'zod';
-import { LLMClient, ANTHROPIC_MODELS, createAnthropicClient, OPENROUTER_MODELS, createOpenRouterClient, KIMI_MODELS, createKimiClient, OPENAI_MODELS, createOpenAIClient, DEEPSEEK_MODELS, createDeepSeekClient } from '@almadar/llm';
+import { LLMClient, ANTHROPIC_MODELS, createAnthropicClient, OPENROUTER_MODELS, createOpenRouterClient, KIMI_MODELS, createKimiClient, OPENAI_MODELS, createOpenAIClient, DEEPSEEK_MODELS, createDeepSeekClient, createRequirementsClient } from '@almadar/llm';
 import { FilesystemBackend, createDeepAgent } from 'deepagents';
 import { MemorySaver } from '@langchain/langgraph';
 export { Command } from '@langchain/langgraph';
@@ -4692,6 +4692,2061 @@ function getBudgetWarningMessage(eventCount, budget) {
   return null;
 }
 
-export { EVENT_BUDGETS, SessionManager, createSkillAgent, getBudgetWarningMessage, getEventBudget, getInterruptConfig, resumeSkillAgent };
+// 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, tool12, input, options = {}) {
+    this.definition.steps.push({
+      id,
+      name: id,
+      tool: tool12,
+      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 path6 = value.slice(2, -2).trim();
+        result[key] = this.getValueFromPath(context, path6);
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  /**
+   * Get value from path
+   */
+  getValueFromPath(obj, path6) {
+    const parts = path6.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);
+}
+
+export { EVENT_BUDGETS, HITLWorkflowEngine, HITLv2Manager, MemoryIntegrationEngine, ReActEngine, ReActWorkflowEngine, ReActWorkflowExecutor, SessionManager, createHITLWorkflowEngine, createHITLv2Manager, createMemoryIntegration, createMultiStageApprovalWorkflow, createReActEngine, createReActWorkflowEngine, createReActWorkflowExecutor, createSchemaGenerationHITLWorkflow, createSkillAgent, getBudgetWarningMessage, getEventBudget, getInterruptConfig, resumeSkillAgent };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map