bobs-workshop 0.3.3 → 3.1.1

package/dist/tools/orchestratorTools.js

@@ -1,832 +0,0 @@
-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 mode switching 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 mode switching notification without blocking return
-    sendDashboardUpdate(specId, "orchestrator_mode_switch", {
-        target_mode: finalMode,
-        workflow_step: `switching_to_${finalMode}`,
-        dashboard_available: !!dashboardUrl,
-        execution_note: `YOU are now switching to ${finalMode} mode - execute ${finalMode.toUpperCase()}_PROMPT steps directly`
-    }).catch(error => {
-        console.log('Dashboard mode switch 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 = `MODE SWITCH DIRECTIVE:\n`;
-    context += `⚠️ YOU are now switching to ${mode.toUpperCase()} mode.\n`;
-    context += `⚠️ Read the ${mode.toUpperCase()}_PROMPT and execute those steps directly.\n`;
-    context += `⚠️ There is NO delegation - YOU ARE the ${mode} executing these tasks.\n\n`;
-    context += `CONTEXT PROVIDED BY ORCHESTRATOR:\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 first steps
-    switch (mode) {
-        case "architect":
-            context += `YOUR FIRST STEPS AS ARCHITECT:\n`;
-            context += `1. Call bob.code.search with phase: "architect" to research existing codebase patterns\n`;
-            context += `2. Call bob.workflow.start to create manual + worktree + launch dashboard\n`;
-            context += `3. Use bob.manual.update to build all required SPEC sections\n`;
-            context += `4. Focus on technical architecture and implementation plan\n`;
-            break;
-        case "engineer":
-            context += `YOUR FIRST STEPS AS ENGINEER:\n`;
-            context += `1. Call bob.manual.get to load the SPEC for implementation guidance\n`;
-            context += `2. Extract implementation plan and update your TODO list\n`;
-            context += `3. Use bob.code.search with phase: "engineer" to find affected files\n`;
-            context += `4. Follow implementation plan and log progress with bob.manual.update\n`;
-            break;
-        case "debugger":
-            context += `YOUR FIRST STEPS AS DEBUGGER:\n`;
-            context += `1. Call bob.code.search with phase: "debugger" to analyze the issue\n`;
-            context += `2. Research existing codebase for similar patterns and bugs\n`;
-            context += `3. Apply minimal, safe fixes with user validation\n`;
-            context += `4. Document findings with bob.manual.update (debug_log parameter)\n`;
-            break;
-        case "reviewer":
-            context += `YOUR FIRST STEPS AS REVIEWER:\n`;
-            context += `1. Call bob.code.search with phase: "reviewer" for vulnerability detection\n`;
-            context += `2. Analyze security, performance, and quality issues\n`;
-            context += `3. Create review manual with improvement recommendations\n`;
-            context += `4. Provide severity-based findings and validation requirements\n`;
-            break;
-    }
-    return context;
-}
-// Helper function to format role directive for Claude (Option A: Enhanced Tool Response)
-// Based on proven pattern from workflows-mcp-server (350+ GitHub stars)
-export function formatRoleDirective(mode, context) {
-    const roleMap = {
-        architect: {
-            emoji: '📐',
-            actions: [
-                'Call bob.code.search({ query: "...", phase: "architect" }) to research existing patterns',
-                'Build manual sections: executive_summary, product_specifications, architecture_analysis, implementation_plan, testing',
-                'Call bob.approval.request(spec_id, "spec_approval", ...) when ready for user review'
-            ]
-        },
-        debugger: {
-            emoji: '🐛',
-            actions: [
-                'Call bob.code.search({ query: "...", phase: "debugger" }) - MANDATORY before diagnosis',
-                'Reproduce and analyze the issue systematically',
-                'Apply minimal, safe fix that addresses root cause',
-                'Update bob.manual.update with debug_log documenting findings'
-            ]
-        },
-        engineer: {
-            emoji: '⚙️',
-            actions: [
-                'Call bob.manual.get(spec_id) to load the implementation plan',
-                'Create worktree if needed using bob.workflow.start',
-                'Implement tasks from plan sequentially (database → backend → frontend → integration)',
-                'Run tests and call bob.workflow.deploy when complete'
-            ]
-        },
-        reviewer: {
-            emoji: '🔍',
-            actions: [
-                'Load context and code to review',
-                'Perform security, performance, and quality audit',
-                'Document findings in bob.manual.update with severity levels',
-                'Provide actionable recommendations'
-            ]
-        }
-    };
-    const role = roleMap[mode];
-    if (!role) {
-        return `Role ${mode} not recognized. Please use architect, engineer, debugger, or reviewer.`;
-    }
-    const problemText = context.problem ? context.problem.substring(0, 100) : 'See spec for details';
-    const specText = context.spec_id || 'Will be created';
-    const confidenceText = context.confidence ? Math.round(context.confidence * 100) : 0;
-    return `
-${role.emoji} ROLE ASSIGNMENT: ${mode.toUpperCase()}
-
-YOU are now executing as the ${mode.toUpperCase()} role. This is not routing to another agent - YOU must perform these actions:
-
-IMMEDIATE ACTIONS REQUIRED:
-${role.actions.map((a, i) => `${i + 1}. ${a}`).join('\n')}
-
-CONTEXT:
-- Spec ID: ${specText}
-- Problem: ${problemText}
-- Confidence: ${confidenceText}%
-
-⚠️ DO NOT wait for another agent. YOU are the ${mode}. Start with step 1 now.
-`.trim();
-}
-// 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