@thoughtflow/core 0.1.2

package/dist/libs/thoughtflow-agent-hierarchy.js

@@ -0,0 +1,913 @@
+"use strict";
+/**
+ * thoughtflow-agent-hierarchy.ts
+ *
+ * Agent Hierarchy for Autonomous Software Development Corporation
+ *
+ * Three-tier architecture:
+ * - Strategic Agents (long-term planning, business alignment)
+ * - Tactical Agents (mid-term coordination, workflow management)
+ * - Operational Agents (short-term execution, code generation)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_REGISTRY = exports.OPERATIONAL_AGENTS = exports.TACTICAL_AGENTS = exports.STRATEGIC_AGENTS = void 0;
+exports.getAgentByName = getAgentByName;
+exports.getAgentsByTaskType = getAgentsByTaskType;
+const task_board_types_1 = require("../contracts/task-board.types");
+const conversation_class_1 = require("../conversation.class");
+const ollama_adapter_1 = require("../adapters/llm/ollama.adapter");
+const openai_adapter_1 = require("../adapters/llm/openai.adapter");
+const workspace_1 = require("../tools/workspace");
+const conversation_status_enum_1 = require("../contracts/conversation-status.enum");
+const VLLM_BASE_URL = process.env.VLLM_BASE_URL ?? `http://${process.env.VLLM_HOST ?? "localhost:8000"}`;
+const OLLAMA_BASE_URL = process.env.OLLAMA_BASE_URL ?? "http://localhost:11434";
+const MODEL = process.env.SCENARIO_MODEL ?? "qwen2.5-coder-14b-instruct";
+function makeLlmAdapter() {
+    return VLLM_BASE_URL
+        ? new openai_adapter_1.OpenAiAdapter({ apiKey: "no-key", baseUrl: VLLM_BASE_URL })
+        : new ollama_adapter_1.OllamaAdapter({ baseUrl: OLLAMA_BASE_URL });
+}
+const PROJECT_ROOT = process.cwd();
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Strategic Agents - Business-level decision making
+ * Focus: Vision, strategy, alignment, business requirements
+ */
+exports.STRATEGIC_AGENTS = {
+    /**
+     * Business Analyst Agent - Analyze single requirement
+     */
+    BUSINESS_ANALYST: {
+        name: "business-analyst",
+        description: "Analyze single requirement",
+        taskTypes: [task_board_types_1.TaskType.RESEARCH, task_board_types_1.TaskType.DOCS],
+        execute: async (task, context) => {
+            const taskId = task.id;
+            console.log(`\n${"=".repeat(80)}`);
+            console.log(`[business-analyst] START TASK`);
+            console.log(`  Task ID: ${taskId}`);
+            console.log(`  Title: ${task.title}`);
+            console.log(`  Status: ${task.status}`);
+            console.log(`  Type: ${task.type}`);
+            console.log(`  Metadata: ${JSON.stringify(task.metadata || {})}`);
+            console.log(`${"=".repeat(80)}\n`);
+            try {
+                const requirementId = task.metadata?.requirementId;
+                const requirementText = task.metadata?.requirementText;
+                const conv = new conversation_class_1.Conversation({
+                    llmAdapter: makeLlmAdapter(),
+                    model: MODEL,
+                    thinking: false,
+                    temperature: 0.6,
+                    tools: [],
+                    systemPrompt: `You are a business analyst agent. Analyze the requirement and provide detailed assessment.
+            
+Task: ${task.title}
+Requirement ID: ${requirementId || 'REQ-001'}
+Requirement Text: ${requirementText || 'No requirement text provided'}
+
+Provide your analysis in this format:
+## Analysis
+- Business Value: [high/medium/low]
+- Complexity: [high/medium/low]
+- Dependencies: [list any dependencies]
+- Risks: [list any risks]
+- Recommendations: [list recommendations]
+
+Be concise and focused on the single requirement.`,
+                    loadModelsOnInit: false,
+                    runPreflightOnInit: false,
+                    maxIterationsPerRun: 6,
+                    stallDetection: "tool",
+                });
+                const prompt = `Analyze this requirement: ${requirementId || 'REQ-001'}
+
+${requirementText || 'No requirement text provided'}
+
+Provide your analysis following the format above.`;
+                console.log(`[business-analyst] Sending prompt to LLM...`);
+                console.log(`[business-analyst] Prompt length: ${prompt.length} chars`);
+                console.log(`[business-analyst] Prompt (first 500 chars):\n${prompt.slice(0, 500)}...\n`);
+                const result = await conv.sendPrompt(prompt, { signal: AbortSignal.timeout(120_000) });
+                console.log(`[business-analyst] LLM response received`);
+                console.log(`  Status: ${result.status === conversation_status_enum_1.ConversationStatus.COMPLETED ? 'SUCCESS' : 'FAILED'}`);
+                console.log(`  Iterations: ${result.iterationsUsed}`);
+                console.log(`  Output length: ${result.output.length} chars`);
+                console.log(`  Output (first 500 chars):\n${result.output.slice(0, 500)}...\n`);
+                conv.dispose();
+                console.log(`[business-analyst] Task ${taskId} completed successfully\n`);
+                return {
+                    success: true,
+                    summary: `Analyzed requirement: ${requirementId || 'unknown'}. ${result.output.slice(0, 200)}...`,
+                    knowledgeUpdates: []
+                };
+            }
+            catch (error) {
+                console.log(`[business-analyst] ERROR for task ${taskId}:`, error);
+                await context.taskBoard.transition(task.id, task_board_types_1.BoardTaskStatus.BLOCKED, String(error));
+                return {
+                    success: false,
+                    summary: `Failed: ${task.title}`,
+                    error: error instanceof Error ? error.message : String(error)
+                };
+            }
+        }
+    },
+    /**
+     * Product Owner Agent - Prioritize single feature
+     */
+    PRODUCT_OWNER: {
+        name: "product-owner",
+        description: "Prioritize single feature",
+        taskTypes: [task_board_types_1.TaskType.RESEARCH, task_board_types_1.TaskType.DOCS],
+        execute: async (task, context) => {
+            try {
+                // Task is already in IN_PROGRESS by orchestrator
+                const featureId = task.metadata?.featureId;
+                const featureDescription = task.metadata?.featureDescription;
+                const conv = new conversation_class_1.Conversation({
+                    llmAdapter: makeLlmAdapter(),
+                    model: MODEL,
+                    thinking: false,
+                    temperature: 0.6,
+                    tools: [],
+                    systemPrompt: `You are a product owner agent. Prioritize features based on business value.
+          
+Task: ${task.title}
+Feature ID: ${featureId || 'FEAT-001'}
+Feature Description: ${featureDescription || 'No description provided'}
+
+Provide your prioritization in this format:
+## Prioritization
+- Business Value Score: [0-10]
+- Complexity Score: [0-10]
+- ROI: [high/medium/low]
+- Priority: [critical/high/medium/low]
+- Justification: [brief explanation]
+
+Be decisive and provide clear prioritization.`,
+                    loadModelsOnInit: false,
+                    runPreflightOnInit: false,
+                    maxIterationsPerRun: 6,
+                    stallDetection: "tool",
+                });
+                const prompt = `Prioritize this feature: ${featureId || 'FEAT-001'}
+
+${featureDescription || 'No description provided'}
+
+Provide your prioritization following the format above.`;
+                const result = await conv.sendPrompt(prompt, { signal: AbortSignal.timeout(120_000) });
+                conv.dispose();
+                return {
+                    success: true,
+                    summary: `Prioritized feature: ${featureId || 'unknown'}. ${result.output.slice(0, 200)}...`,
+                    knowledgeUpdates: []
+                };
+            }
+            catch (error) {
+                await context.taskBoard.transition(task.id, task_board_types_1.BoardTaskStatus.BLOCKED, String(error));
+                return {
+                    success: false,
+                    summary: `Failed: ${task.title}`,
+                    error: error instanceof Error ? error.message : String(error)
+                };
+            }
+        }
+    },
+    /**
+     * Architect Agent - Design single component
+     */
+    ARCHITECT: {
+        name: "architect",
+        description: "Design single component",
+        taskTypes: [task_board_types_1.TaskType.RESEARCH, task_board_types_1.TaskType.DOCS],
+        execute: async (task, context) => {
+            try {
+                // Task is already in IN_PROGRESS by orchestrator
+                const componentId = task.metadata?.componentId;
+                const componentRequirements = task.metadata?.componentRequirements;
+                const conv = new conversation_class_1.Conversation({
+                    llmAdapter: makeLlmAdapter(),
+                    model: MODEL,
+                    thinking: false,
+                    temperature: 0.6,
+                    tools: [],
+                    systemPrompt: `You are an architect agent. Design software components with clear specifications.
+          
+Task: ${task.title}
+Component ID: ${componentId || 'COMP-001'}
+Requirements: ${componentRequirements || 'No requirements provided'}
+
+Provide your architecture design in this format:
+## Architecture Design
+- Component Name: ${componentId || 'Component'}
+- Purpose: [brief description]
+- Key Components: [list sub-components]
+- Technology Stack: [recommended tech]
+- API Contract: [brief API description]
+- Data Model: [brief data model]
+- Non-functional Requirements: [performance, scalability, etc.]
+
+Be specific and actionable.`,
+                    loadModelsOnInit: false,
+                    runPreflightOnInit: false,
+                    maxIterationsPerRun: 6,
+                    stallDetection: "tool",
+                });
+                const prompt = `Design this component: ${componentId || 'COMP-001'}
+
+Requirements:
+${componentRequirements || 'No requirements provided'}
+
+Provide your architecture design following the format above.`;
+                const result = await conv.sendPrompt(prompt, { signal: AbortSignal.timeout(120_000) });
+                conv.dispose();
+                return {
+                    success: true,
+                    summary: `Designed component: ${componentId || 'unknown'}. ${result.output.slice(0, 200)}...`,
+                    knowledgeUpdates: []
+                };
+            }
+            catch (error) {
+                await context.taskBoard.transition(task.id, task_board_types_1.BoardTaskStatus.BLOCKED, String(error));
+                return {
+                    success: false,
+                    summary: `Failed: ${task.title}`,
+                    error: error instanceof Error ? error.message : String(error)
+                };
+            }
+        }
+    }
+};
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Tactical Agents - Workflow coordination
+ * Focus: Task orchestration, workflow management, quality gates
+ */
+exports.TACTICAL_AGENTS = {
+    /**
+     * Workflow Orchestrator Agent - Route single task
+     */
+    WORKFLOW_ORCHESTRATOR: {
+        name: "workflow-orchestrator",
+        description: "Route single task",
+        taskTypes: [task_board_types_1.TaskType.RESEARCH, task_board_types_1.TaskType.DOCS],
+        execute: async (task, context) => {
+            try {
+                // Task is already in IN_PROGRESS by orchestrator
+                const conv = new conversation_class_1.Conversation({
+                    llmAdapter: makeLlmAdapter(),
+                    model: MODEL,
+                    thinking: false,
+                    temperature: 0.6,
+                    tools: [],
+                    systemPrompt: `You are a workflow orchestrator agent. Route tasks and map dependencies.
+          
+Task: ${task.title}
+
+Provide your routing decision in this format:
+## Routing Decision
+- Task Type: [feature/bugfix/test/docs]
+- Dependencies: [list task IDs this depends on]
+- Execution Order: [1, 2, 3...]
+- Required Agents: [list agent names]
+- Estimated Complexity: [high/medium/low]
+- Blocking Issues: [list any blockers]
+
+Be decisive about routing.`,
+                    loadModelsOnInit: false,
+                    runPreflightOnInit: false,
+                    maxIterationsPerRun: 6,
+                    stallDetection: "tool",
+                });
+                const prompt = `Route this task: ${task.title}
+
+Context: ${task.description || 'No context provided'}
+
+Provide your routing decision following the format above.`;
+                const result = await conv.sendPrompt(prompt, { signal: AbortSignal.timeout(120_000) });
+                conv.dispose();
+                return {
+                    success: true,
+                    summary: `Routed task: ${task.title}. ${result.output.slice(0, 200)}...`,
+                    knowledgeUpdates: []
+                };
+            }
+            catch (error) {
+                await context.taskBoard.transition(task.id, task_board_types_1.BoardTaskStatus.BLOCKED, String(error));
+                return {
+                    success: false,
+                    summary: `Failed: ${task.title}`,
+                    error: error instanceof Error ? error.message : String(error)
+                };
+            }
+        }
+    },
+    /**
+     * Code Review Agent - Review single file
+     */
+    CODE_REVIEWER: {
+        name: "code-reviewer",
+        description: "Review single file",
+        taskTypes: [task_board_types_1.TaskType.RESEARCH, task_board_types_1.TaskType.DOCS],
+        execute: async (task, context) => {
+            try {
+                // Task is already in IN_PROGRESS by orchestrator
+                const filePath = task.metadata?.filePath;
+                const conv = new conversation_class_1.Conversation({
+                    llmAdapter: makeLlmAdapter(),
+                    model: MODEL,
+                    thinking: false,
+                    temperature: 0.6,
+                    tools: [new workspace_1.ReadFileTool(PROJECT_ROOT)],
+                    systemPrompt: `You are a code review agent. Review TypeScript files for bugs, style issues, and improvements.
+          
+Task: ${task.title}
+File to review: ${filePath || 'unknown'}
+
+Provide your code review in this format:
+## Code Review Report
+
+### Issues Found
+1. [SEVERITY] Description - Location: Line X
+
+### Fixes Applied
+1. Description of fix - File: ${filePath || 'unknown'}
+
+### Verification
+- [✓/✗] Fix verified
+
+### Summary
+- Total issues: X
+- Fixed: Y
+- Remaining: Z
+
+Be thorough and identify all issues.`,
+                    loadModelsOnInit: false,
+                    runPreflightOnInit: false,
+                    maxIterationsPerRun: 6,
+                    stallDetection: "tool",
+                });
+                const prompt = `Review this file: ${filePath || 'unknown'}
+
+${filePath ? `File path: ${filePath}` : 'No file path provided'}
+
+Provide your code review following the format above.`;
+                const result = await conv.sendPrompt(prompt, { signal: AbortSignal.timeout(120_000) });
+                conv.dispose();
+                return {
+                    success: true,
+                    summary: `Reviewed ${filePath || 'unknown'}. ${result.output.slice(0, 200)}...`,
+                    knowledgeUpdates: []
+                };
+            }
+            catch (error) {
+                await context.taskBoard.transition(task.id, task_board_types_1.BoardTaskStatus.BLOCKED, String(error));
+                return {
+                    success: false,
+                    summary: `Failed: ${task.title}`,
+                    error: error instanceof Error ? error.message : String(error)
+                };
+            }
+        }
+    },
+    /**
+     * Testing Agent - Run single test
+     */
+    TESTER: {
+        name: "tester",
+        description: "Run single test",
+        taskTypes: [task_board_types_1.TaskType.TEST],
+        execute: async (task, context) => {
+            try {
+                // Task is already in IN_PROGRESS by orchestrator
+                const command = task.metadata?.command;
+                const conv = new conversation_class_1.Conversation({
+                    llmAdapter: makeLlmAdapter(),
+                    model: MODEL,
+                    thinking: false,
+                    temperature: 0.6,
+                    tools: [],
+                    systemPrompt: `You are a testing agent. Run tests and report results.
+          
+Task: ${task.title}
+Test Command: ${command || 'npm test'}
+
+Provide your test results in this format:
+## Test Results
+
+### Summary
+- Total tests: X
+- Passed: X
+- Failed: X
+- Skipped: X
+
+### Details
+1. [PASS/FAIL] Test name - Duration: Xms
+
+### Coverage
+- Statement coverage: X%
+- Branch coverage: X%
+
+### Issues
+- [list any test failures or issues]
+
+Be accurate in reporting results.`,
+                    loadModelsOnInit: false,
+                    runPreflightOnInit: false,
+                    maxIterationsPerRun: 6,
+                    stallDetection: "tool",
+                });
+                const prompt = `Run tests with this command: ${command || 'npm test'}
+
+Provide your test results following the format above.`;
+                const result = await conv.sendPrompt(prompt, { signal: AbortSignal.timeout(120_000) });
+                conv.dispose();
+                return {
+                    success: true,
+                    summary: `Ran test: ${command || 'unknown'}. ${result.output.slice(0, 200)}...`,
+                    knowledgeUpdates: []
+                };
+            }
+            catch (error) {
+                await context.taskBoard.transition(task.id, task_board_types_1.BoardTaskStatus.BLOCKED, String(error));
+                return {
+                    success: false,
+                    summary: `Failed: ${task.title}`,
+                    error: error instanceof Error ? error.message : String(error)
+                };
+            }
+        }
+    },
+    /**
+     * Security Agent - Audit single file
+     */
+    SECURITY_AUDITOR: {
+        name: "security-auditor",
+        description: "Audit single file",
+        taskTypes: [task_board_types_1.TaskType.RESEARCH, task_board_types_1.TaskType.DOCS],
+        execute: async (task, context) => {
+            try {
+                // Task is already in IN_PROGRESS by orchestrator
+                const filePath = task.metadata?.filePath;
+                const conv = new conversation_class_1.Conversation({
+                    llmAdapter: makeLlmAdapter(),
+                    model: MODEL,
+                    thinking: false,
+                    temperature: 0.6,
+                    tools: [new workspace_1.ReadFileTool(PROJECT_ROOT)],
+                    systemPrompt: `You are a security auditor agent. Audit code for security vulnerabilities.
+          
+Task: ${task.title}
+File to audit: ${filePath || 'unknown'}
+
+Provide your security audit in this format:
+## Security Audit Report
+
+### Vulnerabilities Found
+1. [SEVERITY] Vulnerability name - Location: Line X
+   - Description: [detailed description]
+   - Remediation: [how to fix]
+
+### Code Quality Issues
+1. [SEVERITY] Issue name - Location: Line X
+
+### Security Best Practices
+- [list any best practice violations]
+
+### Overall Assessment
+- Risk Level: [critical/high/medium/low]
+- Immediate Action Required: [yes/no]
+
+Be thorough in identifying security issues.`,
+                    loadModelsOnInit: false,
+                    runPreflightOnInit: false,
+                    maxIterationsPerRun: 6,
+                    stallDetection: "tool",
+                });
+                const prompt = `Audit this file for security issues: ${filePath || 'unknown'}
+
+${filePath ? `File path: ${filePath}` : 'No file path provided'}
+
+Provide your security audit following the format above.`;
+                const result = await conv.sendPrompt(prompt, { signal: AbortSignal.timeout(120_000) });
+                conv.dispose();
+                return {
+                    success: true,
+                    summary: `Audited ${filePath || 'unknown'}. ${result.output.slice(0, 200)}...`,
+                    knowledgeUpdates: []
+                };
+            }
+            catch (error) {
+                await context.taskBoard.transition(task.id, task_board_types_1.BoardTaskStatus.BLOCKED, String(error));
+                return {
+                    success: false,
+                    summary: `Failed: ${task.title}`,
+                    error: error instanceof Error ? error.message : String(error)
+                };
+            }
+        }
+    }
+};
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Operational Agents - Code execution
+ * Focus: Code generation, file operations, tool usage
+ */
+exports.OPERATIONAL_AGENTS = {
+    /**
+     * Developer Agent - Write single file
+     */
+    DEVELOPER: {
+        name: "developer",
+        description: "Write single file",
+        taskTypes: [task_board_types_1.TaskType.FEATURE, task_board_types_1.TaskType.BUGFIX, task_board_types_1.TaskType.REFACTOR],
+        execute: async (task, context) => {
+            try {
+                // Task is already in IN_PROGRESS by orchestrator
+                const filePath = task.metadata?.filePath;
+                const fileContent = task.metadata?.content;
+                const generationRequirements = task.metadata?.generationRequirements;
+                const conv = new conversation_class_1.Conversation({
+                    llmAdapter: makeLlmAdapter(),
+                    model: MODEL,
+                    thinking: false,
+                    temperature: 0.7,
+                    tools: [new workspace_1.WriteFileTool(PROJECT_ROOT)],
+                    systemPrompt: `You are a developer agent. Generate TypeScript code based on requirements.
+          
+Task: ${task.title}
+File to create: ${filePath || 'unknown'}
+Requirements: ${generationRequirements || 'No requirements provided'}
+
+Generate code that:
+- Follows TypeScript best practices
+- Includes proper type annotations
+- Has clear naming conventions
+- Includes necessary comments
+- Handles errors appropriately
+
+Provide your generated code in this format:
+## Generated Code
+\`\`\`typescript
+// Your TypeScript code here
+\`\`\`
+
+## Code Summary
+- Purpose: [brief description]
+- Key Functions: [list functions]
+- Dependencies: [list dependencies]
+- Testing Notes: [how to test]
+
+Be creative and generate high-quality code.`,
+                    loadModelsOnInit: false,
+                    runPreflightOnInit: false,
+                    maxIterationsPerRun: 6,
+                    stallDetection: "tool",
+                });
+                const prompt = `Generate code for this file: ${filePath || 'unknown'}
+
+Requirements:
+${generationRequirements || 'No requirements provided'}
+
+Provide your generated code following the format above.`;
+                const result = await conv.sendPrompt(prompt, { signal: AbortSignal.timeout(120_000) });
+                conv.dispose();
+                return {
+                    success: true,
+                    summary: `Generated ${filePath || 'unknown'} (${result.output.length} chars). ${result.output.slice(0, 200)}...`,
+                    changedFiles: [filePath || 'unknown'],
+                    knowledgeUpdates: []
+                };
+            }
+            catch (error) {
+                await context.taskBoard.transition(task.id, task_board_types_1.BoardTaskStatus.BLOCKED, String(error));
+                return {
+                    success: false,
+                    summary: `Failed: ${task.title}`,
+                    error: error instanceof Error ? error.message : String(error)
+                };
+            }
+        }
+    },
+    /**
+     * Research Agent - Read single file
+     */
+    RESEARCHER: {
+        name: "researcher",
+        description: "Read single file",
+        taskTypes: [task_board_types_1.TaskType.RESEARCH, task_board_types_1.TaskType.DOCS],
+        execute: async (task, context) => {
+            try {
+                // Task is already in IN_PROGRESS by orchestrator
+                const filePath = task.metadata?.filePath;
+                const conv = new conversation_class_1.Conversation({
+                    llmAdapter: makeLlmAdapter(),
+                    model: MODEL,
+                    thinking: false,
+                    temperature: 0.6,
+                    tools: [new workspace_1.ReadFileTool(PROJECT_ROOT)],
+                    systemPrompt: `You are a research agent. Analyze code files and extract key information.
+          
+Task: ${task.title}
+File to research: ${filePath || 'unknown'}
+
+Provide your research findings in this format:
+## Research Findings
+
+### File Overview
+- File Name: ${filePath || 'unknown'}
+- Purpose: [brief description]
+- Size: [lines of code]
+- Complexity: [high/medium/low]
+
+### Key Functions/Classes
+1. [Name] - Purpose: [brief description], Complexity: [low/medium/high]
+
+### Dependencies
+- Imports: [list key imports]
+- Exports: [list key exports]
+
+### Code Quality
+- Type Safety: [high/medium/low]
+- Documentation: [high/medium/low]
+- Test Coverage: [high/medium/low]
+
+### Recommendations
+- [list any recommendations for improvement]
+
+Be thorough in your analysis.`,
+                    loadModelsOnInit: false,
+                    runPreflightOnInit: false,
+                    maxIterationsPerRun: 6,
+                    stallDetection: "tool",
+                });
+                const prompt = `Research this file: ${filePath || 'unknown'}
+
+${filePath ? `File path: ${filePath}` : 'No file path provided'}
+
+Provide your research findings following the format above.`;
+                const result = await conv.sendPrompt(prompt, { signal: AbortSignal.timeout(120_000) });
+                conv.dispose();
+                return {
+                    success: true,
+                    summary: `Researched ${filePath || 'unknown'}. ${result.output.slice(0, 200)}...`,
+                    knowledgeUpdates: []
+                };
+            }
+            catch (error) {
+                await context.taskBoard.transition(task.id, task_board_types_1.BoardTaskStatus.BLOCKED, String(error));
+                return {
+                    success: false,
+                    summary: `Failed: ${task.title}`,
+                    error: error instanceof Error ? error.message : String(error)
+                };
+            }
+        }
+    },
+    /**
+     * DevOps Agent - Run single command
+     */
+    DEVOPS: {
+        name: "devops",
+        description: "Run single command",
+        taskTypes: [task_board_types_1.TaskType.RESEARCH, task_board_types_1.TaskType.DOCS],
+        execute: async (task, context) => {
+            try {
+                // Task is already in IN_PROGRESS by orchestrator
+                const command = task.metadata?.command;
+                const conv = new conversation_class_1.Conversation({
+                    llmAdapter: makeLlmAdapter(),
+                    model: MODEL,
+                    thinking: false,
+                    temperature: 0.6,
+                    tools: [],
+                    systemPrompt: `You are a DevOps agent. Execute commands and report results.
+          
+Task: ${task.title}
+Command to execute: ${command || 'unknown'}
+
+Provide your execution results in this format:
+## Command Execution Results
+
+### Command
+${command || 'unknown'}
+
+### Output
+[command output]
+
+### Status
+- Exit Code: 0
+- Success: true/false
+- Duration: Xms
+
+### Analysis
+- [brief analysis of results]
+- [any issues or warnings]
+
+### Recommendations
+- [list any recommendations]
+
+Be accurate in reporting command results.`,
+                    loadModelsOnInit: false,
+                    runPreflightOnInit: false,
+                    maxIterationsPerRun: 6,
+                    stallDetection: "tool",
+                });
+                const prompt = `Execute this command: ${command || 'unknown'}
+
+Provide your execution results following the format above.`;
+                const result = await conv.sendPrompt(prompt, { signal: AbortSignal.timeout(120_000) });
+                conv.dispose();
+                return {
+                    success: true,
+                    summary: `Executed: ${command || 'unknown'}. ${result.output.slice(0, 200)}...`,
+                    knowledgeUpdates: []
+                };
+            }
+            catch (error) {
+                await context.taskBoard.transition(task.id, task_board_types_1.BoardTaskStatus.BLOCKED, String(error));
+                return {
+                    success: false,
+                    summary: `Failed: ${task.title}`,
+                    error: error instanceof Error ? error.message : String(error)
+                };
+            }
+        }
+    },
+    /**
+     * Data Agent - Execute single data operation
+     */
+    DATA_ENGINEER: {
+        name: "data-engineer",
+        description: "Execute single data operation",
+        taskTypes: [task_board_types_1.TaskType.RESEARCH, task_board_types_1.TaskType.DOCS],
+        execute: async (task, context) => {
+            try {
+                // Task is already in IN_PROGRESS by orchestrator
+                const operation = task.metadata?.operation;
+                const conv = new conversation_class_1.Conversation({
+                    llmAdapter: makeLlmAdapter(),
+                    model: MODEL,
+                    thinking: false,
+                    temperature: 0.6,
+                    tools: [],
+                    systemPrompt: `You are a data engineering agent. Execute data operations and report results.
+          
+Task: ${task.title}
+Operation: ${operation || 'unknown'}
+
+Provide your data operation results in this format:
+## Data Operation Results
+
+### Operation Details
+- Operation Type: ${operation || 'unknown'}
+- Input Source: [describe input]
+- Output Destination: [describe output]
+
+### Execution Summary
+- Records Processed: X
+- Success Rate: X%
+- Duration: Xms
+
+### Data Quality
+- Valid Records: X
+- Invalid Records: X
+- Duplicates Removed: X
+
+### Issues
+- [list any data quality issues or errors]
+
+### Recommendations
+- [list any recommendations for improvement]
+
+Be thorough in reporting data operation results.`,
+                    loadModelsOnInit: false,
+                    runPreflightOnInit: false,
+                    maxIterationsPerRun: 6,
+                    stallDetection: "tool",
+                });
+                const prompt = `Execute this data operation: ${operation || 'unknown'}
+
+Provide your results following the format above.`;
+                const result = await conv.sendPrompt(prompt, { signal: AbortSignal.timeout(120_000) });
+                conv.dispose();
+                return {
+                    success: true,
+                    summary: `Executed: ${operation || 'unknown'}. ${result.output.slice(0, 200)}...`,
+                    knowledgeUpdates: []
+                };
+            }
+            catch (error) {
+                await context.taskBoard.transition(task.id, task_board_types_1.BoardTaskStatus.BLOCKED, String(error));
+                return {
+                    success: false,
+                    summary: `Failed: ${task.title}`,
+                    error: error instanceof Error ? error.message : String(error)
+                };
+            }
+        }
+    },
+    /**
+     * Verification Agent - Verify project quality and completeness
+     */
+    VERIFICATION_AGENT: {
+        name: "verification-agent",
+        description: "Verify project quality and completeness",
+        taskTypes: [task_board_types_1.TaskType.RESEARCH, task_board_types_1.TaskType.TEST],
+        execute: async (task, context) => {
+            try {
+                // Task is already in IN_PROGRESS by orchestrator
+                const verificationType = task.metadata?.verificationType;
+                const projectPath = task.metadata?.projectPath;
+                const conv = new conversation_class_1.Conversation({
+                    llmAdapter: makeLlmAdapter(),
+                    model: MODEL,
+                    thinking: false,
+                    temperature: 0.6,
+                    tools: [new workspace_1.ReadFileTool(PROJECT_ROOT)],
+                    systemPrompt: `You are a verification agent. Verify project quality, completeness, and positive outcomes.
+          
+Task: ${task.title}
+Verification Type: ${verificationType || 'comprehensive'}
+Project Path: ${projectPath || '.'}
+
+Provide your verification report in this format:
+## Verification Report
+
+### Verification Type: ${verificationType || 'comprehensive'}
+
+### Files Verified
+1. [✓/✗] File name - Status: present/missing
+
+### Quality Checks
+1. [✓/✗] Check name - Result: passed/failed
+
+### Positive Outcome Indicators
+1. [✓/✗] Indicator name - Status: met/unmet
+
+### Overall Assessment
+- Project Quality: [excellent/good/fair/poor]
+- Completeness: [complete/incomplete]
+- Positive Outcome: [yes/no]
+- Recommendation: [approve/reject/revise]
+
+### Detailed Findings
+[any specific issues or positive findings]
+
+Be thorough in your verification and provide honest assessment.`,
+                    loadModelsOnInit: false,
+                    runPreflightOnInit: false,
+                    maxIterationsPerRun: 6,
+                    stallDetection: "tool",
+                });
+                const prompt = `Verify this project: ${projectPath || '.'}
+
+Verification Type: ${verificationType || 'comprehensive'}
+
+Provide your verification report following the format above.`;
+                const result = await conv.sendPrompt(prompt, { signal: AbortSignal.timeout(120_000) });
+                conv.dispose();
+                const isPositive = result.output.toLowerCase().includes('positive outcome: [yes]') ||
+                    result.output.toLowerCase().includes('recommendation: [approve]');
+                return {
+                    success: true,
+                    summary: `Verified project: ${projectPath || '.'}. Positive: ${isPositive}. ${result.output.slice(0, 200)}...`,
+                    knowledgeUpdates: []
+                };
+            }
+            catch (error) {
+                await context.taskBoard.transition(task.id, task_board_types_1.BoardTaskStatus.BLOCKED, String(error));
+                return {
+                    success: false,
+                    summary: `Failed: ${task.title}`,
+                    error: error instanceof Error ? error.message : String(error)
+                };
+            }
+        }
+    }
+};
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Agent Registry - Combined agent profiles
+ */
+exports.AGENT_REGISTRY = [
+    ...Object.values(exports.STRATEGIC_AGENTS),
+    ...Object.values(exports.TACTICAL_AGENTS),
+    ...Object.values(exports.OPERATIONAL_AGENTS),
+    exports.OPERATIONAL_AGENTS.VERIFICATION_AGENT
+];
+/**
+ * Get agent by name
+ */
+function getAgentByName(name) {
+    return exports.AGENT_REGISTRY.find(agent => agent.name === name);
+}
+/**
+ * Get agents by task type
+ */
+function getAgentsByTaskType(taskType) {
+    return exports.AGENT_REGISTRY.filter(agent => agent.taskTypes.includes(taskType));
+}
+// ─────────────────────────────────────────────────────────────────────────────
+//# sourceMappingURL=thoughtflow-agent-hierarchy.js.map