adaptive-memory-multi-model-router 2.14.46 → 2.14.48

package/tmlpd-pi-extension/src/orchestration/haloOrchestrator.ts

@@ -1,266 +0,0 @@
-/**
- * TMLPD HALO Orchestrator Reference
- * 
- * Hierarchical Autonomous Logic-Oriented Orchestration
- * 
- * Reference implementation - for full features see TMLPD v2.x
- * 
- * Full TMLPD includes:
- * - 3-tier hierarchical planning
- * - TaskPlanner: Decompose with dependencies
- * - RoleAssigner: Specialized agent assignment
- * - ExecutionEngine: Parallel with verification
- * - 19.6% improvement on complex tasks
- */
-
-import { MCTSWorkflowOptimizer } from "./mctsWorkflow";
-import { EpisodicMemoryStore } from "../memory/episodicMemory";
-
-export interface SubTask {
-  id: string;
-  description: string;
-  dependencies: string[];
-  estimatedComplexity: number;
-}
-
-export interface AgentAssignment {
-  subtaskId: string;
-  agentId: string;
-  model: string;
-  estimatedDuration: number;
-}
-
-export interface ExecutionResult {
-  subtaskId: string;
-  success: boolean;
-  output: string;
-  duration_ms: number;
-}
-
-export interface HALOConfig {
-  maxConcurrent: number;
-  optimizationTarget: "quality" | "cost" | "balanced";
-  enableMCTS: boolean;
-}
-
-const DEFAULT_HALO_CONFIG: HALOConfig = {
-  maxConcurrent: 3,
-  optimizationTarget: "balanced",
-  enableMCTS: false
-};
-
-/**
- * HALO Orchestrator
- * 
- * Hierarchical orchestration with 3 tiers:
- * 1. Plan: Decompose task into subtasks with dependencies
- * 2. Assign: Match subtasks to optimal agents
- * 3. Execute: Run in parallel with result verification
- */
-export class HALOOrchestrator {
-  private config: HALOConfig;
-  private memory: EpisodicMemoryStore;
-  private mcts: MCTSWorkflowOptimizer;
-
-  constructor(config: Partial<HALOConfig> = {}) {
-    this.config = { ...DEFAULT_HALO_CONFIG, ...config };
-    this.memory = new EpisodicMemoryStore();
-    this.mcts = new MCTSWorkflowOptimizer({ maxIterations: 30 });
-  }
-
-  /**
-   * Execute task with HALO orchestration
-   */
-  async execute(
-    taskDescription: string,
-    executeFn: (subtask: SubTask, agentId: string) => Promise<ExecutionResult>
-  ): Promise<{
-    success: boolean;
-    results: ExecutionResult[];
-    strategy: Record<string, string>;
-    metadata: any;
-  }> {
-    // Phase 1: Plan - decompose task
-    const subtasks = this.decomposeTask(taskDescription);
-    
-    // Check memory for similar successful strategies
-    const similar = this.memory.getSimilarTasks(taskDescription, 3);
-    
-    // Phase 2: Assign - determine optimal agent assignments
-    const strategy = this.config.enableMCTS
-      ? await this.optimizeWithMCTS(subtasks)
-      : this.quickAssign(subtasks);
-
-    // Phase 3: Execute - run with concurrency limit
-    const results = await this.executeParallel(subtasks, strategy, executeFn);
-
-    // Store in episodic memory
-    this.memory.store({
-      task: {
-        description: taskDescription,
-        type: this.classifyTask(taskDescription),
-        complexity: subtasks.length
-      },
-      result: {
-        success: results.every(r => r.success),
-        output: results.map(r => r.output).join("\n---\n"),
-        duration_ms: results.reduce((sum, r) => sum + r.duration_ms, 0)
-      },
-      agent: { id: "halo", model: "composite", provider: "multi" },
-      metadata: { strategy, subtaskCount: subtasks.length },
-      importance: subtasks.length > 5 ? 0.8 : 0.5
-    });
-
-    return {
-      success: results.every(r => r.success),
-      results,
-      strategy,
-      metadata: {
-        subtasks: subtasks.length,
-        optimizationTarget: this.config.optimizationTarget
-      }
-    };
-  }
-
-  /**
-   * Decompose task into subtasks
-   */
-  decomposeTask(taskDescription: string): SubTask[] {
-    // Simple decomposition - for full NLP-based decomposition see TMLPD
-    const words = taskDescription.toLowerCase().split(/\s+/);
-    const subtasks: SubTask[] = [];
-    
-    // Detect complexity indicators
-    const hasMultipleSteps = /and|then|also|plus|additionally/.test(taskDescription);
-    const hasBranching = /if|when|either|option|choice/.test(taskDescription);
-    const hasSequential = /first|then|finally|step|last/.test(taskDescription);
-
-    if (hasMultipleSteps || taskDescription.length > 100) {
-      // Multi-subtask decomposition
-      const segments = taskDescription.split(/[.,]+/).filter(s => s.trim().length > 10);
-      segments.forEach((seg, idx) => {
-        subtasks.push({
-          id: `subtask-${idx}`,
-          description: seg.trim(),
-          dependencies: idx > 0 ? [`subtask-${idx - 1}`] : [],
-          estimatedComplexity: seg.split(/\s+/).length / 10
-        });
-      });
-    } else {
-      // Single task
-      subtasks.push({
-        id: "subtask-0",
-        description: taskDescription,
-        dependencies: [],
-        estimatedComplexity: words.length / 10
-      });
-    }
-
-    return subtasks;
-  }
-
-  /**
-   * Classify task type
-   */
-  classifyTask(description: string): string {
-    const lower = description.toLowerCase();
-    if (/coding|code|function|class|debug/.test(lower)) return "coding";
-    if (/explain|what is|how to|understand/.test(lower)) return "explanation";
-    if (/analyze|review|evaluate|assess/.test(lower)) return "analysis";
-    if (/create|build|design|implement/.test(lower)) return "creation";
-    if (/translate|convert|transform/.test(lower)) return "transformation";
-    return "general";
-  }
-
-  /**
-   * Quick agent assignment without MCTS
-   */
-  quickAssign(subtasks: SubTask[]): Record<string, string> {
-    const strategy: Record<string, string> = {};
-    const agents = ["claude", "codex", "claude-minimax", "gemini"];
-
-    subtasks.forEach((subtask, idx) => {
-      // Round-robin assignment based on complexity
-      if (subtask.estimatedComplexity > 1.5) {
-        strategy[subtask.id] = agents[idx % agents.length];
-      } else {
-        strategy[subtask.id] = "claude-minimax"; // Fast agent for simple tasks
-      }
-    });
-
-    return strategy;
-  }
-
-  /**
-   * Optimize assignment with MCTS
-   */
-  private async optimizeWithMCTS(
-    subtasks: SubTask[]
-  ): Promise<Record<string, string>> {
-    const subtaskIds = subtasks.map(s => s.id);
-    
-    return await this.mcts.findBestStrategy(subtaskIds, async (assignments) => {
-      // Evaluate strategy quality
-      // For reference: higher reward for balanced load + successful execution
-      const agentLoad = Object.values(assignments).reduce((acc: Record<string, number>, agentId) => {
-        acc[agentId] = (acc[agentId] || 0) + 1;
-        return acc;
-      }, {});
-
-      const loadBalance = 1 / (1 + Object.values(agentLoad).reduce((max, v) => Math.max(max, v), 0) - 1);
-      return loadBalance * 100; // Reward for balanced assignment
-    });
-  }
-
-  /**
-   * Execute subtasks in parallel with concurrency limit
-   */
-  private async executeParallel(
-    subtasks: SubTask[],
-    strategy: Record<string, string>,
-    executeFn: (subtask: SubTask, agentId: string) => Promise<ExecutionResult>
-  ): Promise<ExecutionResult[]> {
-    const results: ExecutionResult[] = [];
-    const pending: Promise<void>[] = [];
-    let idx = 0;
-
-    for (const subtask of subtasks) {
-      const agentId = strategy[subtask.id] || "claude";
-      
-      const promise = executeFn(subtask, agentId).then(result => {
-        results[idx] = result;
-      });
-      
-      pending.push(promise);
-      
-      if (pending.length >= this.config.maxConcurrent) {
-        await Promise.race(pending);
-      }
-      
-      idx++;
-    }
-
-    await Promise.all(pending);
-    return results;
-  }
-
-  /**
-   * Get memory statistics
-   */
-  getMemoryStats() {
-    return this.memory.getStats();
-  }
-}
-
-/**
- * Reference to Full TMLPD HALO
- * 
- * Full implementation in tmlpd-clean/src/orchestration/halo_orchestrator.py
- * 
- * Features:
- * - NLP-based task decomposition
- * - Dependency graph resolution
- * - Agent capability matching
- * - Result verification and retry
- * - Multi-round refinement for low confidence
- */

