rax-flow-core 0.1.4 → 2.0.0

package/src/memory/local-vector-store.ts

@@ -1,30 +1,62 @@
 import { IVectorStore, MemoryDocument, SearchResult } from "../types/contracts.js";
-import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { readFile, writeFile, mkdir, stat } from "node:fs/promises";
 import path from "node:path";
 
+export interface StorageMetadata {
+    version: string;
+    createdAt: string;
+    updatedAt: string;
+    documentCount: number;
+    vectorDimensions: number;
+}
+
 /**
  * A lightweight, local vector store using Cosine Similarity.
  * Suitable for small-to-medium datasets (thousands of records).
- * Persists data to a simple JSON structure.
+ * Persists data with versioning, metadata, and TTL support.
  */
 export class LocalVectorStore implements IVectorStore {
     private documents: MemoryDocument[] = [];
     private vectors: number[][] = [];
     private metadata: Map<string, Record<string, unknown>> = new Map();
+    private ttlMap: Map<string, number> = new Map(); // doc id -> expiry timestamp
+    private storageMetadata: StorageMetadata = {
+        version: "1.0",
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        documentCount: 0,
+        vectorDimensions: 0
+    };
 
     constructor(private persistPath?: string) { }
 
-    async add(documents: MemoryDocument[], vectors: number[][]): Promise<void> {
+    async add(documents: MemoryDocument[], vectors: number[][], ttlSeconds?: number): Promise<void> {
         if (documents.length !== vectors.length) {
             throw new Error("Mismatched documents and vectors count.");
         }
         this.documents.push(...documents);
         this.vectors.push(...vectors);
+        
+        // Update metadata
+        if (vectors.length > 0) {
+            this.storageMetadata.vectorDimensions = vectors[0].length;
+        }
+        
+        // Set TTL if provided
+        if (ttlSeconds) {
+            const expiryTime = Date.now() + ttlSeconds * 1000;
+            documents.forEach(doc => this.ttlMap.set(doc.id, expiryTime));
+        }
+        
+        this.storageMetadata.documentCount = this.documents.length;
+        this.storageMetadata.updatedAt = new Date().toISOString();
         if (this.persistPath) await this.save();
     }
 
     async search(queryVector: number[], limit: number = 5): Promise<SearchResult[]> {
         if (this.vectors.length === 0) return [];
+        
+        this.pruneExpiredDocuments();
 
         const results: SearchResult[] = this.vectors.map((vec, i) => {
             const score = this.cosineSimilarity(queryVector, vec);
@@ -40,6 +72,9 @@ export class LocalVectorStore implements IVectorStore {
         this.documents = [];
         this.vectors = [];
         this.metadata.clear();
+        this.ttlMap.clear();
+        this.storageMetadata.documentCount = 0;
+        this.storageMetadata.updatedAt = new Date().toISOString();
         if (this.persistPath) await this.save();
     }
 
@@ -50,8 +85,11 @@ export class LocalVectorStore implements IVectorStore {
                 this.documents.splice(idx, 1);
                 this.vectors.splice(idx, 1);
                 this.metadata.delete(id);
+                this.ttlMap.delete(id);
             }
         }
+        this.storageMetadata.documentCount = this.documents.length;
+        this.storageMetadata.updatedAt = new Date().toISOString();
         if (this.persistPath) await this.save();
     }
 
@@ -69,10 +107,51 @@ export class LocalVectorStore implements IVectorStore {
     public getMetrics() {
         return {
             documentCount: this.documents.length,
-            vectorDimensions: this.vectors[0]?.length || 0
+            vectorDimensions: this.vectors[0]?.length || 0,
+            storagePath: this.persistPath || "in-memory",
+            metadata: this.storageMetadata
+        };
+    }
+
+    /**
+     * Export store state for external persistence or backup.
+     */
+    public export() {
+        return {
+            documents: this.documents,
+            vectors: this.vectors,
+            metadata: Object.fromEntries(this.metadata),
+            storageMetadata: this.storageMetadata
         };
     }
 
+    /**
+     * Import store state from external source.
+     */
+    public async import(state: ReturnType<LocalVectorStore['export']>): Promise<void> {
+        this.documents = state.documents;
+        this.vectors = state.vectors;
+        this.metadata = new Map(Object.entries(state.metadata));
+        this.storageMetadata = state.storageMetadata;
+        if (this.persistPath) await this.save();
+    }
+
+    /**
+     * Remove expired documents based on TTL.
+     */
+    private pruneExpiredDocuments(): void {
+        const now = Date.now();
+        const expiredIds: string[] = [];
+        
+        this.ttlMap.forEach((expiry, docId) => {
+            if (expiry < now) expiredIds.push(docId);
+        });
+        
+        if (expiredIds.length > 0) {
+            this.delete(expiredIds);
+        }
+    }
+
     /**
      * Calculates cosine similarity between two numeric vectors.
      */
@@ -112,18 +191,36 @@ export class LocalVectorStore implements IVectorStore {
     }
 
     /**
-     * Internal save to disk.
+     * Internal save to disk with error handling and version info.
      */
     private async save(): Promise<void> {
         if (!this.persistPath) return;
         try {
             await mkdir(path.dirname(this.persistPath), { recursive: true });
-            await writeFile(this.persistPath, JSON.stringify({
+            const payload = {
+                metadata: this.storageMetadata,
                 documents: this.documents,
-                vectors: this.vectors
-            }));
+                vectors: this.vectors,
+                ttl: Object.fromEntries(this.ttlMap)
+            };
+            await writeFile(this.persistPath, JSON.stringify(payload, null, 2));
         } catch (err) {
             console.error("Failed to persist vector store:", err);
         }
     }
+
+    /**
+     * Check if store is stale and needs reload.
+     */
+    public async isStale(): Promise<boolean> {
+        if (!this.persistPath) return false;
+        try {
+            const stats = await stat(this.persistPath);
+            const fileTime = new Date(stats.mtime).getTime();
+            const storageTime = new Date(this.storageMetadata.updatedAt).getTime();
+            return fileTime > storageTime;
+        } catch {
+            return false;
+        }
+    }
 }

package/src/orchestrator/core-orchestrator.ts

@@ -330,10 +330,31 @@ export class CoreOrchestrator {
         }
       };
 
+      // Inject memory context if available
+      if (this.memory && input.userPrompt) {
+        try {
+          const memoryContext = await this.getMemoryContext(input.userPrompt);
+          if (memoryContext) {
+            attemptInput.context!.memoryContext = memoryContext;
+          }
+        } catch (err) {
+          console.warn("Memory context retrieval failed:", err);
+        }
+      }
+
       await this.plugins.runBeforeNode({ node, input: attemptInput });
       const output = await agent.run(attemptInput);
       await this.plugins.runAfterNode({ node, input: attemptInput, output });
 
+      // Persist node output to memory
+      if (this.memory && output.success) {
+        try {
+          await this.persistNodeToMemory(node, output);
+        } catch (err) {
+          console.warn("Failed to persist node to memory:", err);
+        }
+      }
+
       // HITL (Human-in-the-Loop) Intercept
       if (node.requireApproval) {
         this.events.emit({
@@ -579,4 +600,61 @@ export class CoreOrchestrator {
       };
     }
   }
+
+  /**
+   * Retrieve relevant context from memory based on input prompt
+   */
+  private async getMemoryContext(prompt: string): Promise<string | undefined> {
+    if (!this.memory) return undefined;
+    
+    try {
+      const context = await this.memory.getQuantumContext(this.getPromptVector(prompt), 3);
+      return context || undefined;
+    } catch (err) {
+      console.warn("Error retrieving memory context:", err);
+      return undefined;
+    }
+  }
+
+  /**
+   * Persist successful node execution to memory graph
+   */
+  private async persistNodeToMemory(node: WorkflowNode, output: AgentOutput): Promise<void> {
+    if (!this.memory) return;
+    
+    try {
+      const nodeContent = JSON.stringify({
+        agent: node.agent,
+        output: output.data,
+        confidence: output.confidence
+      });
+      
+      const vector = this.getPromptVector(nodeContent);
+      
+      await this.memory.remember({
+        id: node.id,
+        text: nodeContent,
+        metadata: {
+          agent: node.agent,
+          success: output.success,
+          confidence: output.confidence
+        },
+        timestamp: Date.now()
+      }, vector);
+    } catch (err) {
+      console.warn("Error persisting to memory:", err);
+    }
+  }
+
+  /**
+   * Simple vector representation of prompt for memory search
+   */
+  private getPromptVector(prompt: string): number[] {
+    const vector = new Array(384).fill(0);
+    for (let i = 0; i < prompt.length; i++) {
+      vector[i % 384] += prompt.charCodeAt(i) / 1000;
+    }
+    const magnitude = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
+    return magnitude > 0 ? vector.map(v => v / magnitude) : vector;
+  }
 }

package/src/orchestrator/task-decomposer.ts

@@ -0,0 +1,428 @@
+import { IModelProvider, WorkflowGraph, WorkflowNode, Intent } from "../types/contracts.js";
+import { Decomposition, Subtask } from "./decomposition-engine.js";
+
+export interface DecompositionStrategy {
+  name: string;
+  description: string;
+  applicableIntents: Intent[];
+  maxChunkSize: number;
+  enableParallelization: boolean;
+}
+
+export interface DecompositionResult {
+  workflow: WorkflowGraph;
+  subworkflows: WorkflowGraph[];
+  strategy: string;
+  confidence: number;
+  reasoning: string;
+}
+
+export interface TaskAnalysis {
+  complexity: "low" | "medium" | "high" | "extreme";
+  estimatedTokens: number;
+  suggestedStrategy: string;
+  canDecompose: boolean;
+  detectedPatterns: string[];
+  riskFactors: string[];
+}
+
+const DEFAULT_STRATEGIES: DecompositionStrategy[] = [
+  {
+    name: "sequential",
+    description: "Linear step-by-step execution",
+    applicableIntents: ["brainstorm", "spec", "architecture", "plan"],
+    maxChunkSize: 1,
+    enableParallelization: false
+  },
+  {
+    name: "parallel_verify",
+    description: "Execute multiple verifications in parallel",
+    applicableIntents: ["test", "benchmark", "optimize"],
+    maxChunkSize: 5,
+    enableParallelization: true
+  },
+  {
+    name: "code_pipeline",
+    description: "Standard code generation pipeline",
+    applicableIntents: ["generate_code"],
+    maxChunkSize: 4,
+    enableParallelization: false
+  },
+  {
+    name: "fix_loop",
+    description: "Iterative fix with verification",
+    applicableIntents: ["fix"],
+    maxChunkSize: 2,
+    enableParallelization: false
+  },
+  {
+    name: "document_chain",
+    description: "Documentation generation chain",
+    applicableIntents: ["document"],
+    maxChunkSize: 3,
+    enableParallelization: true
+  }
+];
+
+const COMPLEXITY_THRESHOLDS = {
+  low: { maxWords: 20, maxConcepts: 2 },
+  medium: { maxWords: 50, maxConcepts: 4 },
+  high: { maxWords: 100, maxConcepts: 6 },
+  extreme: { maxWords: Infinity, maxConcepts: Infinity }
+};
+
+const COMPLEX_PATTERNS = [
+  { pattern: /microservice|distributed|scalab/i, weight: 3, type: "architecture" },
+  { pattern: /auth|security|encrypt|oauth/i, weight: 2, type: "security" },
+  { pattern: /database|persist|store|query/i, weight: 2, type: "data" },
+  { pattern: /api|rest|graphql|endpoint/i, weight: 1, type: "api" },
+  { pattern: /test|coverage|verify|validate/i, weight: 1, type: "testing" },
+  { pattern: /deploy|ci\/cd|pipeline|infra/i, weight: 2, type: "devops" },
+  { pattern: /real.?time|websocket|stream/i, weight: 2, type: "realtime" },
+  { pattern: /ai|ml|model|neural|llm/i, weight: 2, type: "ai" }
+];
+
+export class TaskDecomposer {
+  private readonly basicDecomposer = new Decomposition();
+
+  constructor(
+    private provider?: IModelProvider,
+    private strategies: DecompositionStrategy[] = DEFAULT_STRATEGIES
+  ) {}
+
+  async analyze(prompt: string, intent: Intent): Promise<TaskAnalysis> {
+    const wordCount = prompt.split(/\s+/).length;
+    const detectedPatterns = this.detectPatterns(prompt);
+    const complexity = this.calculateComplexity(prompt, detectedPatterns);
+    const estimatedTokens = this.estimateTokens(prompt, complexity);
+    const strategy = this.selectStrategy(intent, complexity);
+
+    const riskFactors = this.identifyRisks(prompt, complexity, detectedPatterns);
+
+    return {
+      complexity,
+      estimatedTokens,
+      suggestedStrategy: strategy.name,
+      canDecompose: complexity !== "low" && estimatedTokens > 500,
+      detectedPatterns: detectedPatterns.map(p => p.type),
+      riskFactors
+    };
+  }
+
+  async decompose(
+    prompt: string,
+    intent: Intent,
+    options?: {
+      useLLM?: boolean;
+      maxSubtasks?: number;
+      preferParallel?: boolean;
+    }
+  ): Promise<DecompositionResult> {
+    const analysis = await this.analyze(prompt, intent);
+    const strategy = this.strategies.find(s => s.name === analysis.suggestedStrategy) ?? this.strategies[0];
+
+    if (options?.useLLM && this.provider && analysis.complexity !== "low") {
+      return this.llmDecompose(prompt, intent, strategy, analysis);
+    }
+
+    return this.heuristicDecompose(prompt, intent, strategy, analysis, options);
+  }
+
+  private async llmDecompose(
+    prompt: string,
+    intent: Intent,
+    strategy: DecompositionStrategy,
+    analysis: TaskAnalysis
+  ): Promise<DecompositionResult> {
+    const systemPrompt = `You are a task decomposition expert. Break down complex tasks into executable subtasks.
+
+Rules:
+1. Each subtask should be atomic and assignable to a single agent
+2. Define clear dependencies between subtasks
+3. Mark independent subtasks for parallel execution
+4. Output valid JSON matching the WorkflowGraph schema
+
+Available agents: IntentClassifierAgent, SpecAgent, ArchitectureAgent, TaskPlannerAgent, CodeGeneratorAgent, TestAgent, ValidatorAgent, FixAgent, OptimizerAgent, DocumentationAgent, BenchmarkAgent, BrainstormAgent`;
+
+    const userPrompt = `Decompose this ${intent} task:
+"${prompt}"
+
+Complexity: ${analysis.complexity}
+Patterns detected: ${analysis.detectedPatterns.join(", ") || "none"}
+Preferred strategy: ${strategy.name}
+
+Output JSON:`;
+
+    try {
+      const response = await this.provider!.callStructured<WorkflowGraph>(
+        `${systemPrompt}\n\n${userPrompt}`,
+        {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            nodes: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  id: { type: "string" },
+                  agent: { type: "string" },
+                  dependsOn: { type: "array", items: { type: "string" } },
+                  requireApproval: { type: "boolean" }
+                },
+                required: ["id", "agent", "dependsOn"]
+              }
+            }
+          },
+          required: ["id", "nodes"]
+        },
+        { temperature: 0.3, maxTokens: 2000 }
+      );
+
+      return {
+        workflow: response.output,
+        subworkflows: [],
+        strategy: strategy.name,
+        confidence: 0.85,
+        reasoning: "LLM-based decomposition applied"
+      };
+    } catch (error) {
+      console.warn("[TaskDecomposer] LLM decomposition failed, falling back to heuristics");
+      return this.heuristicDecompose(prompt, intent, strategy, analysis, {});
+    }
+  }
+
+  private heuristicDecompose(
+    prompt: string,
+    intent: Intent,
+    strategy: DecompositionStrategy,
+    analysis: TaskAnalysis,
+    options?: { maxSubtasks?: number; preferParallel?: boolean }
+  ): Promise<DecompositionResult> {
+    const nodes: WorkflowNode[] = [];
+    const subworkflows: WorkflowGraph[] = [];
+
+    switch (intent) {
+      case "generate_code":
+        nodes.push(
+          { id: "analyze", agent: "IntentClassifierAgent", dependsOn: [] },
+          { id: "spec", agent: "SpecAgent", dependsOn: ["analyze"] },
+          { id: "architecture", agent: "ArchitectureAgent", dependsOn: ["spec"] },
+          { id: "implement", agent: "CodeGeneratorAgent", dependsOn: ["architecture"] },
+          { id: "test", agent: "TestAgent", dependsOn: ["implement"] },
+          { id: "validate", agent: "ValidatorAgent", dependsOn: ["test"] }
+        );
+        break;
+
+      case "fix":
+        nodes.push(
+          { id: "diagnose", agent: "ValidatorAgent", dependsOn: [] },
+          { id: "fix", agent: "FixAgent", dependsOn: ["diagnose"] },
+          { id: "verify", agent: "ValidatorAgent", dependsOn: ["fix"] }
+        );
+        break;
+
+      case "test":
+        nodes.push(
+          { id: "analyze", agent: "IntentClassifierAgent", dependsOn: [] },
+          { id: "test_design", agent: "TestAgent", dependsOn: ["analyze"] },
+          { id: "test_exec", agent: "ValidatorAgent", dependsOn: ["test_design"] }
+        );
+        break;
+
+      case "architecture":
+        nodes.push(
+          { id: "requirements", agent: "SpecAgent", dependsOn: [] },
+          { id: "design", agent: "ArchitectureAgent", dependsOn: ["requirements"] },
+          { id: "plan", agent: "TaskPlannerAgent", dependsOn: ["design"] },
+          { id: "review", agent: "ValidatorAgent", dependsOn: ["plan"] }
+        );
+        break;
+
+      case "document":
+        nodes.push(
+          { id: "analyze", agent: "IntentClassifierAgent", dependsOn: [] },
+          { id: "document", agent: "DocumentationAgent", dependsOn: ["analyze"] },
+          { id: "validate", agent: "ValidatorAgent", dependsOn: ["document"] }
+        );
+        break;
+
+      case "optimize":
+        nodes.push(
+          { id: "profile", agent: "BenchmarkAgent", dependsOn: [] },
+          { id: "optimize", agent: "OptimizerAgent", dependsOn: ["profile"] },
+          { id: "validate", agent: "ValidatorAgent", dependsOn: ["optimize"] },
+          { id: "benchmark", agent: "BenchmarkAgent", dependsOn: ["validate"] }
+        );
+        break;
+
+      case "benchmark":
+        nodes.push(
+          { id: "setup", agent: "BenchmarkAgent", dependsOn: [] },
+          { id: "execute", agent: "BenchmarkAgent", dependsOn: ["setup"] },
+          { id: "report", agent: "BenchmarkAgent", dependsOn: ["execute"] }
+        );
+        break;
+
+      default:
+        nodes.push(
+          { id: "analyze", agent: "IntentClassifierAgent", dependsOn: [] },
+          { id: "execute", agent: "BrainstormAgent", dependsOn: ["analyze"] }
+        );
+    }
+
+    if (analysis.complexity === "extreme" && nodes.length > 0) {
+      const lastNodeId = nodes[nodes.length - 1].id;
+      nodes.push({ id: "review", agent: "ValidatorAgent", dependsOn: [lastNodeId] });
+    }
+
+    if (options?.preferParallel && strategy.enableParallelization) {
+      const independentNodes = nodes.filter(n => n.dependsOn.length === 0);
+      if (independentNodes.length > 1) {
+        const parallelGateId = "parallel_gate";
+        for (const node of independentNodes) {
+          node.dependsOn = [parallelGateId];
+        }
+        nodes.unshift({ id: parallelGateId, agent: "IntentClassifierAgent", dependsOn: [] });
+      }
+    }
+
+    if (options?.maxSubtasks && nodes.length > options.maxSubtasks) {
+      const keptNodes = nodes.slice(0, options.maxSubtasks);
+      const lastKept = keptNodes[keptNodes.length - 1];
+      for (const node of keptNodes) {
+        node.dependsOn = node.dependsOn.filter(d => keptNodes.some(k => k.id === d));
+      }
+      nodes.length = 0;
+      nodes.push(...keptNodes);
+    }
+
+    const workflow: WorkflowGraph = {
+      id: `wf_${intent}_${Date.now()}`,
+      nodes
+    };
+
+    return Promise.resolve({
+      workflow,
+      subworkflows,
+      strategy: strategy.name,
+      confidence: analysis.complexity === "low" ? 0.9 : 0.7,
+      reasoning: `Heuristic decomposition using ${strategy.name} strategy for ${analysis.complexity} complexity`
+    });
+  }
+
+  detectPatterns(prompt: string): Array<{ type: string; weight: number }> {
+    const detected: Array<{ type: string; weight: number }> = [];
+    for (const { pattern, weight, type } of COMPLEX_PATTERNS) {
+      if (pattern.test(prompt)) {
+        detected.push({ type, weight });
+      }
+    }
+    return detected;
+  }
+
+  private calculateComplexity(
+    prompt: string,
+    patterns: Array<{ type: string; weight: number }>
+  ): TaskAnalysis["complexity"] {
+    const wordCount = prompt.split(/\s+/).length;
+    const patternWeight = patterns.reduce((sum, p) => sum + p.weight, 0);
+    const conceptCount = patterns.length;
+
+    if (wordCount > COMPLEXITY_THRESHOLDS.high.maxWords || patternWeight >= 6 || conceptCount >= 5) {
+      return "extreme";
+    }
+    if (wordCount > COMPLEXITY_THRESHOLDS.medium.maxWords || patternWeight >= 3 || conceptCount >= 3) {
+      return "high";
+    }
+    if (wordCount > COMPLEXITY_THRESHOLDS.low.maxWords || patternWeight >= 1 || conceptCount >= 1) {
+      return "medium";
+    }
+    return "low";
+  }
+
+  private estimateTokens(prompt: string, complexity: TaskAnalysis["complexity"]): number {
+    const baseTokens = prompt.split(/\s+/).length * 1.3;
+    const multipliers = { low: 1, medium: 1.5, high: 2, extreme: 3 };
+    return Math.round(baseTokens * multipliers[complexity]);
+  }
+
+  private selectStrategy(intent: Intent, complexity: TaskAnalysis["complexity"]): DecompositionStrategy {
+    const intentMatch = this.strategies.find(s => s.applicableIntents.includes(intent));
+    if (intentMatch) return intentMatch;
+
+    if (complexity === "extreme" || complexity === "high") {
+      return this.strategies.find(s => s.name === "parallel_verify") ?? this.strategies[0];
+    }
+    return this.strategies.find(s => s.name === "sequential") ?? this.strategies[0];
+  }
+
+  private identifyRisks(
+    prompt: string,
+    complexity: TaskAnalysis["complexity"],
+    patterns: Array<{ type: string; weight: number }>
+  ): string[] {
+    const risks: string[] = [];
+
+    if (complexity === "extreme") {
+      risks.push("Task may exceed context window limits");
+      risks.push("Consider splitting into separate workflows");
+    }
+
+    if (patterns.some(p => p.type === "security")) {
+      risks.push("Security-sensitive task requires governance review");
+    }
+
+    if (patterns.some(p => p.type === "realtime")) {
+      risks.push("Real-time features may require specialized testing");
+    }
+
+    if (prompt.includes("urgent") || prompt.includes("asap") || prompt.includes("critical")) {
+      risks.push("Time-sensitive task flagged for priority execution");
+    }
+
+    return risks;
+  }
+
+  async decomposeToSubtasks(
+    prompt: string,
+    options?: { constraints?: { maxSubtasks?: number; maxDuration?: number } }
+  ): Promise<Subtask[]> {
+    return this.basicDecomposer.decompose(prompt, options);
+  }
+
+  async generateSubWorkflows(
+    prompt: string,
+    intent: Intent,
+    analysis: TaskAnalysis
+  ): Promise<WorkflowGraph[]> {
+    if (analysis.complexity !== "extreme") {
+      return [];
+    }
+
+    const patterns = this.detectPatterns(prompt);
+    const subworkflows: WorkflowGraph[] = [];
+
+    for (const pattern of patterns) {
+      const subWf: WorkflowGraph = {
+        id: `subwf_${pattern.type}_${Date.now()}`,
+        nodes: [
+          { id: `${pattern.type}_spec`, agent: "SpecAgent", dependsOn: [] },
+          { id: `${pattern.type}_impl`, agent: "CodeGeneratorAgent", dependsOn: [`${pattern.type}_spec`] },
+          { id: `${pattern.type}_test`, agent: "TestAgent", dependsOn: [`${pattern.type}_impl`] }
+        ]
+      };
+      subworkflows.push(subWf);
+    }
+
+    return subworkflows;
+  }
+
+  addStrategy(strategy: DecompositionStrategy): void {
+    this.strategies.push(strategy);
+  }
+
+  getStrategies(): DecompositionStrategy[] {
+    return [...this.strategies];
+  }
+}