bobs-workshop 0.1.4

package/dist/tools/orchestratorTools.js

@@ -0,0 +1,765 @@
+import { z } from "zod";
+import { specCreateHandler, specGetHandler, specListHandler } from "./specTools.js";
+import { dashboardLaunchHandler, dashboardUpdateHandler } from "./dashboardTools.js";
+import { mcpLogger } from "../services/mcpLogger.js";
+import { validateGate1, validateGate2, validateGate3, validateEnhancedStateTransition } from "../validation/schemas.js";
+export const WorkshopInput = z.object({
+    problem: z.string().describe("Problem statement or task description"),
+    mode: z.enum(["architect", "engineer", "debugger", "reviewer"]).optional().describe("Preferred mode (optional - will be auto-determined)"),
+    spec_id: z.string().optional().describe("Continue existing SPEC (optional)"),
+    clarifications: z.record(z.string()).optional().describe("Answers to previous clarifying questions"),
+    user_approval: z.boolean().optional().describe("User approval for spec or implementation"),
+    user_satisfaction: z.boolean().optional().describe("User satisfaction with completed work")
+});
+export const WorkshopOutput = z.object({
+    spec_id: z.string(),
+    action: z.enum(["clarify", "route", "continue", "await_approval", "proceed", "complete"]),
+    clarify_questions: z.array(z.string()).optional(),
+    next_mode: z.string().optional(),
+    dashboard_url: z.string().optional(),
+    prompt_context: z.string().optional(),
+    workflow_step: z.enum([
+        "questioning", "spec_review", "approved", "implementation",
+        "user_review", "completed", "routed_to_architect", "routed_to_engineer",
+        "routed_to_debugger", "routed_to_reviewer"
+    ]).optional(),
+    requires_user_input: z.boolean().optional(),
+    approval_message: z.string().optional(),
+    confidence_score: z.number().optional().describe("Confidence level in problem understanding (0-1)")
+});
+export async function workshopHandler(input) {
+    console.log("bob.workshop orchestrator called with:", input);
+    const validated = WorkshopInput.parse(input);
+    // Step 1: Analyze the problem statement
+    const analysis = analyzeProblem(validated.problem, validated.clarifications);
+    // Step 2: Handle existing SPEC continuation
+    if (validated.spec_id) {
+        return await continueExistingSpec(validated.spec_id, analysis, validated.mode);
+    }
+    // Step 3: Check for existing related SPECs
+    const existingSpecs = await findRelatedSpecs(validated.problem);
+    // Step 4: Decide if we need clarification (enhanced threshold and logic)
+    if (analysis.confidence < 0.95 && !validated.clarifications && analysis.questions.length > 0) {
+        return {
+            spec_id: "",
+            action: "clarify",
+            clarify_questions: analysis.questions,
+            next_mode: analysis.suggestedMode,
+            dashboard_url: undefined,
+            prompt_context: undefined,
+            workflow_step: "questioning",
+            requires_user_input: true,
+            approval_message: `I need to ask ${analysis.questions.length} clarifying question${analysis.questions.length > 1 ? 's' : ''} before proceeding. Please provide answers to ensure accurate implementation.`,
+            confidence_score: analysis.confidence
+        };
+    }
+    // Step 5: Create new SPEC for new features with parallel dashboard update
+    let specId = "";
+    if (analysis.category === "feature" || analysis.category === "research") {
+        // Create SPEC and send dashboard update in parallel
+        const [newSpec] = await Promise.allSettled([
+            specCreateHandler({
+                title: extractTitle(validated.problem),
+                author: "AI Orchestrator",
+                category: mapCategoryToSpecCategory(analysis.category),
+                priority: mapComplexityToPriority(analysis.complexity),
+                tags: extractTags(validated.problem),
+                initial_state: "draft"
+            }),
+            sendDashboardUpdate("", "orchestrator_started", {
+                action: "spec_creation",
+                problem: validated.problem,
+                analysis: {
+                    category: analysis.category,
+                    complexity: analysis.complexity,
+                    confidence: analysis.confidence
+                }
+            })
+        ]);
+        if (newSpec.status === 'fulfilled') {
+            specId = newSpec.value.spec_id;
+            // Send spec creation notification
+            await sendDashboardUpdate(specId, "spec_created", {
+                title: extractTitle(validated.problem),
+                category: analysis.category,
+                complexity: analysis.complexity
+            });
+        }
+        else {
+            throw new Error(`Failed to create SPEC: ${newSpec.reason}`);
+        }
+    }
+    else if (existingSpecs.length > 0) {
+        // Use most recent existing SPEC for non-feature work
+        specId = existingSpecs[0].spec_id;
+        // Notify about continuing existing SPEC
+        await sendDashboardUpdate(specId, "spec_continued", {
+            problem: validated.problem,
+            analysis: {
+                category: analysis.category,
+                complexity: analysis.complexity
+            }
+        });
+    }
+    // Step 6: Launch dashboard for new feature work with parallel notification
+    let dashboardUrl = "";
+    if (analysis.category === "feature" && analysis.suggestedMode === "architect") {
+        const [dashboardResult] = await Promise.allSettled([
+            dashboardLaunchHandler(),
+            sendDashboardUpdate(specId, "dashboard_launch_requested", {
+                mode: analysis.suggestedMode,
+                reason: "new feature development"
+            })
+        ]);
+        if (dashboardResult.status === 'fulfilled') {
+            dashboardUrl = "http://localhost:4577";
+            // Notify dashboard is ready
+            await sendDashboardUpdate(specId, "dashboard_launched", {
+                url: dashboardUrl,
+                status: dashboardResult.value?.status || "launched"
+            });
+        }
+    }
+    // Step 7: Determine final mode (respect explicit preference)
+    const finalMode = validated.mode || analysis.suggestedMode;
+    // Log role transition from orchestrator to target mode
+    await mcpLogger.logRoleTransition('orchestrator', finalMode, specId, `Problem classified as ${analysis.category} (confidence: ${Math.round(analysis.confidence * 100)}%)`);
+    // Step 8: Create context for the target mode
+    const promptContext = await createModeContext(finalMode, validated.problem, specId, analysis);
+    // Step 9: Send final routing notification in parallel with return
+    const result = {
+        spec_id: specId,
+        action: "route",
+        clarify_questions: undefined,
+        next_mode: finalMode,
+        dashboard_url: dashboardUrl || undefined,
+        prompt_context: promptContext,
+        workflow_step: `routed_to_${finalMode}`,
+        requires_user_input: false,
+        approval_message: undefined,
+        confidence_score: analysis.confidence
+    };
+    // Send routing notification without blocking return
+    sendDashboardUpdate(specId, "orchestrator_routing", {
+        target_mode: finalMode,
+        workflow_step: `routed_to_${finalMode}`,
+        dashboard_available: !!dashboardUrl
+    }).catch(error => {
+        console.log('Dashboard routing notification failed (non-blocking):', error);
+    });
+    return result;
+}
+function analyzeProblem(problem, clarifications) {
+    const lowerProblem = problem.toLowerCase();
+    // Simple keyword-based analysis (can be enhanced with more sophisticated NLP)
+    let category = "feature";
+    let suggestedMode = "architect";
+    let confidence = 0.8; // Base confidence
+    const questions = [];
+    // Detect category and mode with priority order (most specific first)
+    if (lowerProblem.includes("review") || lowerProblem.includes("audit") || lowerProblem.includes("check") || lowerProblem.includes("vulnerabilities")) {
+        category = "review";
+        suggestedMode = "reviewer";
+        confidence += 0.2;
+    }
+    else if (lowerProblem.includes("bug") || lowerProblem.includes("fix") || lowerProblem.includes("error") || lowerProblem.includes("broken")) {
+        category = "bug";
+        suggestedMode = "debugger";
+        confidence += 0.2;
+    }
+    else if (lowerProblem.includes("implement") || lowerProblem.includes("develop") || (lowerProblem.includes("according") && lowerProblem.includes("spec"))) {
+        category = "implementation";
+        suggestedMode = "engineer";
+        confidence += 0.2;
+    }
+    else if (lowerProblem.includes("add") || lowerProblem.includes("create") || lowerProblem.includes("build") || lowerProblem.includes("new") || lowerProblem.includes("dashboard") || lowerProblem.includes("feature") || lowerProblem.includes("library") || lowerProblem.includes("make me")) {
+        category = "feature";
+        suggestedMode = "architect";
+        confidence += 0.15;
+    }
+    // Assess complexity
+    let complexity = "medium";
+    if (lowerProblem.length < 50 || lowerProblem.split(" ").length < 8) {
+        complexity = "simple";
+        confidence -= 0.1;
+    }
+    else if (lowerProblem.length > 200 || lowerProblem.includes("system") || lowerProblem.includes("architecture")) {
+        complexity = "complex";
+        confidence += 0.05;
+    }
+    // Final category adjustment based on strong indicators (only for ambiguous cases)
+    if (category === "feature" && (lowerProblem.includes("dashboard") || lowerProblem.includes("comprehensive") || lowerProblem.includes("components"))) {
+        confidence = 0.9; // High confidence for clear feature descriptions
+    }
+    // Enhanced question generation with more sophisticated probing
+    if (!clarifications) {
+        // Feature category questions
+        if (category === "feature") {
+            // Core architecture questions
+            if (!lowerProblem.includes("user") && !lowerProblem.includes("api") && !lowerProblem.includes("frontend") && !lowerProblem.includes("backend")) {
+                questions.push("Is this a user-facing feature, internal API, or full-stack component?");
+                confidence -= 0.08;
+            }
+            // Data persistence questions
+            if (!lowerProblem.includes("database") && !lowerProblem.includes("storage") && !lowerProblem.includes("persist") && complexity !== "simple") {
+                questions.push("Does this feature need to store/persist data? If so, what type of data?");
+                confidence -= 0.06;
+            }
+            // Security and access control
+            if (!lowerProblem.includes("authentication") && !lowerProblem.includes("permission") && !lowerProblem.includes("role") && lowerProblem.includes("user")) {
+                questions.push("What are the authentication and authorization requirements? Who can access this feature?");
+                confidence -= 0.06;
+            }
+            // Integration and dependencies
+            if (!lowerProblem.includes("integrate") && !lowerProblem.includes("external") && !lowerProblem.includes("api") && complexity === "complex") {
+                questions.push("Does this feature integrate with external services or existing systems?");
+                confidence -= 0.04;
+            }
+            // Performance and scale
+            if (!lowerProblem.includes("performance") && !lowerProblem.includes("scale") && !lowerProblem.includes("users") && complexity !== "simple") {
+                questions.push("What are the expected performance requirements and user scale?");
+                confidence -= 0.04;
+            }
+            // UI/UX considerations
+            if (lowerProblem.includes("user") && !lowerProblem.includes("interface") && !lowerProblem.includes("ui") && !lowerProblem.includes("design")) {
+                questions.push("Do you have specific UI/UX requirements or design preferences?");
+                confidence -= 0.03;
+            }
+            // Testing strategy
+            if (!lowerProblem.includes("test") && !lowerProblem.includes("quality") && complexity !== "simple") {
+                questions.push("What level of testing is required (unit, integration, e2e)?");
+                confidence -= 0.03;
+            }
+        }
+        else if (category === "bug") {
+            // Reproduction steps
+            if (!lowerProblem.includes("reproduce") && !lowerProblem.includes("steps") && !lowerProblem.includes("when")) {
+                questions.push("Can you provide detailed steps to reproduce this issue?");
+                confidence -= 0.08;
+            }
+            // Expected vs actual behavior
+            if (!lowerProblem.includes("expect") && !lowerProblem.includes("should") && !lowerProblem.includes("supposed")) {
+                questions.push("What is the expected behavior vs. what you're actually seeing?");
+                confidence -= 0.07;
+            }
+            // Environment and context
+            if (!lowerProblem.includes("environment") && !lowerProblem.includes("browser") && !lowerProblem.includes("version")) {
+                questions.push("In what environment does this occur (browser, OS, version, etc.)?");
+                confidence -= 0.06;
+            }
+            // Frequency and impact
+            if (!lowerProblem.includes("always") && !lowerProblem.includes("sometimes") && !lowerProblem.includes("critical")) {
+                questions.push("How frequently does this occur and what's the business impact?");
+                confidence -= 0.05;
+            }
+            // Error messages and logs
+            if (!lowerProblem.includes("error") && !lowerProblem.includes("log") && !lowerProblem.includes("message")) {
+                questions.push("Are there any error messages, console logs, or stack traces?");
+                confidence -= 0.05;
+            }
+        }
+        else if (category === "implementation") {
+            // Existing specifications
+            if (!lowerProblem.includes("spec") && !lowerProblem.includes("requirement") && !lowerProblem.includes("design")) {
+                questions.push("Do you have existing specifications, designs, or requirements documents?");
+                confidence -= 0.07;
+            }
+            // Technical constraints
+            if (!lowerProblem.includes("constraint") && !lowerProblem.includes("limitation") && !lowerProblem.includes("technology")) {
+                questions.push("Are there any technical constraints or preferred technologies to use?");
+                confidence -= 0.06;
+            }
+            // Timeline and priority
+            if (!lowerProblem.includes("deadline") && !lowerProblem.includes("urgent") && !lowerProblem.includes("priority")) {
+                questions.push("What's the timeline and priority level for this implementation?");
+                confidence -= 0.04;
+            }
+        }
+        else if (category === "review") {
+            // Scope of review
+            if (!lowerProblem.includes("component") && !lowerProblem.includes("module") && !lowerProblem.includes("file")) {
+                questions.push("What specific components, modules, or files should be reviewed?");
+                confidence -= 0.08;
+            }
+            // Review focus areas
+            if (!lowerProblem.includes("security") && !lowerProblem.includes("performance") && !lowerProblem.includes("quality")) {
+                questions.push("What should the review focus on: security, performance, code quality, or all?");
+                confidence -= 0.06;
+            }
+            // Standards and guidelines
+            if (!lowerProblem.includes("standard") && !lowerProblem.includes("guideline") && !lowerProblem.includes("compliance")) {
+                questions.push("Are there specific coding standards or compliance requirements to check against?");
+                confidence -= 0.05;
+            }
+        }
+        else if (category === "research") {
+            // Research scope
+            if (!lowerProblem.includes("scope") && !lowerProblem.includes("depth") && !lowerProblem.includes("focus")) {
+                questions.push("What's the scope and depth of research needed? Any specific focus areas?");
+                confidence -= 0.07;
+            }
+            // Deliverables
+            if (!lowerProblem.includes("report") && !lowerProblem.includes("document") && !lowerProblem.includes("summary")) {
+                questions.push("What deliverables are expected: summary, detailed report, recommendations?");
+                confidence -= 0.06;
+            }
+        }
+        // Universal questions for ambiguous or short descriptions
+        if (problem.length < 30) {
+            questions.push("Could you provide more details about what you're trying to accomplish?");
+            confidence -= 0.1;
+        }
+        if (complexity === "simple" && questions.length === 0 && confidence < 0.9) {
+            questions.push("Are there any specific requirements or constraints I should be aware of?");
+            confidence -= 0.05;
+        }
+        // Limit to maximum 3 most important questions to avoid overwhelming user
+        if (questions.length > 3) {
+            questions.splice(3);
+        }
+    }
+    return {
+        confidence: Math.max(0.5, Math.min(1.0, confidence)),
+        category,
+        complexity,
+        suggestedMode,
+        questions
+    };
+}
+async function continueExistingSpec(specId, analysis, preferredMode) {
+    try {
+        const spec = await specGetHandler({ spec_id: specId });
+        const mode = preferredMode || analysis.suggestedMode;
+        // Log role transition for existing spec continuation
+        await mcpLogger.logRoleTransition('orchestrator', mode, specId, `Continuing existing SPEC work, transitioning to ${mode} mode`);
+        const promptContext = await createModeContext(mode, "", specId, analysis);
+        // Send dashboard notification about continuing existing SPEC
+        sendDashboardUpdate(specId, "spec_continuation", {
+            mode,
+            analysis: {
+                category: analysis.category,
+                complexity: analysis.complexity,
+                confidence: analysis.confidence
+            },
+            spec_title: spec.title
+        }).catch(error => {
+            console.log('Dashboard continuation notification failed (non-blocking):', error);
+        });
+        return {
+            spec_id: specId,
+            action: "continue",
+            clarify_questions: undefined,
+            next_mode: mode,
+            dashboard_url: undefined,
+            prompt_context: promptContext,
+            workflow_step: `continuing_with_${mode}`
+        };
+    }
+    catch (error) {
+        throw new Error(`Cannot continue SPEC ${specId}: ${error}`);
+    }
+}
+async function findRelatedSpecs(problem) {
+    try {
+        const allSpecs = await specListHandler({});
+        const keywords = extractKeywords(problem);
+        return allSpecs.specs.filter((spec) => {
+            const specText = (spec.title + " " + spec.category).toLowerCase();
+            return keywords.some(keyword => specText.includes(keyword));
+        }).slice(0, 3); // Return top 3 matches
+    }
+    catch (error) {
+        return [];
+    }
+}
+function extractTitle(problem) {
+    // Extract a concise title from the problem statement
+    const words = problem.split(" ").slice(0, 8);
+    return words.join(" ").replace(/[^\w\s-]/g, "").trim();
+}
+function extractKeywords(text) {
+    const stopWords = ["the", "a", "an", "and", "or", "but", "in", "on", "at", "to", "for", "of", "with", "by"];
+    return text.toLowerCase()
+        .split(/\s+/)
+        .filter(word => word.length > 2 && !stopWords.includes(word))
+        .slice(0, 5);
+}
+function extractTags(problem) {
+    const lowerProblem = problem.toLowerCase();
+    const tags = [];
+    // Common technology/domain tags
+    const tagMap = {
+        "react": ["frontend", "react"],
+        "api": ["backend", "api"],
+        "database": ["backend", "database"],
+        "auth": ["security", "authentication"],
+        "user": ["frontend", "ux"],
+        "mobile": ["mobile", "responsive"],
+        "test": ["testing", "qa"],
+        "performance": ["performance", "optimization"]
+    };
+    Object.entries(tagMap).forEach(([keyword, tagList]) => {
+        if (lowerProblem.includes(keyword)) {
+            tags.push(...tagList);
+        }
+    });
+    return [...new Set(tags)]; // Remove duplicates
+}
+function mapCategoryToSpecCategory(category) {
+    const mapping = {
+        "feature": "fullstack",
+        "bug": "general",
+        "review": "general",
+        "implementation": "backend",
+        "research": "general"
+    };
+    return mapping[category];
+}
+function mapComplexityToPriority(complexity) {
+    const mapping = {
+        "simple": "low",
+        "medium": "medium",
+        "complex": "high"
+    };
+    return mapping[complexity];
+}
+async function createModeContext(mode, problem, specId, analysis) {
+    let context = `ORCHESTRATOR CONTEXT:\n`;
+    context += `- Mode: ${mode}\n`;
+    context += `- Problem: ${problem}\n`;
+    context += `- SPEC ID: ${specId}\n`;
+    context += `- Category: ${analysis.category}\n`;
+    context += `- Complexity: ${analysis.complexity}\n`;
+    context += `- Confidence: ${(analysis.confidence * 100).toFixed(1)}%\n\n`;
+    // Add mode-specific guidance
+    switch (mode) {
+        case "architect":
+            context += `ARCHITECT GUIDANCE:\n`;
+            context += `- Create comprehensive SPEC with all required sections\n`;
+            context += `- Research existing codebase patterns first\n`;
+            context += `- Launch dashboard for visual tracking\n`;
+            context += `- Focus on technical architecture and implementation plan\n`;
+            break;
+        case "engineer":
+            context += `ENGINEER GUIDANCE:\n`;
+            context += `- Load existing SPEC for implementation guidance\n`;
+            context += `- Create worktree for isolated development\n`;
+            context += `- Follow implementation plan from SPEC\n`;
+            context += `- Log progress in execution logs\n`;
+            break;
+        case "debugger":
+            context += `DEBUGGER GUIDANCE:\n`;
+            context += `- Analyze issue systematically\n`;
+            context += `- Research existing codebase for similar patterns\n`;
+            context += `- Apply minimal, safe fixes\n`;
+            context += `- Document findings in debug logs\n`;
+            break;
+        case "reviewer":
+            context += `REVIEWER GUIDANCE:\n`;
+            context += `- Focus on security, performance, and quality\n`;
+            context += `- Provide severity-based findings\n`;
+            context += `- Check for common vulnerabilities\n`;
+            context += `- Validate against project standards\n`;
+            break;
+    }
+    return context;
+}
+// Helper function to send dashboard updates without blocking main workflow
+async function sendDashboardUpdate(specId, event, data) {
+    try {
+        await dashboardUpdateHandler({
+            spec_id: specId,
+            event,
+            data
+        });
+    }
+    catch (error) {
+        // Don't let dashboard update failures break the main workflow
+        console.log(`Dashboard update failed (non-blocking): [${specId}] ${event}`, error instanceof Error ? error.message : String(error));
+    }
+}
+// Search enforcement functions for Debugger
+function countSearchToolUsage(specId) {
+    let searchCount = 0;
+    // Check active operations for search tool calls
+    const activeOps = mcpLogger.getActiveOperationsForSpec(specId);
+    for (const operationId of activeOps) {
+        const operation = mcpLogger.activeOperations.get(operationId);
+        if (operation && operation.details.tool_name === 'bob.code.search') {
+            searchCount++;
+        }
+    }
+    // Also check completed tool calls in the log buffer (for recent completions)
+    const logBuffer = mcpLogger.logBuffer || [];
+    for (const entry of logBuffer) {
+        if (entry.data &&
+            entry.data.tool_name === 'bob.code.search' &&
+            entry.data.spec_id === specId &&
+            entry.data.event_type === 'tool_call_completed') {
+            searchCount++;
+        }
+    }
+    return searchCount;
+}
+export function validateDebuggerSearchUsage(specId, operation) {
+    // Only enforce for debug operations (commits and debug_log updates)
+    const debugOperations = ['debug_log', 'commit', 'fix_implementation'];
+    if (!debugOperations.some(op => operation.toLowerCase().includes(op))) {
+        return { valid: true };
+    }
+    const searchCount = countSearchToolUsage(specId);
+    if (searchCount < 1) {
+        return {
+            valid: false,
+            error: `Debugger must call bob.code.search at least once before ${operation}. Current search calls: ${searchCount}. Please perform search to understand the codebase before proceeding.`
+        };
+    }
+    return { valid: true };
+}
+// 3-Gate Approval System Implementation
+export async function processApprovalGate(specId, gateNumber, context) {
+    try {
+        let approved = false;
+        let nextStep = "";
+        let message = "";
+        let blockingReason;
+        switch (gateNumber) {
+            case 1: // Q&A Clarification Gate
+                approved = validateGate1(context.confidence || 0, context.questions || []);
+                if (approved) {
+                    nextStep = "spec_review";
+                    message = "Confidence threshold met (≥95%). Proceeding to architecture planning.";
+                    // Validate state transition
+                    await validateEnhancedStateTransition({ from: "questioning", to: "spec_review", spec_id: specId }, { confidence_threshold: true });
+                }
+                else {
+                    nextStep = "questioning";
+                    blockingReason = `Confidence too low (${Math.round((context.confidence || 0) * 100)}%) or questions remain`;
+                    message = `Gate 1 blocked: ${blockingReason}. Please provide clarifications.`;
+                }
+                break;
+            case 2: // Spec Approval Gate
+                approved = validateGate2(context.userApproval || false, context.sectionsComplete || []);
+                if (approved) {
+                    nextStep = "approved";
+                    message = "Specification approved. Ready for implementation.";
+                    // Validate state transition
+                    await validateEnhancedStateTransition({ from: "spec_review", to: "approved", spec_id: specId }, { confidence_threshold: true, user_approval: true });
+                }
+                else {
+                    nextStep = "spec_review";
+                    blockingReason = "Specification not approved or missing required sections";
+                    message = `Gate 2 blocked: ${blockingReason}. Please complete spec and get approval.`;
+                }
+                break;
+            case 3: // Implementation Approval Gate (with mandatory Reviewer)
+                approved = validateGate3(context.testsPass || false, context.reviewerComplete || false, context.userApproval || false);
+                if (approved) {
+                    nextStep = "completed";
+                    message = "Implementation approved after testing and review. Ready for deployment.";
+                    // Validate state transition
+                    await validateEnhancedStateTransition({ from: "user_review", to: "completed", spec_id: specId }, {
+                        confidence_threshold: true,
+                        reviewer_completed: true,
+                        user_approval: true
+                    });
+                }
+                else {
+                    nextStep = "user_review";
+                    const reasons = [];
+                    if (!context.testsPass)
+                        reasons.push("tests not passing");
+                    if (!context.reviewerComplete)
+                        reasons.push("reviewer not completed");
+                    if (!context.userApproval)
+                        reasons.push("user approval pending");
+                    blockingReason = reasons.join(", ");
+                    message = `Gate 3 blocked: ${blockingReason}. Please address issues before proceeding.`;
+                }
+                break;
+        }
+        // Log gate processing
+        await mcpLogger.info(`Gate ${gateNumber} processed for ${specId}`, {
+            approved,
+            nextStep,
+            blockingReason,
+            gateNumber,
+            spec_id: specId
+        });
+        return { approved, nextStep, message, blockingReason };
+    }
+    catch (error) {
+        const errorMessage = `Gate ${gateNumber} validation failed: ${error instanceof Error ? error.message : String(error)}`;
+        await mcpLogger.error(errorMessage, { specId, gateNumber, error });
+        return {
+            approved: false,
+            nextStep: "error",
+            message: errorMessage,
+            blockingReason: "Validation error"
+        };
+    }
+}
+// Enhanced workflow router with 3-gate integration
+export async function routeWithApprovalGates(specId, currentState, context) {
+    // Determine which gate to process based on current state
+    let gateNumber = null;
+    if (currentState === "questioning" && context.confidence >= 0.95) {
+        gateNumber = 1;
+    }
+    else if (currentState === "spec_review" && context.requestingApproval) {
+        gateNumber = 2;
+    }
+    else if (currentState === "implementation" && context.implementationComplete) {
+        gateNumber = 3;
+    }
+    if (gateNumber) {
+        const gateResult = await processApprovalGate(specId, gateNumber, context);
+        if (gateResult.approved) {
+            return {
+                action: "proceed",
+                nextMode: getNextMode(gateResult.nextStep),
+                gateResult
+            };
+        }
+        else {
+            return {
+                action: "await_approval",
+                gateResult
+            };
+        }
+    }
+    // No gate processing needed, continue with normal routing
+    return {
+        action: "route",
+        nextMode: context.suggestedMode
+    };
+}
+function getNextMode(nextStep) {
+    const modeMap = {
+        "spec_review": "architect",
+        "approved": "engineer",
+        "user_review": "reviewer",
+        "completed": "none"
+    };
+    return modeMap[nextStep] || "architect";
+}
+// Mandatory Reviewer Integration (TASK-006)
+export async function enforceReviewerBeforeGate3(specId, context) {
+    // Check if implementation is complete and ready for Gate 3
+    if (!context.implementationComplete) {
+        return {
+            requiresReviewer: false,
+            reviewerComplete: false,
+            nextAction: "continue_implementation"
+        };
+    }
+    // Check if tests are passing (required before reviewer)
+    if (!context.testsPass) {
+        return {
+            requiresReviewer: false,
+            reviewerComplete: false,
+            nextAction: "fix_tests_first"
+        };
+    }
+    // Check if reviewer has already completed their work
+    const reviewerComplete = await checkReviewerCompletion(specId);
+    if (!reviewerComplete) {
+        // Auto-route to Reviewer with context
+        await mcpLogger.info(`Auto-routing to Reviewer before Gate 3 for ${specId}`, {
+            spec_id: specId,
+            reason: "mandatory_review_before_gate3",
+            tests_passing: context.testsPass
+        });
+        // Send dashboard update
+        await sendDashboardUpdate(specId, "auto_routing_reviewer", {
+            reason: "Gate 3 requires review",
+            tests_status: "passing"
+        });
+        return {
+            requiresReviewer: true,
+            reviewerComplete: false,
+            nextAction: "route_to_reviewer"
+        };
+    }
+    // Reviewer is complete, ready for Gate 3
+    return {
+        requiresReviewer: false,
+        reviewerComplete: true,
+        nextAction: "proceed_to_gate3"
+    };
+}
+async function checkReviewerCompletion(specId) {
+    try {
+        // Check for reviewer completion in the spec logs
+        const spec = await specGetHandler({ spec_id: specId });
+        // Look for reviewer completion in execution logs
+        const reviewerLogs = spec.execution_logs?.filter((log) => log.engineer?.includes("REVIEWER") || log.action?.includes("review")) || [];
+        // Also check debug logs for review findings
+        const reviewFindings = spec.debug_logs?.filter((log) => log.issue?.includes("review") || log.root_cause?.includes("review")) || [];
+        return reviewerLogs.length > 0 || reviewFindings.length > 0;
+    }
+    catch (error) {
+        await mcpLogger.warning(`Failed to check reviewer completion for ${specId}`, { error });
+        // Default to requiring review if we can't determine completion
+        return false;
+    }
+}
+// Enhanced implementation complete handler with reviewer enforcement
+export async function handleImplementationComplete(specId, context) {
+    // Step 1: Check if tests are passing
+    if (!context.testsPass) {
+        return {
+            action: "fix_tests",
+            message: "Tests must pass before proceeding to review and approval. Please fix failing tests.",
+        };
+    }
+    // Step 2: Start dev server (moved from workflow.start)
+    if (!context.devServerStarted) {
+        await mcpLogger.info(`Starting dev server after tests pass for ${specId}`, { spec_id: specId });
+        // This would integrate with the server startup logic that was removed from workflow.start
+        await sendDashboardUpdate(specId, "starting_preview_server", {
+            reason: "tests_passed",
+            next_step: "review_and_approval"
+        });
+        return {
+            action: "start_server",
+            message: "Tests passed! Starting preview server before review and approval.",
+        };
+    }
+    // Step 3: Enforce mandatory reviewer
+    const reviewerCheck = await enforceReviewerBeforeGate3(specId, context);
+    if (reviewerCheck.requiresReviewer) {
+        return {
+            action: "route",
+            nextMode: "reviewer",
+            message: "Implementation complete and tests passing. Routing to Reviewer for mandatory review before final approval.",
+        };
+    }
+    if (reviewerCheck.nextAction === "fix_tests_first") {
+        return {
+            action: "fix_tests",
+            message: "Please ensure all tests are passing before proceeding to review.",
+        };
+    }
+    // Step 4: Process Gate 3 (all requirements met)
+    const gateResult = await processApprovalGate(specId, 3, {
+        ...context,
+        reviewerComplete: reviewerCheck.reviewerComplete
+    });
+    if (gateResult.approved) {
+        return {
+            action: "complete",
+            message: "Implementation approved! Ready for deployment.",
+            gateResult
+        };
+    }
+    else {
+        return {
+            action: "await_approval",
+            message: gateResult.message,
+            requiresApproval: true,
+            gateResult
+        };
+    }
+}
+//# sourceMappingURL=orchestratorTools.js.map