package/tmlpd-pi-extension/src/orchestration/mctsWorkflow.ts

@@ -1,262 +0,0 @@
-/**
- * TMLPD MCTS Workflow Search
- * 
- * Monte Carlo Tree Search for workflow optimization.
- * Reference implementation - for full features see TMLPD v2.x
- * 
- * Full TMLPD includes:
- * - UCB1 selection policy
- * - Exploration vs exploitation balancing
- * - Workflow state tree building
- * - Strategy learning from execution outcomes
- */
-
-import { nanoid } from "nanoid";
-
-export interface WorkflowState {
-  stateId: string;
-  subtasks: string[];
-  completed: string[];
-  assignments: Record<string, string>; // subtask -> agent
-  totalReward: number;
-  visits: number;
-}
-
-export interface WorkflowAction {
-  type: "assign" | "execute" | "parallelize";
-  subtaskId?: string;
-  agentId?: string;
-}
-
-export interface MCTSConfig {
-  maxIterations: number;
-  explorationConstant: number; // UCB1 exploration parameter
-  maxDepth: number;
-}
-
-const DEFAULT_MCTS_CONFIG: MCTSConfig = {
-  maxIterations: 50,
-  explorationConstant: 1.414, // sqrt(2) for UCB1
-  maxDepth: 5
-};
-
-export class WorkflowNode {
-  state: WorkflowState;
-  parent: WorkflowNode | null;
-  children: Map<string, WorkflowNode>;
-  untriedActions: WorkflowAction[];
-  
-  constructor(state: WorkflowState, parent: WorkflowNode | null = null) {
-    this.state = state;
-    this.parent = parent;
-    this.children = new Map();
-    this.untriedActions = [];
-  }
-
-  get averageReward(): number {
-    return this.state.visits > 0 ? this.state.totalReward / this.state.visits : 0;
-  }
-
-  get isTerminal(): boolean {
-    return this.state.subtasks.length === this.state.completed.length;
-  }
-
-  get isFullyExpanded(): boolean {
-    return this.untriedActions.length === 0 && this.children.size > 0;
-  }
-}
-
-/**
- * MCTS Workflow Optimizer
- * 
- * Uses Monte Carlo Tree Search to find optimal workflow strategies.
- * 
- * @example
- * ```typescript
- * const optimizer = new MCTSWorkflowOptimizer();
- * const bestStrategy = optimizer.findBestStrategy(task);
- * ```
- */
-export class MCTSWorkflowOptimizer {
-  private config: MCTSConfig;
-  private root: WorkflowNode | null = null;
-  private agents: string[];
-
-  constructor(config: Partial<MCTSConfig> = {}, agents: string[] = []) {
-    this.config = { ...DEFAULT_MCTS_CONFIG, ...config };
-    this.agents = agents;
-  }
-
-  /**
-   * Set available agents
-   */
-  setAgents(agents: string[]) {
-    this.agents = agents;
-  }
-
-  /**
-   * Find best workflow strategy using MCTS
-   */
-  async findBestStrategy(
-    subtasks: string[],
-    evaluateFn: (strategy: Record<string, string>) => Promise<number> // Returns reward
-  ): Promise<Record<string, string>> {
-    const initialState: WorkflowState = {
-      stateId: nanoid(8),
-      subtasks,
-      completed: [],
-      assignments: {},
-      totalReward: 0,
-      visits: 0
-    };
-
-    this.root = new WorkflowNode(initialState);
-
-    // Initialize untried actions
-    if (this.root) {
-      this.root.untriedActions = this.generateActions(subtasks);
-    }
-
-    // MCTS iterations
-    for (let i = 0; i < this.config.maxIterations; i++) {
-      await this.mctsIteration(evaluateFn);
-    }
-
-    // Return best strategy
-    if (this.root && this.root.children.size > 0) {
-      const bestChild = this.selectBestChild(this.root);
-      return bestChild?.state.assignments || {};
-    } else {
-      return {};
-    }
-  }
-
-  private async mctsIteration(
-    evaluateFn: (strategy: Record<string, string>) => Promise<number>
-  ) {
-    if (!this.root) return;
-
-    let node = this.selectNode(this.root);
-
-    if (!node) return;
-
-    // Expansion
-    if (node.untriedActions.length > 0) {
-      const action = node.untriedActions.pop()!;
-      node = this.expand(node, action);
-    }
-
-    // Simulation (simplified - evaluate async)
-    if (node) {
-      const reward = await evaluateFn(node.state.assignments);
-      this.backpropagate(node, reward);
-    }
-  }
-
-  private selectNode(node: WorkflowNode): WorkflowNode | null {
-    while (node && !node.isTerminal) {
-      if (node.isFullyExpanded) {
-        node = this.ucb1Select(node);
-      } else {
-        return node;
-      }
-    }
-    return node;
-  }
-
-  private ucb1Select(node: WorkflowNode): WorkflowNode {
-    let bestChild: WorkflowNode | null = null;
-    let bestUCB = -Infinity;
-
-    for (const child of node.children.values()) {
-      const ucb = this.ucb(child);
-      if (ucb > bestUCB) {
-        bestUCB = ucb;
-        bestChild = child;
-      }
-    }
-
-    return bestChild || node;
-  }
-
-  private ucb(node: WorkflowNode): number {
-    if (node.state.visits === 0) return Infinity;
-    const parentVisits = node.parent?.state.visits || 1;
-    return node.averageReward + 
-      this.config.explorationConstant * Math.sqrt(Math.log(parentVisits) / node.state.visits);
-  }
-
-  private expand(node: WorkflowNode, action: WorkflowAction): WorkflowNode {
-    const newAssignments = { ...node.state.assignments };
-    
-    if (action.type === "assign" && action.subtaskId && action.agentId) {
-      newAssignments[action.subtaskId] = action.agentId;
-    }
-
-    const newState: WorkflowState = {
-      stateId: nanoid(8),
-      subtasks: node.state.subtasks,
-      completed: [...node.state.completed],
-      assignments: newAssignments,
-      totalReward: 0,
-      visits: 0
-    };
-
-    const child = new WorkflowNode(newState, node);
-    node.children.set(newState.stateId, child);
-    child.untriedActions = this.generateActions(newState.subtasks);
-
-    return child;
-  }
-
-  private generateActions(subtasks: string[]): WorkflowAction[] {
-    const actions: WorkflowAction[] = [];
-    const availableAgents = this.agents.length > 0 ? this.agents : ["claude", "codex", "gemini"];
-
-    subtasks.forEach(subtask => {
-      availableAgents.forEach(agent => {
-        actions.push({
-          type: "assign",
-          subtaskId: subtask,
-          agentId: agent
-        });
-      });
-    });
-
-    return actions;
-  }
-
-  private selectBestChild(node: WorkflowNode): WorkflowNode | null {
-    let best: WorkflowNode | null = null;
-    let bestReward = -Infinity;
-
-    for (const child of node.children.values()) {
-      if (child.averageReward > bestReward) {
-        bestReward = child.averageReward;
-        best = child;
-      }
-    }
-
-    return best;
-  }
-
-  private backpropagate(node: WorkflowNode, reward: number) {
-    while (node) {
-      node.state.visits++;
-      node.state.totalReward += reward;
-      node = node.parent as WorkflowNode;
-    }
-  }
-}
-
-/**
- * Reference to Full TMLPD MCTS
- * 
- * Full implementation in tmlpd-clean/src/orchestration/mcts_workflow.py
- * 
- * Features:
- * - Full UCB1 with proper exploration constant
- * - Deterministic rollout simulation
- * - Strategy caching with performance tracking
- * - Adaptive depth based on task complexity
- */