@sashabogi/foundation 0.1.0

package/dist/tools/seldon/index.js

@@ -0,0 +1,886 @@
+/**
+ * Seldon Module Tools
+ *
+ * Multi-agent orchestration with 13+ providers.
+ * Named after Hari Seldon - the mathematician who created psychohistory
+ * to predict and guide humanity's future through the Seldon Plan.
+ *
+ * Tools:
+ *
+ * Agent Invocation:
+ * - seldon_invoke: Invoke a single agent by role
+ * - seldon_compare: Run same task through multiple agents
+ * - seldon_critique: Get adversarial plan critique
+ * - seldon_review: Get code review feedback
+ * - seldon_design: Get UI/UX design feedback
+ *
+ * Planning:
+ * - seldon_plan: Generate a detailed implementation plan
+ * - seldon_phase_create: Create execution phases from intent
+ * - seldon_phase_list: List phases and their status
+ *
+ * Verification (The Loop):
+ * - seldon_verify: Verify implementation against plan
+ * - seldon_fix: Generate fixes for verification issues
+ * - seldon_execute_verified: Execute with verification loop (YOLO mode)
+ * - seldon_execute_parallel: Execute multiple phases in parallel
+ *
+ * Pipeline:
+ * - seldon_pipeline_create: Create multi-step DAG workflow
+ * - seldon_pipeline_execute: Execute a pipeline
+ * - seldon_pipeline_status: Get pipeline execution status
+ *
+ * Task Management:
+ * - seldon_task_execute: Execute task in isolated worktree
+ * - seldon_task_claim: Claim next available task
+ *
+ * Providers:
+ * - seldon_providers_list: List available providers
+ * - seldon_providers_test: Test provider connectivity
+ */
+import { z } from 'zod';
+import { nanoid } from 'nanoid';
+import { ProviderService } from '../../services/provider.service.js';
+import { StorageService } from '../../services/storage.service.js';
+import { GitService } from '../../services/git.service.js';
+// =============================================================================
+// Schemas
+// =============================================================================
+const AgentRoleSchema = z.enum([
+    'orchestrator',
+    'coder',
+    'critic',
+    'reviewer',
+    'designer',
+    'researcher',
+    'verifier', // New role for verification
+]);
+const IssueSeveritySchema = z.enum(['critical', 'major', 'minor']);
+const VerificationCategorySchema = z.enum([
+    'missing_implementation',
+    'incorrect_implementation',
+    'regression',
+    'type_error',
+    'logic_error',
+    'security',
+    'performance',
+    'style',
+    'test_failure',
+    'other',
+]);
+// =============================================================================
+// In-memory state for phases and plans (will be moved to StorageService)
+// =============================================================================
+const phases = new Map();
+const plans = new Map();
+const verificationResults = new Map();
+// =============================================================================
+// Tool Registration
+// =============================================================================
+export function registerSeldonTools(server) {
+    const providers = ProviderService.getInstance();
+    const storage = StorageService.getInstance();
+    const git = GitService.getInstance();
+    // ===========================================================================
+    // Agent Invocation Tools
+    // ===========================================================================
+    // seldon_invoke
+    server.tool('seldon_invoke', 'Invoke a specialized AI agent by role. Routes to configured provider with automatic failover.', {
+        role: AgentRoleSchema.describe('Agent role to invoke'),
+        task: z.string().describe('Task description for the agent'),
+        context: z.string().optional().describe('Additional context for the agent'),
+    }, async ({ role, task, context }) => {
+        const result = await providers.invoke({ role, task, context });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: result.success
+                        ? `**${role}** (${result.provider}/${result.model}):\n\n${result.output}`
+                        : `Error: ${result.error}`,
+                },
+            ],
+        };
+    });
+    // seldon_compare
+    server.tool('seldon_compare', 'Run the same task through multiple agents and compare their responses.', {
+        roles: z.array(AgentRoleSchema).describe('Agent roles to compare'),
+        task: z.string().describe('Task to send to all agents'),
+        context: z.string().optional().describe('Additional context'),
+    }, async ({ roles, task, context }) => {
+        const results = await Promise.all(roles.map((role) => providers.invoke({ role, task, context })));
+        const output = results
+            .map((r, i) => `## ${roles[i]} (${r.provider})\n\n${r.success ? r.output : `Error: ${r.error}`}`)
+            .join('\n\n---\n\n');
+        return {
+            content: [{ type: 'text', text: output }],
+        };
+    });
+    // seldon_critique
+    server.tool('seldon_critique', 'Get adversarial critique on a plan, PRD, or architecture from the critic role.', {
+        content: z.string().describe('Plan or document to critique'),
+        focus: z.string().optional().describe('Specific areas to focus critique on'),
+    }, async ({ content, focus }) => {
+        const task = focus
+            ? `Critique this plan, focusing on: ${focus}\n\n${content}`
+            : `Critique this plan thoroughly:\n\n${content}`;
+        const result = await providers.invoke({ role: 'critic', task });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: result.success ? result.output : `Error: ${result.error}`,
+                },
+            ],
+        };
+    });
+    // seldon_review
+    server.tool('seldon_review', 'Get code review feedback from the reviewer role.', {
+        code: z.string().describe('Code to review'),
+        context: z.string().optional().describe('Context about the code (purpose, language, etc.)'),
+        focus: z.array(z.string()).optional().describe('Areas to focus on (e.g., ["security", "performance"])'),
+    }, async ({ code, context, focus }) => {
+        let task = `Review this code:\n\n\`\`\`\n${code}\n\`\`\``;
+        if (context)
+            task += `\n\nContext: ${context}`;
+        if (focus?.length)
+            task += `\n\nFocus areas: ${focus.join(', ')}`;
+        const result = await providers.invoke({ role: 'reviewer', task });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: result.success ? result.output : `Error: ${result.error}`,
+                },
+            ],
+        };
+    });
+    // seldon_design
+    server.tool('seldon_design', 'Get UI/UX design feedback from the designer role.', {
+        description: z.string().describe('Description of the design or component'),
+        context: z.string().optional().describe('Additional context (target users, platform, etc.)'),
+    }, async ({ description, context }) => {
+        let task = `Provide UI/UX feedback on:\n\n${description}`;
+        if (context)
+            task += `\n\nContext: ${context}`;
+        const result = await providers.invoke({ role: 'designer', task });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: result.success ? result.output : `Error: ${result.error}`,
+                },
+            ],
+        };
+    });
+    // ===========================================================================
+    // Planning Tools
+    // ===========================================================================
+    // seldon_plan
+    server.tool('seldon_plan', 'Generate a detailed implementation plan from an intent. Creates file-level instructions.', {
+        intent: z.string().describe('What you want to accomplish'),
+        context: z.string().optional().describe('Additional context (existing code, constraints, etc.)'),
+        phaseId: z.string().optional().describe('Associate with a phase'),
+    }, async ({ intent, context, phaseId }) => {
+        const planPrompt = `You are a senior software architect. Create a detailed implementation plan for the following intent.
+
+INTENT: ${intent}
+
+${context ? `CONTEXT:\n${context}\n` : ''}
+
+Respond with a structured plan in the following format:
+
+## Overview
+[Brief description of what will be implemented]
+
+## Files to Modify/Create
+
+### [file path]
+- **Action**: create | modify | delete
+- **Description**: [what this file does]
+- **Details**:
+  - [specific implementation detail 1]
+  - [specific implementation detail 2]
+  - ...
+
+### [next file...]
+
+## Acceptance Criteria
+1. [criterion 1]
+2. [criterion 2]
+...
+
+## Dependencies
+- [any dependencies between files or external packages]
+
+## Risks/Considerations
+- [potential issues to watch for]`;
+        const result = await providers.invoke({
+            role: 'orchestrator',
+            task: planPrompt,
+        });
+        if (!result.success) {
+            return {
+                content: [{ type: 'text', text: `Error generating plan: ${result.error}` }],
+            };
+        }
+        // Create plan object
+        const plan = {
+            id: `plan_${nanoid(8)}`,
+            phaseId: phaseId || `phase_${nanoid(8)}`,
+            intent,
+            description: result.output,
+            files: [], // Would be parsed from output in real implementation
+            acceptanceCriteria: [], // Would be parsed from output
+            generatedAt: Date.now(),
+            generatedBy: result.provider,
+        };
+        plans.set(plan.id, plan);
+        // Update phase if provided
+        if (phaseId && phases.has(phaseId)) {
+            const phase = phases.get(phaseId);
+            phase.planId = plan.id;
+            phase.status = 'ready';
+            phases.set(phaseId, phase);
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `# Plan ${plan.id}\n\n${result.output}\n\n---\n*Generated by ${result.provider}*`,
+                },
+            ],
+        };
+    });
+    // seldon_phase_create
+    server.tool('seldon_phase_create', 'Create execution phases from a high-level intent. Breaks work into manageable chunks.', {
+        intent: z.string().describe('High-level description of what to build'),
+        numPhases: z.number().optional().describe('Suggested number of phases (default: auto)'),
+    }, async ({ intent, numPhases }) => {
+        const phasePrompt = `You are a senior software architect. Break down the following project intent into sequential execution phases.
+
+INTENT: ${intent}
+
+${numPhases ? `Target approximately ${numPhases} phases.` : 'Determine the appropriate number of phases based on complexity.'}
+
+Each phase should be:
+- Self-contained and independently verifiable
+- Buildable incrementally on previous phases
+- Clear in scope and acceptance criteria
+
+Respond with phases in this format:
+
+## Phase 1: [Name]
+**Description**: [What this phase accomplishes]
+**Depends On**: [None or previous phase numbers]
+**Acceptance Criteria**:
+- [criterion 1]
+- [criterion 2]
+
+## Phase 2: [Name]
+...`;
+        const result = await providers.invoke({
+            role: 'orchestrator',
+            task: phasePrompt,
+        });
+        if (!result.success) {
+            return {
+                content: [{ type: 'text', text: `Error creating phases: ${result.error}` }],
+            };
+        }
+        // Parse phases from output (simplified - would use regex in real implementation)
+        const phaseMatches = result.output.match(/## Phase \d+:/g) || [];
+        const createdPhases = [];
+        for (let i = 0; i < phaseMatches.length; i++) {
+            const phase = {
+                id: `phase_${nanoid(8)}`,
+                name: `Phase ${i + 1}`,
+                description: '', // Would be parsed
+                order: i + 1,
+                status: 'pending',
+                dependsOn: i > 0 ? [createdPhases[i - 1].id] : undefined,
+                createdAt: Date.now(),
+            };
+            phases.set(phase.id, phase);
+            createdPhases.push(phase);
+        }
+        let output = `# Created ${createdPhases.length} Phases\n\n`;
+        output += createdPhases.map(p => `- **${p.id}**: ${p.name} (${p.status})`).join('\n');
+        output += `\n\n---\n\n${result.output}`;
+        return {
+            content: [{ type: 'text', text: output }],
+        };
+    });
+    // seldon_phase_list
+    server.tool('seldon_phase_list', 'List all phases and their current status.', {}, async () => {
+        if (phases.size === 0) {
+            return {
+                content: [{ type: 'text', text: 'No phases created. Use `seldon_phase_create` to create phases.' }],
+            };
+        }
+        const sortedPhases = Array.from(phases.values()).sort((a, b) => a.order - b.order);
+        const statusEmoji = {
+            pending: '⏳',
+            planning: '📝',
+            ready: '✅',
+            executing: '🔨',
+            verifying: '🔍',
+            fixing: '🔧',
+            passed: '✓',
+            failed: '✗',
+            blocked: '🚫',
+            cancelled: '⊘',
+        };
+        let output = '# Phases\n\n';
+        output += '| # | ID | Name | Status | Plan |\n';
+        output += '|---|-----|------|--------|------|\n';
+        for (const phase of sortedPhases) {
+            const emoji = statusEmoji[phase.status] || '?';
+            output += `| ${phase.order} | ${phase.id} | ${phase.name} | ${emoji} ${phase.status} | ${phase.planId || '-'} |\n`;
+        }
+        return {
+            content: [{ type: 'text', text: output }],
+        };
+    });
+    // ===========================================================================
+    // Verification Tools (The Loop)
+    // ===========================================================================
+    // seldon_verify
+    server.tool('seldon_verify', 'Verify implementation against a plan. Returns issues categorized by severity (critical/major/minor).', {
+        planId: z.string().describe('Plan ID to verify against'),
+        files: z.array(z.string()).optional().describe('Specific files to check (default: all plan files)'),
+        runTests: z.boolean().optional().describe('Run test suite as part of verification (default: true)'),
+        testCommand: z.string().optional().describe('Custom test command (default: npm test)'),
+    }, async ({ planId, files, runTests = true, testCommand = 'npm test' }) => {
+        const plan = plans.get(planId);
+        if (!plan) {
+            return {
+                content: [{ type: 'text', text: `Plan not found: ${planId}` }],
+            };
+        }
+        const startTime = Date.now();
+        // Build verification prompt
+        const verifyPrompt = `You are a meticulous code reviewer verifying an implementation against a plan.
+
+## PLAN
+${plan.description}
+
+## ACCEPTANCE CRITERIA
+${plan.acceptanceCriteria.map((c, i) => `${i + 1}. ${c}`).join('\n') || 'See plan description'}
+
+## TASK
+Analyze the implementation and identify any issues. For each issue, provide:
+- Severity: critical (blocks core functionality), major (significant issue), or minor (polish)
+- Category: missing_implementation, incorrect_implementation, regression, type_error, logic_error, security, performance, style, test_failure, other
+- File and line number if applicable
+- Clear description of the issue
+- Suggested fix
+
+Respond in this format:
+
+## VERIFICATION RESULT
+
+### Summary
+- Critical: [count]
+- Major: [count]  
+- Minor: [count]
+- Passed: [yes/no]
+
+### Issues
+
+#### Issue 1
+- **Severity**: critical | major | minor
+- **Category**: [category]
+- **File**: [path]
+- **Line**: [number or range]
+- **Message**: [description]
+- **Suggestion**: [how to fix]
+
+#### Issue 2
+...
+
+If no issues found, respond with:
+
+## VERIFICATION RESULT
+### Summary
+- Critical: 0
+- Major: 0
+- Minor: 0
+- Passed: yes
+
+No issues found. Implementation matches plan.`;
+        const result = await providers.invoke({
+            role: 'verifier',
+            task: verifyPrompt,
+        });
+        if (!result.success) {
+            return {
+                content: [{ type: 'text', text: `Verification error: ${result.error}` }],
+            };
+        }
+        // Parse verification result (simplified)
+        const output = result.output;
+        const criticalMatch = output.match(/Critical:\s*(\d+)/i);
+        const majorMatch = output.match(/Major:\s*(\d+)/i);
+        const minorMatch = output.match(/Minor:\s*(\d+)/i);
+        const passedMatch = output.match(/Passed:\s*(yes|no)/i);
+        const critical = criticalMatch ? parseInt(criticalMatch[1]) : 0;
+        const major = majorMatch ? parseInt(majorMatch[1]) : 0;
+        const minor = minorMatch ? parseInt(minorMatch[1]) : 0;
+        const passed = passedMatch ? passedMatch[1].toLowerCase() === 'yes' : (critical === 0 && major === 0);
+        // Create verification result
+        const verificationResult = {
+            id: `ver_${nanoid(8)}`,
+            phaseId: plan.phaseId,
+            planId,
+            passed,
+            timestamp: Date.now(),
+            issues: [], // Would be parsed from output
+            summary: {
+                critical,
+                major,
+                minor,
+                total: critical + major + minor,
+            },
+            filesChecked: files || plan.files.map(f => f.path),
+            duration: Date.now() - startTime,
+        };
+        verificationResults.set(verificationResult.id, verificationResult);
+        // Update phase status
+        const phase = phases.get(plan.phaseId);
+        if (phase) {
+            phase.status = passed ? 'passed' : 'fixing';
+            phases.set(phase.id, phase);
+        }
+        const statusEmoji = passed ? '✅' : '❌';
+        let responseOutput = `# Verification ${verificationResult.id} ${statusEmoji}\n\n`;
+        responseOutput += `**Plan**: ${planId}\n`;
+        responseOutput += `**Phase**: ${plan.phaseId}\n`;
+        responseOutput += `**Duration**: ${verificationResult.duration}ms\n\n`;
+        responseOutput += result.output;
+        return {
+            content: [{ type: 'text', text: responseOutput }],
+        };
+    });
+    // seldon_fix
+    server.tool('seldon_fix', 'Generate fixes for verification issues. Returns code changes to apply.', {
+        verificationId: z.string().describe('Verification result ID'),
+        severityThreshold: IssueSeveritySchema.optional().describe('Only fix issues at or above this severity (default: major)'),
+        autoApply: z.boolean().optional().describe('Automatically apply fixes (default: false)'),
+    }, async ({ verificationId, severityThreshold = 'major', autoApply = false }) => {
+        const verification = verificationResults.get(verificationId);
+        if (!verification) {
+            return {
+                content: [{ type: 'text', text: `Verification result not found: ${verificationId}` }],
+            };
+        }
+        const plan = plans.get(verification.planId);
+        if (!plan) {
+            return {
+                content: [{ type: 'text', text: `Plan not found: ${verification.planId}` }],
+            };
+        }
+        // Filter issues by severity
+        const severityOrder = ['critical', 'major', 'minor'];
+        const thresholdIndex = severityOrder.indexOf(severityThreshold);
+        const issuesToFix = verification.issues.filter(issue => severityOrder.indexOf(issue.severity) <= thresholdIndex);
+        if (issuesToFix.length === 0) {
+            return {
+                content: [{ type: 'text', text: `No issues at or above '${severityThreshold}' severity to fix.` }],
+            };
+        }
+        // Generate fix prompt
+        const fixPrompt = `You are a senior developer fixing verification issues. For each issue, provide the exact code fix.
+
+## ORIGINAL PLAN
+${plan.description}
+
+## ISSUES TO FIX
+${issuesToFix.map((issue, i) => `
+### Issue ${i + 1}: ${issue.severity.toUpperCase()}
+- **Category**: ${issue.category}
+- **File**: ${issue.file}
+- **Line**: ${issue.line || 'N/A'}
+- **Message**: ${issue.message}
+- **Suggestion**: ${issue.suggestion || 'None provided'}
+`).join('\n')}
+
+## TASK
+For each issue, provide:
+1. The file to modify
+2. The original code (if modifying existing code)
+3. The fixed code
+4. Brief explanation
+
+Format your response as:
+
+### Fix for Issue 1
+**File**: [path]
+**Confidence**: high | medium | low
+
+\`\`\`[language]
+// ORIGINAL (lines X-Y)
+[original code]
+
+// FIXED
+[fixed code]
+\`\`\`
+
+**Explanation**: [why this fix works]
+
+### Fix for Issue 2
+...`;
+        const result = await providers.invoke({
+            role: 'coder',
+            task: fixPrompt,
+        });
+        if (!result.success) {
+            return {
+                content: [{ type: 'text', text: `Error generating fixes: ${result.error}` }],
+            };
+        }
+        // Create fix result
+        const fixes = issuesToFix.map((issue, i) => ({
+            issueId: issue.id,
+            file: issue.file,
+            originalCode: undefined, // Would be parsed
+            fixedCode: '', // Would be parsed from result
+            explanation: '', // Would be parsed
+            confidence: 'medium',
+        }));
+        let output = `# Fixes for Verification ${verificationId}\n\n`;
+        output += `**Issues Fixed**: ${issuesToFix.length}\n`;
+        output += `**Severity Threshold**: ${severityThreshold}\n`;
+        output += `**Auto-Apply**: ${autoApply}\n\n`;
+        output += result.output;
+        if (autoApply) {
+            output += `\n\n---\n⚠️ Auto-apply is enabled but not yet implemented. Fixes shown above for manual application.`;
+        }
+        return {
+            content: [{ type: 'text', text: output }],
+        };
+    });
+    // seldon_execute_verified
+    server.tool('seldon_execute_verified', 'Execute a phase with verification loop (YOLO mode). Automatically verifies and fixes until passing or max attempts.', {
+        phaseId: z.string().describe('Phase ID to execute'),
+        maxAttempts: z.number().optional().describe('Maximum verification/fix cycles (default: 3)'),
+        severityThreshold: IssueSeveritySchema.optional().describe('Stop on issues at this severity (default: major)'),
+        autoFix: z.boolean().optional().describe('Automatically apply fixes (default: true)'),
+        runTests: z.boolean().optional().describe('Run tests during verification (default: true)'),
+    }, async ({ phaseId, maxAttempts = 3, severityThreshold = 'major', autoFix = true, runTests = true }) => {
+        const phase = phases.get(phaseId);
+        if (!phase) {
+            return {
+                content: [{ type: 'text', text: `Phase not found: ${phaseId}` }],
+            };
+        }
+        if (!phase.planId) {
+            return {
+                content: [{ type: 'text', text: `Phase ${phaseId} has no plan. Use \`seldon_plan\` first.` }],
+            };
+        }
+        const plan = plans.get(phase.planId);
+        if (!plan) {
+            return {
+                content: [{ type: 'text', text: `Plan not found: ${phase.planId}` }],
+            };
+        }
+        const startTime = Date.now();
+        const attempts = [];
+        let currentAttempt = 0;
+        let finalStatus = 'error';
+        // Update phase status
+        phase.status = 'executing';
+        phase.startedAt = Date.now();
+        phases.set(phase.id, phase);
+        // The Loop
+        while (currentAttempt < maxAttempts) {
+            currentAttempt++;
+            const attemptStart = Date.now();
+            // Step 1: Execute (invoke coder with plan)
+            if (currentAttempt === 1) {
+                phase.status = 'executing';
+                phases.set(phase.id, phase);
+                // In real implementation, this would invoke the coder
+                // For now, we simulate
+            }
+            // Step 2: Verify
+            phase.status = 'verifying';
+            phases.set(phase.id, phase);
+            const verifyPrompt = `Verify implementation of phase "${phase.name}" against plan.`;
+            const verifyResult = await providers.invoke({
+                role: 'verifier',
+                task: verifyPrompt,
+                context: plan.description,
+            });
+            // Parse verification (simplified)
+            const passed = verifyResult.output.toLowerCase().includes('passed: yes') ||
+                verifyResult.output.toLowerCase().includes('no issues found');
+            const verificationResult = {
+                id: `ver_${nanoid(8)}`,
+                phaseId: phase.id,
+                planId: plan.id,
+                passed,
+                timestamp: Date.now(),
+                issues: [],
+                summary: { critical: 0, major: 0, minor: 0, total: 0 },
+                filesChecked: plan.files.map(f => f.path),
+                duration: Date.now() - attemptStart,
+            };
+            verificationResults.set(verificationResult.id, verificationResult);
+            if (passed) {
+                attempts.push({
+                    attemptNumber: currentAttempt,
+                    startedAt: attemptStart,
+                    completedAt: Date.now(),
+                    verificationResult,
+                    outcome: 'passed',
+                });
+                finalStatus = 'passed';
+                break;
+            }
+            // Step 3: Fix if not passed and autoFix enabled
+            if (autoFix && currentAttempt < maxAttempts) {
+                phase.status = 'fixing';
+                phases.set(phase.id, phase);
+                const fixPrompt = `Fix issues found in verification:\n\n${verifyResult.output}`;
+                const fixResult = await providers.invoke({
+                    role: 'coder',
+                    task: fixPrompt,
+                    context: plan.description,
+                });
+                attempts.push({
+                    attemptNumber: currentAttempt,
+                    startedAt: attemptStart,
+                    completedAt: Date.now(),
+                    verificationResult,
+                    outcome: 'fixed_and_retrying',
+                });
+            }
+            else {
+                attempts.push({
+                    attemptNumber: currentAttempt,
+                    startedAt: attemptStart,
+                    completedAt: Date.now(),
+                    verificationResult,
+                    outcome: 'failed',
+                });
+            }
+        }
+        // Final status
+        if (finalStatus !== 'passed') {
+            finalStatus = currentAttempt >= maxAttempts ? 'max_attempts' : 'failed';
+        }
+        phase.status = finalStatus === 'passed' ? 'passed' : 'failed';
+        phase.completedAt = Date.now();
+        phases.set(phase.id, phase);
+        const result = {
+            phaseId: phase.id,
+            status: finalStatus,
+            attempts,
+            totalDuration: Date.now() - startTime,
+            finalVerification: verificationResults.get(attempts[attempts.length - 1]?.verificationResult.id),
+        };
+        // Build output
+        const statusEmoji = finalStatus === 'passed' ? '✅' : finalStatus === 'max_attempts' ? '⚠️' : '❌';
+        let output = `# Execute Verified ${statusEmoji}\n\n`;
+        output += `**Phase**: ${phase.name} (${phase.id})\n`;
+        output += `**Status**: ${finalStatus}\n`;
+        output += `**Attempts**: ${attempts.length}/${maxAttempts}\n`;
+        output += `**Duration**: ${result.totalDuration}ms\n\n`;
+        output += `## Attempt History\n\n`;
+        for (const attempt of attempts) {
+            const emoji = attempt.outcome === 'passed' ? '✓' : attempt.outcome === 'fixed_and_retrying' ? '🔄' : '✗';
+            output += `### Attempt ${attempt.attemptNumber} ${emoji}\n`;
+            output += `- Outcome: ${attempt.outcome}\n`;
+            output += `- Duration: ${attempt.completedAt - attempt.startedAt}ms\n`;
+            output += `- Verification: ${attempt.verificationResult.passed ? 'passed' : 'failed'}\n\n`;
+        }
+        return {
+            content: [{ type: 'text', text: output }],
+        };
+    });
+    // seldon_execute_parallel
+    server.tool('seldon_execute_parallel', 'Execute multiple phases in parallel, each in its own worktree. Merges when all pass.', {
+        phaseIds: z.array(z.string()).describe('Phase IDs to execute in parallel'),
+        worktreePerPhase: z.boolean().optional().describe('Create separate worktree per phase (default: true)'),
+        maxAttempts: z.number().optional().describe('Max verification attempts per phase (default: 3)'),
+        severityThreshold: IssueSeveritySchema.optional().describe('Severity threshold for all phases (default: major)'),
+        mergeStrategy: z.enum(['sequential', 'parallel', 'manual']).optional().describe('How to merge completed phases (default: sequential)'),
+    }, async ({ phaseIds, worktreePerPhase = true, maxAttempts = 3, severityThreshold = 'major', mergeStrategy = 'sequential' }) => {
+        const startTime = Date.now();
+        // Validate all phases exist
+        const phasesToExecute = [];
+        for (const id of phaseIds) {
+            const phase = phases.get(id);
+            if (!phase) {
+                return {
+                    content: [{ type: 'text', text: `Phase not found: ${id}` }],
+                };
+            }
+            phasesToExecute.push(phase);
+        }
+        // Create worktrees if requested
+        const worktreeAssignments = new Map();
+        if (worktreePerPhase) {
+            for (const phase of phasesToExecute) {
+                try {
+                    const repoRoot = await git.getRepoRoot();
+                    const worktreePath = `${repoRoot}-phase-${phase.id.slice(-4)}`;
+                    const branchName = `phase/${phase.id}`;
+                    // Would create worktree here in real implementation
+                    worktreeAssignments.set(phase.id, worktreePath);
+                    phase.worktreeId = `wt_${nanoid(8)}`;
+                    phases.set(phase.id, phase);
+                }
+                catch (error) {
+                    // Git operations may fail, continue anyway
+                }
+            }
+        }
+        // Execute phases in parallel
+        let output = `# Parallel Execution\n\n`;
+        output += `**Phases**: ${phaseIds.length}\n`;
+        output += `**Worktrees**: ${worktreePerPhase ? 'Yes' : 'No'}\n`;
+        output += `**Max Attempts**: ${maxAttempts}\n`;
+        output += `**Merge Strategy**: ${mergeStrategy}\n\n`;
+        output += `## Phase Status\n\n`;
+        output += `| Phase | Status | Worktree | Attempts |\n`;
+        output += `|-------|--------|----------|----------|\n`;
+        // In real implementation, these would run concurrently
+        // For now, we show what would happen
+        for (const phase of phasesToExecute) {
+            const worktree = worktreeAssignments.get(phase.id) || '-';
+            output += `| ${phase.id} | ⏳ pending | ${worktree.slice(-20)} | 0/${maxAttempts} |\n`;
+        }
+        output += `\n---\n\n`;
+        output += `⚠️ **Parallel execution is simulated**. In production, each phase would:\n\n`;
+        output += `1. Run in its own worktree\n`;
+        output += `2. Execute with verification loop independently\n`;
+        output += `3. Report progress via status updates\n`;
+        output += `4. Merge when all phases pass (strategy: ${mergeStrategy})\n`;
+        return {
+            content: [{ type: 'text', text: output }],
+        };
+    });
+    // ===========================================================================
+    // Pipeline Tools
+    // ===========================================================================
+    // seldon_pipeline_create
+    server.tool('seldon_pipeline_create', 'Create a multi-step DAG workflow with dependencies between steps.', {
+        name: z.string().describe('Pipeline name'),
+        steps: z.array(z.object({
+            id: z.string().describe('Unique step identifier'),
+            role: AgentRoleSchema.describe('Agent role for this step'),
+            task: z.string().describe('Task description'),
+            dependsOn: z.array(z.string()).optional().describe('Step IDs this depends on'),
+        })).describe('Pipeline steps with dependencies'),
+    }, async ({ name, steps }) => {
+        // TODO: Port full implementation from hari-seldon
+        const pipelineId = `pipe_${nanoid(8)}`;
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `✓ Created pipeline "${name}" (${pipelineId}) with ${steps.length} steps\n\nSteps:\n${steps.map(s => `- ${s.id}: ${s.role} → ${s.dependsOn?.join(', ') || 'none'}`).join('\n')}`,
+                },
+            ],
+        };
+    });
+    // seldon_pipeline_execute
+    server.tool('seldon_pipeline_execute', 'Execute a previously created pipeline.', {
+        pipelineId: z.string().describe('Pipeline ID to execute'),
+        context: z.string().optional().describe('Initial context for the pipeline'),
+    }, async ({ pipelineId, context }) => {
+        // TODO: Port implementation from hari-seldon
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `[Stub] Would execute pipeline ${pipelineId}`,
+                },
+            ],
+        };
+    });
+    // seldon_pipeline_status
+    server.tool('seldon_pipeline_status', 'Get the status of a pipeline execution.', {
+        pipelineId: z.string().describe('Pipeline ID to check'),
+    }, async ({ pipelineId }) => {
+        // TODO: Port implementation from hari-seldon
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `[Stub] Would get status of pipeline ${pipelineId}`,
+                },
+            ],
+        };
+    });
+    // ===========================================================================
+    // Task Management Tools
+    // ===========================================================================
+    // seldon_task_execute
+    server.tool('seldon_task_execute', 'Execute a coding task in an isolated git worktree.', {
+        role: AgentRoleSchema.describe('Agent role (usually "coder")'),
+        task: z.string().describe('Task description'),
+        baseBranch: z.string().optional().describe('Base branch for worktree (default: main)'),
+    }, async ({ role, task, baseBranch = 'main' }) => {
+        // TODO: Port implementation from hari-seldon
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `[Stub] Would execute task with ${role} in worktree based on ${baseBranch}`,
+                },
+            ],
+        };
+    });
+    // seldon_task_claim
+    server.tool('seldon_task_claim', 'Claim the next available task from the queue (for worker pattern).', {
+        role: AgentRoleSchema.optional().describe('Only claim tasks for this role'),
+    }, async ({ role }) => {
+        // TODO: Port implementation from hari-seldon
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `[Stub] Would claim next task${role ? ` for role ${role}` : ''}`,
+                },
+            ],
+        };
+    });
+    // ===========================================================================
+    // Provider Tools
+    // ===========================================================================
+    // seldon_providers_list
+    server.tool('seldon_providers_list', 'List all available AI providers and their health status.', {}, async () => {
+        const available = providers.listProviders();
+        const health = providers.getProviderHealth();
+        let output = '## Available Providers\n\n';
+        for (const p of available) {
+            const h = health.find((h) => h.provider === p);
+            const status = h?.healthy ? '✓' : h ? '✗' : '?';
+            output += `- **${p}** ${status}\n`;
+        }
+        return {
+            content: [{ type: 'text', text: output }],
+        };
+    });
+    // seldon_providers_test
+    server.tool('seldon_providers_test', 'Test connectivity to a specific provider.', {
+        provider: z.string().describe('Provider name to test'),
+    }, async ({ provider }) => {
+        const result = await providers.testProvider(provider);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: result.success
+                        ? `✓ ${provider} is healthy (${result.latencyMs}ms)`
+                        : `✗ ${provider} failed: ${result.error}`,
+                },
+            ],
+        };
+    });
+}
+//# sourceMappingURL=index.js.map