synapsexcoder 6.0.0

package/dist/agents/base-agents.js

@@ -0,0 +1,3961 @@
+// @ts-nocheck
+/**
+ * SynapseXcoder V6 - Base Agent Class
+ *
+ * All specialized agents (Planner, Analyzer, Reviewer, etc.) extend this base class.
+ * Provides common functionality: task execution, metrics tracking, subagent spawning,
+ * and communication with the OpenCode tool bridge.
+ */
+import { EventEmitter } from "events";
+import { v4 as uuidv4 } from "uuid";
+import { ContextSystem } from "../context/context-system.js";
+import { ThoughtsManager } from "../thoughts/thoughts-manager.js";
+import { AgentConfigManager } from "./agent-config-manager.js";
+import { CommandProcessor } from "../commands/command-processor.js";
+import { TeamCollaborationSystem } from "../team/team-collaboration.js";
+import { PluginManager } from "../plugins/plugin-system.js";
+import { TokenOptimizer } from "../optimization/token-optimizer.js";
+import { optimizePromptForModel } from "../optimization/token-optimizer.js";
+import { createGatedSubAgent } from "./gated-subagents.js";
+import { getDefaultController as getDefaultDasp } from "../dasp/index.js";
+// ============================================================================
+// Model Resolution Utilities
+// ============================================================================
+/**
+ * Resolve model with fallback candidates
+ */
+export function resolveModelCandidates(userModel) {
+    const candidates = [];
+    // User-specified model first
+    if (userModel) {
+        candidates.push(userModel);
+    }
+    // Environment variable
+    const envModel = process.env.DUCKYCODER_MODEL;
+    if (envModel && !candidates.includes(envModel)) {
+        candidates.push(envModel);
+    }
+    // Provider-specific aliases
+    const aliases = {
+        "claude-sonnet": [
+            "opencode/claude-sonnet-4-5",
+            "github-copilot/claude-sonnet-4.5",
+        ],
+        "claude-opus": [
+            "opencode/claude-opus-4-6",
+            "github-copilot/claude-opus-4.6",
+            "opencode/claude-opus-4-5",
+            "github-copilot/claude-opus-4-5",
+        ],
+        "gpt-4": ["github-copilot/gpt-4o", "opencode/gpt-5"],
+        grok: ["github-copilot/grok-code-fast-1"],
+    };
+    for (const [alias, models] of Object.entries(aliases)) {
+        if (userModel?.includes(alias) || envModel?.includes(alias)) {
+            candidates.push(...models.filter((m) => !candidates.includes(m)));
+        }
+    }
+    // If no model specified via userModel or envVar, default to claude-opus-4-6
+    if (!userModel && !envModel) {
+        candidates.push("opencode/claude-opus-4-6");
+        candidates.push("github-copilot/claude-opus-4.6");
+    }
+    // Hard fallbacks - use models that are actually available
+    // OPTIMIZATION: Limit to 3 fallbacks to reduce retry attempts
+    const fallbacks = [
+        "opencode/claude-opus-4-6",
+        "github-copilot/claude-opus-4.6",
+        "github-copilot/grok-code-fast-1",
+    ];
+    candidates.push(...fallbacks.filter((m) => !candidates.includes(m)));
+    return candidates;
+}
+/**
+ * Check if error is ProviderModelNotFoundError
+ */
+export function isProviderModelNotFoundError(error) {
+    const patterns = [
+        /ProviderModelNotFoundError/i,
+        /ModelNotFound/i,
+        /model not found/i,
+        /provider\/model/i,
+        /invalid model/i,
+        /model.*not.*available/i,
+    ];
+    return patterns.some((pattern) => pattern.test(error));
+}
+// ============================================================================
+// Base Agent (Abstract)
+// ============================================================================
+export class BaseAgent extends EventEmitter {
+    id;
+    type;
+    config;
+    memory = new Map();
+    status;
+    messageBus;
+    toolBridge;
+    artifacts = [];
+    isRunning = false;
+    abortController = null;
+    constructor(type, config, messageBus, toolBridge) {
+        super();
+        this.id = uuidv4();
+        this.type = type;
+        this.config = {
+            type,
+            mode: config.mode || "subagent",
+            model: config.model || "github-copilot/grok-code-fast-1",
+            temperature: config.temperature ?? 0.2,
+            maxSteps: config.maxSteps ?? 50,
+            description: config.description,
+            color: config.color,
+            tools: config.tools,
+            hidden: config.hidden ?? false,
+            timeout: config.timeout ?? 300000,
+        };
+        this.messageBus = messageBus;
+        this.toolBridge = toolBridge;
+        this.status = this.createInitialStatus();
+    }
+    createInitialStatus() {
+        return {
+            id: this.id,
+            type: this.type,
+            status: "idle",
+            startedAt: 0,
+            lastActivity: Date.now(),
+            metrics: {
+                tasksCompleted: 0,
+                tasksFailed: 0,
+                tokensUsed: 0,
+                executionTime: 0,
+                toolsInvoked: 0,
+            },
+        };
+    }
+    async start() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        this.status.status = "running";
+        this.status.startedAt = Date.now();
+        this.abortController = new AbortController();
+        this.emit("start", this.id);
+    }
+    async stop() {
+        if (!this.isRunning)
+            return;
+        this.isRunning = false;
+        this.status.status = "idle";
+        this.abortController?.abort();
+        this.emit("stop", this.id);
+    }
+    async abort(reason) {
+        this.status.status = "idle";
+        this.abortController?.abort(reason);
+        await this.sendStatusUpdate("aborted", { reason });
+        this.emit("abort", this.id, reason);
+    }
+    // ========================================================================
+    // Status & Metrics
+    // ========================================================================
+    getStatus() {
+        return {
+            ...this.status,
+            lastActivity: Date.now(),
+        };
+    }
+    updateStatus(status, details) {
+        this.status.status = status;
+        this.status.lastActivity = Date.now();
+        if (details) {
+            this.status.currentTask = details;
+        }
+        this.emit("statusChange", this.status);
+    }
+    recordTaskCompletion(tokensUsed, toolsInvoked, executionTime) {
+        this.status.metrics.tasksCompleted++;
+        this.status.metrics.tokensUsed += tokensUsed;
+        this.status.metrics.toolsInvoked += toolsInvoked;
+        this.status.metrics.executionTime += executionTime;
+    }
+    recordTaskFailure() {
+        this.status.metrics.tasksFailed++;
+    }
+    // ========================================================================
+    // Communication
+    // ========================================================================
+    async sendMessage(recipient, type, payload) {
+        return this.messageBus.send({
+            sender: this.type,
+            recipient,
+            type: type,
+            payload,
+        });
+    }
+    async sendTaskResult(recipient, result, correlationId) {
+        return this.messageBus.sendTaskResult(this.type, recipient, result, correlationId);
+    }
+    async sendTaskError(recipient, taskId, error, correlationId) {
+        return this.messageBus.sendTaskError(this.type, recipient, taskId, error, correlationId);
+    }
+    async sendStatusUpdate(status, details) {
+        return this.messageBus.sendStatusUpdate(this.type, status, details);
+    }
+    async sendApprovalRequest(request) {
+        return this.messageBus.sendApprovalRequest(this.type, request);
+    }
+    // ========================================================================
+    // Approval Workflow
+    // ========================================================================
+    async requestApproval(taskId, changes, explanation, riskLevel = "medium") {
+        this.updateStatus("waiting", "Requesting approval for changes");
+        const approvalId = await this.sendApprovalRequest({
+            taskId,
+            changes,
+            riskLevel,
+            explanation,
+        });
+        // Wait for approval response via message bus
+        const approved = await this.waitForApproval(approvalId);
+        if (approved) {
+            this.updateStatus("running", "Approval granted, proceeding with changes");
+            return true;
+        }
+        else {
+            this.updateStatus("error", "Approval denied, cancelling task");
+            return false;
+        }
+    }
+    async waitForApproval(_approvalId) {
+        // Listen for approval response via message bus
+        const response = await this.messageBus.receive("master", 30000); // Wait 30s for approval response
+        return (response?.type === "approval_response" &&
+            response.payload?.approved === true);
+    }
+    // ========================================================================
+    // File Operations
+    // ========================================================================
+    async readFile(path) {
+        const result = await this.toolBridge.readFileContent(path);
+        return result?.content ?? null;
+    }
+    async readFiles(paths) {
+        const results = new Map();
+        for (const path of paths) {
+            results.set(path, await this.readFile(path));
+        }
+        return results;
+    }
+    async writeFile(path, content) {
+        const result = await this.toolBridge.writeFile(path, content);
+        return result.success;
+    }
+    async editFile(path, oldString, newString) {
+        const result = await this.toolBridge.editFile(path, oldString, newString);
+        return result.success;
+    }
+    async listDir(path, recursive = false) {
+        const result = await this.toolBridge.listDir(path, { recursive });
+        return result.success ? result.output : null;
+    }
+    async searchFiles(pattern, options) {
+        const result = await this.toolBridge.searchFiles(pattern, options);
+        return result.success ? result.output : null;
+    }
+    // ========================================================================
+    // Bash Operations
+    // ========================================================================
+    async runBash(command, options) {
+        const result = await this.toolBridge.runBash(command, options);
+        return result.success ? result.output : null;
+    }
+    async runGit(args) {
+        return this.runBash(`git ${args.join(" ")}`);
+    }
+    // ========================================================================
+    // Web Operations
+    // ========================================================================
+    async webSearch(query, numResults = 5) {
+        const result = await this.toolBridge.webSearch(query, { numResults });
+        return result.success ? result.output : null;
+    }
+    async callModel(prompt, options = {}) {
+        const result = await this.toolBridge.callModel(prompt, {
+            model: this.config.model,
+            ...options,
+        });
+        return result.success ? result.output : null;
+    }
+    // ========================================================================
+    // Artifact Management
+    // ========================================================================
+    createArtifact(type, name, content) {
+        const artifact = {
+            id: uuidv4(),
+            type,
+            name,
+            content,
+            createdAt: Date.now(),
+            agentId: this.id,
+        };
+        this.artifacts.push(artifact);
+        this.emit("artifactCreated", artifact);
+        return artifact;
+    }
+    setMemory(key, value) {
+        this.memory.set(key, value);
+    }
+    getMemory(key) {
+        return this.memory.get(key);
+    }
+    clearMemory() {
+        this.memory.clear();
+    }
+    getArtifacts() {
+        return [...this.artifacts];
+    }
+    clearArtifacts() {
+        this.artifacts = [];
+    }
+}
+// ============================================================================
+// Master Agent
+// ============================================================================
+// ============================================================================
+// Master Agent
+// ============================================================================
+export class MasterAgent extends BaseAgent {
+    activeSubAgents = new Map();
+    // Using more generic type to support both BaseAgent and GatedSubAgent
+    subAgentFactory = new Map();
+    listenerStops = new Map();
+    contextSystem;
+    thoughtsManager;
+    agentConfigManager;
+    commandProcessor;
+    teamSystem;
+    pluginManager;
+    tokenOptimizer;
+    gatekeeperCoordinator = null;
+    enableGatekeeper = true;
+    gatekeeperReviewLevel = "standard";
+    gatekeeperMaxRevisions = 3;
+    daspController = null;
+    daspEnabled = true;
+    constructor(messageBus, toolBridge, config, projectRoot) {
+        // Resolve model with fallbacks
+        const resolvedModel = resolveModelCandidates(config?.model)[0];
+        super("master", {
+            mode: "primary",
+            model: resolvedModel,
+            ...config,
+        }, messageBus, toolBridge);
+        // Initialize context and knowledge systems
+        this.contextSystem = new ContextSystem(projectRoot);
+        this.thoughtsManager = new ThoughtsManager(projectRoot || process.cwd());
+        this.agentConfigManager = new AgentConfigManager(projectRoot || process.cwd());
+        this.teamSystem = new TeamCollaborationSystem(projectRoot || process.cwd());
+        this.pluginManager = new PluginManager(projectRoot || process.cwd(), this);
+        this.tokenOptimizer = new TokenOptimizer();
+        this.daspController = getDefaultDasp();
+        this.commandProcessor = new CommandProcessor(this);
+        // Register default sub-agent constructors
+        // IMPORTANT: Using GatedSubAgents which include internal GatekeeperAgent
+        // for final review at the very end before returning to Master
+        this.subAgentFactory.set("planner", () => createGatedSubAgent("planner", messageBus, toolBridge, {}));
+        this.subAgentFactory.set("analyzer", () => createGatedSubAgent("analyzer", messageBus, toolBridge, {}));
+        this.subAgentFactory.set("reviewer", () => createGatedSubAgent("reviewer", messageBus, toolBridge, {}));
+        this.subAgentFactory.set("rewriter", () => createGatedSubAgent("rewriter", messageBus, toolBridge, {}));
+        this.subAgentFactory.set("ui_designer", () => createGatedSubAgent("ui_designer", messageBus, toolBridge, {}));
+        this.subAgentFactory.set("researcher", () => createGatedSubAgent("researcher", messageBus, toolBridge, {}));
+        // Gatekeeper is NOT a GatedSubAgent (it reviews others, not itself)
+        this.subAgentFactory.set("gatekeeper", () => new GatekeeperAgent(messageBus, toolBridge));
+        // Verifier - autonomous verification agent
+        this.subAgentFactory.set("verifier", () => createGatedSubAgent("verifier", messageBus, toolBridge, {}));
+        // Strategist - long-horizon goal decomposition
+        this.subAgentFactory.set("strategist", () => createGatedSubAgent("strategist", messageBus, toolBridge, {}));
+        // Diff Validator - compares original vs modified code
+        this.subAgentFactory.set("diff_validator", () => createGatedSubAgent("diff_validator", messageBus, toolBridge, {}));
+        // Debugger - auto-fix agent triggered on failure
+        this.subAgentFactory.set("debugger", () => createGatedSubAgent("debugger", messageBus, toolBridge, {}));
+        // Test Runner - executes validation tests
+        this.subAgentFactory.set("test_runner", () => createGatedSubAgent("test_runner", messageBus, toolBridge, {}));
+    }
+    async execute(task) {
+        const startTime = Date.now();
+        await this.start();
+        this.updateStatus("running", "Creating execution plan");
+        // Initialize gatekeeper coordinator if enabled
+        if (this.enableGatekeeper) {
+            this.gatekeeperCoordinator = new GatekeeperCoordinator(this.messageBus, this.toolBridge, 4);
+        }
+        const sessionId = task.context.metadata["sessionId"];
+        if (sessionId) {
+            // Log session activity
+            try {
+                const session = this.teamSystem.getSession(sessionId);
+                if (session) {
+                    this.teamSystem.logActivity({
+                        sessionId,
+                        userId: "master-agent", // System user for now
+                        type: "create",
+                        targetType: "task",
+                        targetId: task.id,
+                        description: `Started processing task: ${task.prompt.substring(0, 50)}...`,
+                        timestamp: Date.now(),
+                    });
+                }
+            }
+            catch (e) {
+                console.warn(`Failed to log session start activity: ${e}`);
+            }
+        }
+        try {
+            // 1. Create execution plan
+            const phases = this.buildPhases(task);
+            // 2. Execute phases sequentially, passing context forward
+            //    Each phase output will be reviewed by gatekeeper before proceeding
+            const phaseResults = await this.executePhasesWithGatekeeper(phases, task.context);
+            // 3. Synthesize output from all phase results
+            const output = this.synthesizeOutput(phaseResults);
+            const executionTime = Date.now() - startTime;
+            this.recordTaskCompletion(0, phases.length, executionTime);
+            this.updateStatus("completed", "All phases complete with gatekeeper review");
+            // Final gatekeeper report
+            if (this.gatekeeperCoordinator) {
+                const gatekeeperReport = this.generateGatekeeperReport(phaseResults);
+                output.gatekeeperReport = gatekeeperReport;
+            }
+            if (sessionId) {
+                try {
+                    this.teamSystem.logActivity({
+                        sessionId,
+                        userId: "master-agent",
+                        type: "approve",
+                        targetType: "task",
+                        targetId: task.id,
+                        description: "Task completed successfully with gatekeeper review",
+                        timestamp: Date.now(),
+                        metadata: {
+                            executionTime,
+                            phases: phases.length,
+                            artifacts: this.artifacts.length,
+                        },
+                    });
+                }
+                catch (e) {
+                    console.warn(`Failed to log session success activity: ${e}`);
+                }
+            }
+            return {
+                taskId: task.id,
+                success: true,
+                output,
+                metrics: { executionTime, tokensUsed: 0, toolsInvoked: phases.length },
+                artifacts: this.collectAllArtifacts(),
+            };
+        }
+        catch (error) {
+            this.recordTaskFailure();
+            this.updateStatus("error");
+            if (sessionId) {
+                try {
+                    this.teamSystem.logActivity({
+                        sessionId,
+                        userId: "master-agent",
+                        type: "reject",
+                        targetType: "task",
+                        targetId: task.id,
+                        description: `Task failed: ${error instanceof Error ? error.message : String(error)}`,
+                        timestamp: Date.now(),
+                    });
+                }
+                catch (e) {
+                    console.warn(`Failed to log session failure activity: ${e}`);
+                }
+            }
+            return {
+                taskId: task.id,
+                success: false,
+                output: undefined,
+                error: error instanceof Error ? error.message : String(error),
+                metrics: {
+                    executionTime: Date.now() - startTime,
+                    tokensUsed: 0,
+                    toolsInvoked: 0,
+                },
+                artifacts: [],
+            };
+        }
+        finally {
+            await this.stop();
+            // Cleanup gatekeeper coordinator
+            if (this.gatekeeperCoordinator) {
+                await this.gatekeeperCoordinator.shutdown();
+            }
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Phase Planning
+    // -------------------------------------------------------------------------
+    buildPhases(task) {
+        const mode = task.context.metadata["mode"] || "full_pipeline";
+        const hasUI = task.context.files.some((f) => /\.(tsx?|jsx?|html|svelte|vue)$/.test(f.path) ||
+            f.content.includes("React") ||
+            f.content.includes("<div"));
+        const needsResearch = task.context.metadata["needsResearch"] === true;
+        const generateDocs = task.context.metadata["generateDocs"] === true;
+        const phases = [];
+        switch (mode) {
+            case "full_pipeline":
+                // OPTIMIZATION: Research and Plan can run in parallel (independent phases)
+                if (needsResearch) {
+                    phases.push({
+                        id: "research",
+                        agentType: "researcher",
+                        prompt: `Research background for: ${task.prompt}`,
+                        parallelGroup: "pre_analysis", // Group for parallel execution
+                    });
+                }
+                phases.push({
+                    id: "plan",
+                    agentType: "planner",
+                    prompt: `Create a plan for: ${task.prompt}`,
+                    parallelGroup: needsResearch ? "pre_analysis" : undefined, // Run in parallel with research if both exist
+                }, {
+                    id: "analyze",
+                    agentType: "analyzer",
+                    prompt: `Analyze code: ${task.prompt}`,
+                }, {
+                    id: "review",
+                    agentType: "reviewer",
+                    prompt: `Review findings from analysis`,
+                }, {
+                    id: "rewrite",
+                    agentType: "rewriter",
+                    prompt: `Apply fixes: ${task.prompt}`,
+                });
+                if (generateDocs) {
+                    phases.push({
+                        id: "docs",
+                        agentType: "rewriter",
+                        prompt: `Generate documentation (README.md, API docs) based on the analysis and changes: ${task.prompt}`,
+                    });
+                }
+                if (hasUI) {
+                    phases.push({
+                        id: "ui",
+                        agentType: "ui_designer",
+                        prompt: `Generate UI mockups for detected UI code`,
+                    });
+                }
+                break;
+            case "analyze_only":
+                phases.push({
+                    id: "analyze",
+                    agentType: "analyzer",
+                    prompt: `Analyze: ${task.prompt}`,
+                });
+                break;
+            case "review_only":
+                phases.push({
+                    id: "review",
+                    agentType: "reviewer",
+                    prompt: `Review: ${task.prompt}`,
+                });
+                break;
+            case "rewrite_only":
+                phases.push({
+                    id: "rewrite",
+                    agentType: "rewriter",
+                    prompt: `Rewrite: ${task.prompt}`,
+                });
+                break;
+            case "ui_design":
+                phases.push({
+                    id: "ui",
+                    agentType: "ui_designer",
+                    prompt: `Design UI for: ${task.prompt}`,
+                });
+                break;
+            case "merge_only":
+                phases.push({
+                    id: "plan",
+                    agentType: "planner",
+                    prompt: `Plan merge for: ${task.prompt}`,
+                });
+                break;
+            case "dry_run":
+                phases.push({
+                    id: "analyze",
+                    agentType: "analyzer",
+                    prompt: `Dry-run analyze: ${task.prompt} (simulation only — no changes applied)`,
+                }, {
+                    id: "review",
+                    agentType: "reviewer",
+                    prompt: `Dry-run review findings for: ${task.prompt}`,
+                });
+                break;
+            case "security_scan":
+                phases.push({
+                    id: "security",
+                    agentType: "gatekeeper",
+                    prompt: `Security vulnerability scan for: ${task.prompt}`,
+                }, {
+                    id: "analyze",
+                    agentType: "analyzer",
+                    prompt: `Analyze security findings for: ${task.prompt}`,
+                });
+                break;
+            case "debug_assistant":
+                phases.push({
+                    id: "debug",
+                    agentType: "debugger",
+                    prompt: `Debug stack trace / error: ${task.prompt}`,
+                }, {
+                    id: "analyze",
+                    agentType: "analyzer",
+                    prompt: `Analyze root cause for: ${task.prompt}`,
+                });
+                break;
+            case "api_validation":
+                phases.push({
+                    id: "api",
+                    agentType: "analyzer",
+                    prompt: `Validate API endpoints for: ${task.prompt}`,
+                });
+                break;
+            case "doc_generator":
+                phases.push({
+                    id: "docs",
+                    agentType: "rewriter",
+                    prompt: `Generate documentation from: ${task.prompt}`,
+                });
+                break;
+            case "create_mode":
+                phases.push({
+                    id: "plan",
+                    agentType: "planner",
+                    prompt: `Plan scaffolding for: ${task.prompt}`,
+                }, {
+                    id: "scaffold",
+                    agentType: "rewriter",
+                    prompt: `Create new files for: ${task.prompt}`,
+                });
+                break;
+            case "debug_mode":
+                phases.push({
+                    id: "debug",
+                    agentType: "debugger",
+                    prompt: `Debug: ${task.prompt}`,
+                });
+                break;
+            case "refactor_mode":
+                phases.push({
+                    id: "analyze",
+                    agentType: "analyzer",
+                    prompt: `Analyze refactoring targets: ${task.prompt}`,
+                }, {
+                    id: "rewrite",
+                    agentType: "rewriter",
+                    prompt: `Apply refactoring: ${task.prompt}`,
+                }, {
+                    id: "review",
+                    agentType: "reviewer",
+                    prompt: `Review refactored code for: ${task.prompt}`,
+                });
+                break;
+            case "document_mode":
+                phases.push({
+                    id: "research",
+                    agentType: "researcher",
+                    prompt: `Research context for documentation: ${task.prompt}`,
+                }, {
+                    id: "docs",
+                    agentType: "rewriter",
+                    prompt: `Generate comprehensive documentation: ${task.prompt}`,
+                });
+                break;
+            case "security_mode":
+                phases.push({
+                    id: "security",
+                    agentType: "gatekeeper",
+                    prompt: `Hardened security scan: ${task.prompt}`,
+                }, {
+                    id: "analyze",
+                    agentType: "analyzer",
+                    prompt: `Analyze security posture for: ${task.prompt}`,
+                }, {
+                    id: "review",
+                    agentType: "reviewer",
+                    prompt: `Review security findings for: ${task.prompt}`,
+                });
+                break;
+            default:
+                phases.push({
+                    id: "analyze",
+                    agentType: "analyzer",
+                    prompt: task.prompt,
+                });
+        }
+        return phases;
+    }
+    // -------------------------------------------------------------------------
+    // Dynamic Task Division — parallel sub-agent execution for large workloads
+    // -------------------------------------------------------------------------
+    /**
+     * Check if a phase should be parallelized based on context
+     */
+    shouldParallelizePhase(phaseId, context) {
+        // Parallelize rewrite phase if there are many files or issues
+        if (phaseId === "rewrite") {
+            // If we have many files, parallelize
+            if (context.files.length > 3)
+                return true;
+            // Check analysis output for many issues
+            const analysis = context.metadata["analyze_output"];
+            if (analysis && typeof analysis === "object") {
+                const issues = analysis.issues || [];
+                if (issues.length > 5)
+                    return true;
+            }
+        }
+        // Parallelize analysis phase if many files
+        if (phaseId === "analyze") {
+            if (context.files.length > 5)
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Divide a large task into smaller batches for parallel execution
+     */
+    divideTaskIntoBatches(originalTask, batchSize = 3) {
+        const batches = [];
+        // Get the analysis output to understand what needs to be done
+        const analysisOutput = originalTask.context.metadata?.analyze_output;
+        if (!analysisOutput && originalTask.type === "rewriter") {
+            return [originalTask]; // Can't divide rewrite without analysis
+        }
+        // For rewrite tasks, divide by files
+        if (originalTask.type === "rewriter") {
+            const files = originalTask.context.files;
+            // Create batches of files
+            for (let i = 0; i < files.length; i += batchSize) {
+                const fileBatch = files.slice(i, i + batchSize);
+                batches.push({
+                    ...originalTask,
+                    id: `${originalTask.id}-batch-${i / batchSize + 1}`,
+                    context: {
+                        ...originalTask.context,
+                        files: fileBatch,
+                    },
+                    prompt: `${originalTask.prompt} (files: ${fileBatch
+                        .map((f) => f.path)
+                        .join(", ")})`,
+                });
+            }
+        }
+        else {
+            // For other tasks, create logical batches
+            for (let i = 0; i < Math.ceil(batchSize); i++) {
+                batches.push({
+                    ...originalTask,
+                    id: `${originalTask.id}-batch-${i + 1}`,
+                    prompt: `${originalTask.prompt} (batch ${i + 1})`,
+                });
+            }
+        }
+        return batches.length > 1 ? batches : [originalTask];
+    }
+    /**
+     * Execute multiple subagents in parallel for a single phase
+     */
+    async executePhaseInParallel(phase, rollingContext) {
+        this.updateStatus("running", `Phase [${phase.id}] → Parallel ${phase.agentType} execution`);
+        // Create the initial task
+        const enhancedPrompt = this.enhancePromptWithContext(phase.prompt, phase.agentType, rollingContext);
+        const initialTask = {
+            id: uuidv4(),
+            type: phase.agentType,
+            prompt: enhancedPrompt,
+            context: rollingContext,
+            successCriteria: `Complete phase: ${phase.id}`,
+        };
+        // Divide into batches
+        const taskBatches = this.divideTaskIntoBatches(initialTask);
+        if (taskBatches.length === 1) {
+            // No parallelization needed
+            const result = await this.executeSingleTask(taskBatches[0]);
+            return [result];
+        }
+        // Execute batches in parallel
+        console.log(`🚀 Parallel execution: ${taskBatches.length} ${phase.agentType} agents`);
+        const results = await Promise.all(taskBatches.map((task) => this.executeSingleTask(task)));
+        return results;
+    }
+    /**
+     * Execute a single task with model fallback
+     */
+    async executeSingleTask(task) {
+        let attempt = 0;
+        const modelCandidates = resolveModelCandidates(this.config.model);
+        while (attempt < modelCandidates.length) {
+            try {
+                const modelToUse = attempt === 0 ? this.config.model : modelCandidates[attempt];
+                const subAgent = this.getOrCreateSubAgent(task.type, modelToUse);
+                // Register sub-agent
+                this.registerSubAgent(subAgent.id, subAgent);
+                // Dispatch task
+                const result = await this.messageBus.sendTask(this.type, task.type, task);
+                // Unregister after completion
+                this.unregisterSubAgent(subAgent.id);
+                if (result.success) {
+                    return result;
+                }
+                // Fallback logic for model errors
+                if (result.error && isProviderModelNotFoundError(result.error)) {
+                    attempt++;
+                    console.warn(`Task ${task.id}: Model ${modelCandidates[attempt - 1]} unavailable, trying ${modelCandidates[attempt]}`);
+                    continue;
+                }
+                return result;
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                if (isProviderModelNotFoundError(errorMsg)) {
+                    attempt++;
+                    if (attempt < modelCandidates.length) {
+                        console.warn(`Task ${task.id}: Model ${modelCandidates[attempt - 1]} failed, trying ${modelCandidates[attempt]}`);
+                        continue;
+                    }
+                }
+                return {
+                    taskId: task.id,
+                    success: false,
+                    output: undefined,
+                    error: errorMsg,
+                    metrics: { executionTime: 0, tokensUsed: 0, toolsInvoked: 0 },
+                    artifacts: [],
+                };
+            }
+        }
+        return {
+            taskId: task.id,
+            success: false,
+            output: undefined,
+            error: "All model attempts failed",
+            metrics: { executionTime: 0, tokensUsed: 0, toolsInvoked: 0 },
+            artifacts: [],
+        };
+    }
+    // -------------------------------------------------------------------------
+    // Phase Execution with Gatekeeper Review
+    // -------------------------------------------------------------------------
+    /**
+     * Execute phases with gatekeeper review after each phase.
+     * Gatekeeper reviews each phase output before proceeding to the next.
+     * If gatekeeper requests revision, the affected phase is re-executed.
+     * If gatekeeper requests restart, the entire pipeline restarts.
+     */
+    async executePhasesWithGatekeeper(phases, baseContext) {
+        const accumulated = [];
+        let rollingContext = { ...baseContext };
+        const maxRevisions = this.gatekeeperMaxRevisions;
+        // OPTIMIZATION: Group phases by parallelGroup for concurrent execution
+        const phaseGroups = [];
+        for (const phase of phases) {
+            if (phase.parallelGroup) {
+                // Check if we already have a group for this parallelGroup
+                const existingGroup = phaseGroups.find((g) => g.phases[0]?.parallelGroup === phase.parallelGroup);
+                if (existingGroup) {
+                    existingGroup.phases.push(phase);
+                }
+                else {
+                    phaseGroups.push({ phases: [phase], parallel: true });
+                }
+            }
+            else {
+                phaseGroups.push({ phases: [phase], parallel: false });
+            }
+        }
+        // Execute phase groups sequentially, but phases within a group in parallel
+        for (const group of phaseGroups) {
+            if (group.parallel && group.phases.length > 1) {
+                // Execute all phases in this group in parallel
+                this.updateStatus("running", `Parallel phases: ${group.phases.map((p) => p.id).join(", ")}`);
+                console.log(`🚀 Executing parallel group: ${group.phases.map((p) => p.id).join(", ")}`);
+                const parallelResults = await Promise.all(group.phases.map((phase) => this.executePhaseWithGatekeeper(phase, rollingContext, maxRevisions)));
+                // Merge all results into rolling context
+                for (const { phase, result, gatekeeperReview } of parallelResults) {
+                    rollingContext = {
+                        ...rollingContext,
+                        metadata: {
+                            ...rollingContext.metadata,
+                            [`${phase.id}_output`]: result.output,
+                        },
+                    };
+                    accumulated.push({ phaseId: phase.id, agentType: phase.agentType, result, gatekeeperReview });
+                }
+            }
+            else {
+                // Execute phases sequentially
+                for (const phase of group.phases) {
+                    const result = await this.executePhaseWithGatekeeper(phase, rollingContext, maxRevisions);
+                    rollingContext = {
+                        ...rollingContext,
+                        metadata: {
+                            ...rollingContext.metadata,
+                            [`${phase.id}_output`]: result.result.output,
+                        },
+                    };
+                    accumulated.push({
+                        phaseId: phase.id,
+                        agentType: phase.agentType,
+                        result: result.result,
+                        gatekeeperReview: result.gatekeeperReview,
+                    });
+                }
+            }
+        }
+        return accumulated;
+    }
+    /**
+     * Execute a single phase with gatekeeper review (extracted for reuse)
+     */
+    async executePhaseWithGatekeeper(phase, rollingContext, maxRevisions) {
+        let phaseApproved = false;
+        let currentAttempt = 0;
+        let mergedResult = {
+            taskId: "",
+            success: false,
+            output: undefined,
+            error: undefined,
+            metrics: { executionTime: 0, tokensUsed: 0, toolsInvoked: 0 },
+            artifacts: [],
+        };
+        let gatekeeperReview;
+        while (!phaseApproved && currentAttempt <= maxRevisions) {
+            if (currentAttempt > 0) {
+                console.log(`🔄 Phase [${phase.id}] re-execution attempt ${currentAttempt}/${maxRevisions}`);
+                this.updateStatus("running", `Phase [${phase.id}] re-execution attempt ${currentAttempt}`);
+            }
+            // Execute the phase
+            const phaseResults = await this.executeSinglePhase(phase, rollingContext);
+            mergedResult = this.mergeParallelResults(phaseResults);
+            // Gatekeeper review
+            if (this.enableGatekeeper && this.gatekeeperCoordinator) {
+                gatekeeperReview = await this.performGatekeeperReview(phase.id, phase.agentType, mergedResult, rollingContext);
+                console.log(`🔍 Gatekeeper decision for [${phase.id}]: ${gatekeeperReview.decision}`);
+                console.log(`   Confidence: ${(gatekeeperReview.confidence * 100).toFixed(1)}%`);
+                console.log(`   Issues: ${gatekeeperReview.issues.length}`);
+                console.log(`   Suggestions: ${gatekeeperReview.suggestions.length}`);
+                // Handle gatekeeper decision
+                switch (gatekeeperReview.decision) {
+                    case "approve":
+                        phaseApproved = true;
+                        break;
+                    case "request_revision":
+                        if (currentAttempt < maxRevisions) {
+                            // Prepare modified prompt based on issues
+                            const modifiedPrompt = this.prepareRevisionPrompt(phase.prompt, gatekeeperReview.issues, gatekeeperReview.suggestions);
+                            phase.prompt = modifiedPrompt;
+                            currentAttempt++;
+                            // Continue to re-execute
+                        }
+                        else {
+                            console.warn(`⚠️ Max revisions reached for phase [${phase.id}], proceeding anyway`);
+                            phaseApproved = true;
+                        }
+                        break;
+                    case "restart_from_scratch":
+                        console.error(`🚨 Gatekeeper requested restart_from_scratch for phase [${phase.id}]`);
+                        // Clear accumulated results and restart from beginning
+                        phaseApproved = true; // Continue but mark for restart
+                        break;
+                    case "escalate":
+                        console.error(`🚨 Gatekeeper escalated phase [${phase.id}]`);
+                        // Store the review and continue with warning
+                        phaseApproved = true;
+                        break;
+                }
+            }
+            else {
+                // No gatekeeper, approve automatically
+                phaseApproved = true;
+            }
+            // Store execution knowledge
+            await this.storeExecutionKnowledge(phase.id, phase.agentType, mergedResult, {
+                id: uuidv4(),
+                type: phase.agentType,
+                prompt: phase.prompt,
+                context: rollingContext,
+                successCriteria: `Complete phase: ${phase.id}`,
+            });
+            // Merge phase artifacts
+            this.artifacts.push(...mergedResult.artifacts);
+        }
+        return { phase, result: mergedResult, gatekeeperReview };
+    }
+    /**
+     * Perform gatekeeper review for a phase
+     */
+    async performGatekeeperReview(phaseId, agentType, result, context) {
+        this.updateStatus("running", `Gatekeeper reviewing phase [${phaseId}]`);
+        if (!this.gatekeeperCoordinator) {
+            throw new Error("Gatekeeper coordinator not initialized");
+        }
+        const task = {
+            id: uuidv4(),
+            type: "gatekeeper",
+            prompt: JSON.stringify(result.output),
+            context: {
+                ...context,
+                metadata: {
+                    ...context.metadata,
+                    phaseId,
+                    agentType,
+                    workOutput: result.output,
+                },
+            },
+            successCriteria: `Complete gatekeeper review for ${phaseId}`,
+        };
+        return this.gatekeeperCoordinator.submitForReview(task);
+    }
+    /**
+     * Prepare a revised prompt based on gatekeeper feedback
+     */
+    prepareRevisionPrompt(originalPrompt, issues, suggestions) {
+        let revisionGuidance = "\n\n## Gatekeeper Revision Requirements\n";
+        if (issues.length > 0) {
+            revisionGuidance += "\n### Issues to Address:\n";
+            issues.forEach((issue, idx) => {
+                revisionGuidance += `${idx + 1}. [${issue.severity.toUpperCase()}] ${issue.description}\n`;
+                if (issue.remediation) {
+                    revisionGuidance += `   Remediation: ${issue.remediation}\n`;
+                }
+            });
+        }
+        if (suggestions.length > 0) {
+            const mustHave = suggestions.filter((s) => s.priority === "must");
+            if (mustHave.length > 0) {
+                revisionGuidance += "\n### Must-Have Improvements:\n";
+                mustHave.forEach((sug, idx) => {
+                    revisionGuidance += `${idx + 1}. ${sug.description}\n`;
+                    if (sug.rationale) {
+                        revisionGuidance += `   Rationale: ${sug.rationale}\n`;
+                    }
+                });
+            }
+        }
+        return `${originalPrompt}${revisionGuidance}`;
+    }
+    /**
+     * Generate final gatekeeper report
+     */
+    generateGatekeeperReport(phaseResults) {
+        const phaseReviews = phaseResults
+            .filter((r) => r.gatekeeperReview)
+            .map((r) => r.gatekeeperReview);
+        const passedCount = phaseReviews.filter((r) => r.decision === "approve").length;
+        const needsRevisionCount = phaseReviews.filter((r) => r.decision === "request_revision").length;
+        const restartedCount = phaseReviews.filter((r) => r.decision === "restart_from_scratch").length;
+        const escalatedCount = phaseReviews.filter((r) => r.decision === "escalate").length;
+        const avgConfidence = phaseReviews.length > 0
+            ? phaseReviews.reduce((sum, r) => sum + r.confidence, 0) /
+                phaseReviews.length
+            : 1;
+        let overallDecision = "approve";
+        if (restartedCount > 0) {
+            overallDecision = "restart_from_scratch";
+        }
+        else if (needsRevisionCount > 0) {
+            overallDecision = "request_revision";
+        }
+        else if (escalatedCount > 0) {
+            overallDecision = "escalate";
+        }
+        // Build master decision
+        let masterAction = "proceed";
+        let reasoning = "All phases passed gatekeeper review";
+        if (restartedCount > 0) {
+            masterAction = "restart";
+            reasoning = `${restartedCount} phase(s) required restart`;
+        }
+        else if (needsRevisionCount > 0) {
+            masterAction = "modify_plan";
+            reasoning = `${needsRevisionCount} phase(s) had issues requiring revision`;
+        }
+        else if (escalatedCount > 0) {
+            masterAction = "stop";
+            reasoning = `${escalatedCount} phase(s) escalated for human review`;
+        }
+        const masterDecision = {
+            action: masterAction,
+            reasoning,
+            affectedPhases: phaseResults
+                .filter((r) => r.gatekeeperReview?.decision !== "approve")
+                .map((r) => r.phaseId),
+        };
+        const nextSteps = [];
+        if (masterAction === "proceed") {
+            nextSteps.push("Proceed to output synthesis");
+        }
+        else if (masterAction === "modify_plan") {
+            nextSteps.push("Apply revisions to affected phases");
+            nextSteps.push("Re-run pipeline with corrections");
+        }
+        else if (masterAction === "restart") {
+            nextSteps.push("Clear current state");
+            nextSteps.push("Restart pipeline from beginning");
+        }
+        else {
+            nextSteps.push("Request human intervention");
+            nextSteps.push("Await user instructions");
+        }
+        return {
+            overallDecision,
+            confidence: avgConfidence,
+            phaseReviews,
+            masterDecision,
+            summary: `Gatekeeper Report: ${passedCount}/${phaseReviews.length} phases passed. Decision: ${overallDecision}`,
+            nextSteps,
+            revisionHistory: [],
+        };
+    }
+    /**
+     * Execute a single phase (extracted from executePhases)
+     */
+    async executeSinglePhase(phase, rollingContext) {
+        const shouldParallelize = this.shouldParallelizePhase(phase.id, rollingContext);
+        if (shouldParallelize) {
+            return this.executePhaseInParallel(phase, rollingContext);
+        }
+        // Execute phase with single subagent
+        let result = {
+            taskId: uuidv4(),
+            success: false,
+            output: undefined,
+            error: "Phase execution failed",
+            metrics: { executionTime: 0, tokensUsed: 0, toolsInvoked: 0 },
+            artifacts: [],
+        };
+        let attempt = 0;
+        const modelCandidates = resolveModelCandidates(this.config.model);
+        while (attempt < modelCandidates.length) {
+            try {
+                const modelToUse = attempt === 0 ? this.config.model : modelCandidates[attempt];
+                const subAgent = this.getOrCreateSubAgent(phase.agentType, modelToUse);
+                const enhancedPrompt = this.enhancePromptWithContext(phase.prompt, phase.agentType, rollingContext);
+                const subTask = {
+                    id: uuidv4(),
+                    type: phase.agentType,
+                    prompt: enhancedPrompt,
+                    context: rollingContext,
+                    successCriteria: `Complete phase: ${phase.id}`,
+                };
+                this.registerSubAgent(subAgent.id, subAgent);
+                result = await this.messageBus.sendTask(this.type, phase.agentType, subTask);
+                this.unregisterSubAgent(subAgent.id);
+                if (result.success) {
+                    return [result];
+                }
+                if (result.error && isProviderModelNotFoundError(result.error)) {
+                    attempt++;
+                    continue;
+                }
+                return [result];
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                if (isProviderModelNotFoundError(errorMsg)) {
+                    attempt++;
+                    if (attempt < modelCandidates.length) {
+                        continue;
+                    }
+                }
+                return [
+                    {
+                        taskId: uuidv4(),
+                        success: false,
+                        output: undefined,
+                        error: errorMsg,
+                        metrics: { executionTime: 0, tokensUsed: 0, toolsInvoked: 0 },
+                        artifacts: [],
+                    },
+                ];
+            }
+        }
+        return [
+            {
+                taskId: uuidv4(),
+                success: false,
+                output: undefined,
+                error: "All model attempts failed",
+                metrics: { executionTime: 0, tokensUsed: 0, toolsInvoked: 0 },
+                artifacts: [],
+            },
+        ];
+    }
+    // -------------------------------------------------------------------------
+    // Parallel Execution Helpers
+    // -------------------------------------------------------------------------
+    /**
+     * Merge results from multiple parallel subagents into a single result
+     */
+    mergeParallelResults(results) {
+        if (results.length === 1) {
+            return results[0];
+        }
+        // Combine all outputs, artifacts, and metrics
+        const combinedOutputs = results
+            .filter((r) => r.success && r.output)
+            .map((r) => r.output);
+        const combinedArtifacts = results.flatMap((r) => r.artifacts || []);
+        const totalExecutionTime = results.reduce((sum, r) => sum + (r.metrics?.executionTime || 0), 0);
+        const totalTokensUsed = results.reduce((sum, r) => sum + (r.metrics?.tokensUsed || 0), 0);
+        const totalToolsInvoked = results.reduce((sum, r) => sum + (r.metrics?.toolsInvoked || 0), 0);
+        // Determine overall success
+        const allSuccessful = results.every((r) => r.success);
+        const someSuccessful = results.some((r) => r.success);
+        return {
+            taskId: uuidv4(),
+            success: allSuccessful,
+            output: combinedOutputs.length === 1
+                ? combinedOutputs[0]
+                : {
+                    results: combinedOutputs,
+                    summary: `Parallel execution: ${results.length} agents, ${someSuccessful ? "partial" : "no"} success`,
+                },
+            error: allSuccessful
+                ? undefined
+                : `Parallel execution: ${results.filter((r) => !r.success).length} of ${results.length} agents failed`,
+            metrics: {
+                executionTime: totalExecutionTime,
+                tokensUsed: totalTokensUsed,
+                toolsInvoked: totalToolsInvoked,
+            },
+            artifacts: combinedArtifacts,
+        };
+    }
+    // -------------------------------------------------------------------------
+    // Context Enhancement
+    // -------------------------------------------------------------------------
+    enhancePromptWithContext(basePrompt, _agentType, context) {
+        // Generate context-aware prompt using the context system
+        const codeContext = context.files
+            .map((f) => `File: ${f.path}\n${f.content.substring(0, 500)}...`)
+            .slice(0, 3);
+        const contextPrompt = this.contextSystem.generateContextPrompt(basePrompt, codeContext);
+        // Add relevant thoughts/knowledge
+        const relevantThoughts = this.thoughtsManager.findThoughts({
+            keywords: this.extractKeywords(basePrompt),
+            limit: 3,
+        });
+        let knowledgeContext = "";
+        if (relevantThoughts.length > 0) {
+            knowledgeContext = "\n\n## Relevant Knowledge\n";
+            for (const thought of relevantThoughts) {
+                knowledgeContext += `### ${thought.title}\n${thought.content.substring(0, 300)}...\n\n`;
+            }
+        }
+        // Combine everything and optimize for token efficiency
+        const fullPrompt = `${contextPrompt}\n\n## Task\n${basePrompt}${knowledgeContext}`;
+        // Apply DASP enhancement if enabled
+        if (this.daspEnabled && this.daspController) {
+            const daspResult = this.daspController.enhance({
+                basePrompt: fullPrompt,
+                agentType: _agentType,
+                processingMode: context.mode,
+                executionContext: context,
+                searchKeywords: this.extractKeywords(basePrompt),
+            });
+            return daspResult.enhancedPrompt;
+        }
+        // Use token optimizer to ensure we stay within limits
+        const maxTokens = 6000; // Leave room for response
+        return optimizePromptForModel(fullPrompt, this.config.model, maxTokens);
+    }
+    extractKeywords(text) {
+        // Simple keyword extraction - split by spaces and filter common words
+        const words = text.toLowerCase().split(/\W+/);
+        const stopWords = new Set([
+            "the",
+            "a",
+            "an",
+            "and",
+            "or",
+            "but",
+            "in",
+            "on",
+            "at",
+            "to",
+            "for",
+            "of",
+            "with",
+            "by",
+            "is",
+            "are",
+            "was",
+            "were",
+            "be",
+            "been",
+            "being",
+            "have",
+            "has",
+            "had",
+            "do",
+            "does",
+            "did",
+            "will",
+            "would",
+            "could",
+            "should",
+            "may",
+            "might",
+            "must",
+            "can",
+            "this",
+            "that",
+            "these",
+            "those",
+        ]);
+        return words.filter((word) => word.length > 2 && !stopWords.has(word));
+    }
+    // -------------------------------------------------------------------------
+    // Sub-Agent Lifecycle
+    // -------------------------------------------------------------------------
+    /** Get a cached sub-agent or create a fresh one from the factory */
+    getOrCreateSubAgent(type, model) {
+        // Reuse an idle registered agent of this type if available
+        for (const [, agent] of this.activeSubAgents) {
+            if (agent.type === type &&
+                agent.getStatus().status === "idle" &&
+                agent instanceof SubAgent &&
+                (!model || agent.config.model === model)) {
+                return agent;
+            }
+        }
+        const factory = this.subAgentFactory.get(type);
+        if (!factory)
+            throw new Error(`No factory registered for agent type: ${type}`);
+        const agent = factory();
+        if (!(agent instanceof SubAgent))
+            throw new Error(`Factory for ${type} did not return a SubAgent`);
+        // Set model dynamically for this execution
+        if (model) {
+            agent.config.model = model;
+        }
+        // Start the message loop so the agent can receive tasks from Master
+        const stopFn = agent.startListening();
+        this.listenerStops.set(agent.id, stopFn);
+        return agent;
+    }
+    /** Collect artifacts from master and all registered sub-agents */
+    collectAllArtifacts() {
+        const all = [...this.artifacts];
+        for (const [, agent] of this.activeSubAgents) {
+            all.push(...agent.getArtifacts());
+        }
+        return all;
+    }
+    synthesizeOutput(phases) {
+        const summary = {
+            totalPhases: phases.length,
+            successfulPhases: phases.filter((p) => p.result.success).length,
+            failedPhases: phases.filter((p) => !p.result.success).length,
+            phases: phases.map((p) => ({
+                id: p.phaseId,
+                agent: p.agentType,
+                success: p.result.success,
+                output: p.result.output,
+                error: p.result.error,
+                artifacts: p.result.artifacts.length,
+                gatekeeperDecision: p.gatekeeperReview?.decision || "none",
+                gatekeeperConfidence: p.gatekeeperReview?.confidence || 0,
+                gatekeeperIssues: p.gatekeeperReview?.issues.length || 0,
+                gatekeeperSuggestions: p.gatekeeperReview?.suggestions.length || 0,
+            })),
+            gatekeeper: {
+                enabled: this.enableGatekeeper,
+                totalReviews: phases.filter((p) => p.gatekeeperReview).length,
+                passedReviews: phases.filter((p) => p.gatekeeperReview?.decision === "approve").length,
+                revisionRequests: phases.filter((p) => p.gatekeeperReview?.decision === "request_revision").length,
+            },
+        };
+        return summary;
+    }
+    // ========================================================================
+    // Sub-Agent Registry
+    // ========================================================================
+    registerSubAgent(agentId, agent) {
+        this.activeSubAgents.set(agentId, agent);
+        agent.on("statusChange", (status) => {
+            this.emit("subAgentStatusChange", agentId, status);
+        });
+    }
+    unregisterSubAgent(agentId) {
+        const agent = this.activeSubAgents.get(agentId);
+        if (agent) {
+            // Stop the message loop
+            const stopFn = this.listenerStops.get(agentId);
+            if (stopFn) {
+                stopFn();
+                this.listenerStops.delete(agentId);
+            }
+            agent.stop();
+            this.activeSubAgents.delete(agentId);
+        }
+    }
+    getActiveSubAgents() {
+        return new Map(this.activeSubAgents);
+    }
+    // ========================================================================
+    // Context and Knowledge Management
+    // ========================================================================
+    getContextSystem() {
+        return this.contextSystem;
+    }
+    getThoughtsManager() {
+        return this.thoughtsManager;
+    }
+    getAgentConfigManager() {
+        return this.agentConfigManager;
+    }
+    getCommandProcessor() {
+        return this.commandProcessor;
+    }
+    getTeamSystem() {
+        return this.teamSystem;
+    }
+    getPluginManager() {
+        return this.pluginManager;
+    }
+    getTokenOptimizer() {
+        return this.tokenOptimizer;
+    }
+    // ========================================================================
+    // Gatekeeper Configuration
+    // ========================================================================
+    /**
+     * Enable or disable gatekeeper review
+     */
+    setGatekeeperEnabled(enabled) {
+        this.enableGatekeeper = enabled;
+        console.log(`Gatekeeper ${enabled ? "enabled" : "disabled"}`);
+    }
+    /**
+     * Check if gatekeeper is enabled
+     */
+    isGatekeeperEnabled() {
+        return this.enableGatekeeper;
+    }
+    /**
+     * Get the gatekeeper coordinator instance
+     */
+    getGatekeeperCoordinator() {
+        return this.gatekeeperCoordinator;
+    }
+    /**
+     * Configure gatekeeper review level
+     */
+    setGatekeeperReviewLevel(level) {
+        this.gatekeeperReviewLevel = level;
+        if (this.gatekeeperCoordinator) {
+            // Update all gatekeeper agents with new level
+            const statuses = this.gatekeeperCoordinator.getGatekeeperStatuses();
+            console.log(`Gatekeeper review level set to: ${level} (${statuses.size} gatekeepers available)`);
+        }
+    }
+    /**
+     * Set maximum number of revision attempts per phase
+     */
+    setGatekeeperMaxRevisions(max) {
+        this.gatekeeperMaxRevisions = Math.max(1, Math.min(10, max));
+        console.log(`Gatekeeper max revisions set to: ${this.gatekeeperMaxRevisions}`);
+    }
+    /**
+     * Get current gatekeeper configuration
+     */
+    getGatekeeperConfig() {
+        return {
+            enabled: this.enableGatekeeper,
+            reviewLevel: this.gatekeeperReviewLevel,
+            maxRevisions: this.gatekeeperMaxRevisions,
+            coordinatorStatus: this.gatekeeperCoordinator?.getGatekeeperStatuses() || null,
+        };
+    }
+    // ========================================================================
+    // Command Processing
+    // ========================================================================
+    async processCommand(command) {
+        return this.commandProcessor.processCommand(command);
+    }
+    // Store execution results as knowledge
+    async storeExecutionKnowledge(phaseId, agentType, result, task) {
+        if (!result.success || !result.output)
+            return;
+        try {
+            // Determine thought type based on phase
+            let thoughtType;
+            switch (phaseId) {
+                case "plan":
+                    thoughtType = "plan";
+                    break;
+                case "analyze":
+                    thoughtType = "analysis";
+                    break;
+                case "review":
+                    thoughtType = "review";
+                    break;
+                case "research":
+                    thoughtType = "research";
+                    break;
+                default:
+                    thoughtType = "decision";
+            }
+            // Create thought from execution result
+            this.thoughtsManager.createThought({
+                title: `${phaseId.charAt(0).toUpperCase() + phaseId.slice(1)}: ${task.prompt.substring(0, 50)}...`,
+                type: thoughtType,
+                content: typeof result.output === "string"
+                    ? result.output
+                    : JSON.stringify(result.output, null, 2),
+                tags: [agentType, phaseId, "execution"],
+                relatedFiles: task.context.files.map((f) => f.path),
+            });
+            // Learn patterns from successful executions
+            if (result.success && typeof result.output === "object") {
+                this.contextSystem.addPattern({
+                    type: "workflow",
+                    name: `${agentType} ${phaseId} pattern`,
+                    description: `Successful ${phaseId} execution pattern for ${agentType}`,
+                    examples: [
+                        {
+                            input: task.prompt,
+                            output: JSON.stringify(result.output),
+                            explanation: `Generated by ${agentType} during ${phaseId} phase`,
+                        },
+                    ],
+                    tags: [agentType, phaseId, "pattern"],
+                });
+            }
+        }
+        catch (error) {
+            console.warn("Failed to store execution knowledge:", error);
+        }
+    }
+}
+// ============================================================================
+// Sub Agent Base
+// ============================================================================
+export class SubAgent extends BaseAgent {
+    masterAgent = null;
+    constructor(type, config, messageBus, toolBridge) {
+        super(type, { mode: "subagent", ...config }, messageBus, toolBridge);
+    }
+    setMasterAgent(master) {
+        this.masterAgent = master;
+    }
+    /**
+     * Start the sub-agent's message loop.
+     * Listens for task_dispatch messages addressed to this agent type and processes them.
+     * Returns a stop function to cancel the loop.
+     */
+    startListening() {
+        let active = true;
+        const loop = async () => {
+            while (active) {
+                const msg = await this.messageBus.receive(this.type, 500);
+                if (!msg)
+                    continue;
+                if (msg.type === "task_dispatch") {
+                    const task = msg.payload;
+                    const result = await this.execute(task);
+                    // Reply to Master with the result, correlating to the dispatch message
+                    await this.messageBus.sendTaskResult(this.type, msg.sender, result, msg.id);
+                }
+                else if (msg.type === "abort_signal") {
+                    await this.abort("abort_signal received");
+                    break;
+                }
+            }
+        };
+        // Run the loop in the background (fire-and-forget)
+        loop().catch((err) => {
+            console.error(`[${this.type}] Message loop error:`, err);
+        });
+        return () => {
+            active = false;
+        };
+    }
+    async execute(task) {
+        const startTime = Date.now();
+        await this.start();
+        try {
+            const result = await this.performTask(task);
+            const executionTime = Date.now() - startTime;
+            this.recordTaskCompletion(0, 0, executionTime);
+            this.updateStatus("completed");
+            return {
+                taskId: task.id,
+                success: true,
+                output: result,
+                metrics: { executionTime, tokensUsed: 0, toolsInvoked: 0 },
+                artifacts: this.artifacts,
+            };
+        }
+        catch (error) {
+            this.recordTaskFailure();
+            this.updateStatus("error");
+            return {
+                taskId: task.id,
+                success: false,
+                output: undefined,
+                error: error instanceof Error ? error.message : String(error),
+                metrics: {
+                    executionTime: Date.now() - startTime,
+                    tokensUsed: 0,
+                    toolsInvoked: 0,
+                },
+                artifacts: [],
+            };
+        }
+        finally {
+            await this.stop();
+        }
+    }
+}
+// ============================================================================
+// Specialized Sub-Agents
+// ============================================================================
+export class PlannerAgent extends SubAgent {
+    async performTask(task) {
+        this.updateStatus("running", "Creating execution plan");
+        const prompt = `Create a detailed execution plan for the following task:
+
+Task: ${task.prompt}
+
+Context: ${task.context.files.length} files provided, mode: ${task.context.metadata?.mode || "full"}
+
+Please provide a structured plan with:
+1. Goal analysis
+2. Step-by-step breakdown
+3. Estimated complexity (low/medium/high)
+4. Estimated time
+5. Required tools/resources
+6. Potential risks
+
+Format as structured JSON.`;
+        const response = await this.callModel(prompt);
+        if (!response) {
+            return this.localPlanFallback(task);
+        }
+        try {
+            return JSON.parse(response);
+        }
+        catch {
+            return {
+                goal: task.prompt,
+                plan: response,
+                ...this.estimateComplexityFromText(task.prompt),
+            };
+        }
+    }
+    /**
+     * Local fallback: parse task description to build a real plan without a model.
+     */
+    localPlanFallback(task) {
+        const description = task.prompt || "";
+        const lower = description.toLowerCase();
+        const fileCount = task.context.files.length;
+        // --- Extract action verbs and targets ---
+        const actionPatterns = [
+            {
+                verb: "create",
+                regex: /\b(?:create|build|generate|scaffold|add|implement|write)\s+(?:a\s+)?(.+?)(?:\s+(?:and|then|,|\.)|$)/gi,
+            },
+            {
+                verb: "refactor",
+                regex: /\b(?:refactor|restructure|reorganize|redesign)\s+(?:the\s+)?(.+?)(?:\s+(?:and|then|,|\.)|$)/gi,
+            },
+            {
+                verb: "fix",
+                regex: /\b(?:fix|repair|resolve|patch|debug)\s+(?:the\s+)?(.+?)(?:\s+(?:and|then|,|\.)|$)/gi,
+            },
+            {
+                verb: "update",
+                regex: /\b(?:update|modify|change|edit|adjust|improve)\s+(?:the\s+)?(.+?)(?:\s+(?:and|then|,|\.)|$)/gi,
+            },
+            {
+                verb: "test",
+                regex: /\b(?:test|verify|validate|check)\s+(?:the\s+)?(.+?)(?:\s+(?:and|then|,|\.)|$)/gi,
+            },
+            {
+                verb: "delete",
+                regex: /\b(?:delete|remove|drop|clean\s*up)\s+(?:the\s+)?(.+?)(?:\s+(?:and|then|,|\.)|$)/gi,
+            },
+            {
+                verb: "migrate",
+                regex: /\b(?:migrate|move|transfer|port)\s+(?:the\s+)?(.+?)(?:\s+(?:and|then|,|\.)|$)/gi,
+            },
+            {
+                verb: "deploy",
+                regex: /\b(?:deploy|publish|release|ship)\s+(?:the\s+)?(.+?)(?:\s+(?:and|then|,|\.)|$)/gi,
+            },
+            {
+                verb: "analyze",
+                regex: /\b(?:analyze|inspect|examine|review|audit)\s+(?:the\s+)?(.+?)(?:\s+(?:and|then|,|\.)|$)/gi,
+            },
+            {
+                verb: "configure",
+                regex: /\b(?:configure|setup|set\s*up|initialize|install)\s+(?:the\s+)?(.+?)(?:\s+(?:and|then|,|\.)|$)/gi,
+            },
+        ];
+        const extractedActions = [];
+        for (const { verb, regex } of actionPatterns) {
+            let match;
+            while ((match = regex.exec(description)) !== null) {
+                const target = match[1]?.trim().substring(0, 80) || "the task";
+                if (target.length > 2) {
+                    extractedActions.push({ verb, target });
+                }
+            }
+        }
+        // --- Build steps from extracted actions or sentence splitting ---
+        let steps;
+        if (extractedActions.length > 0) {
+            steps = extractedActions.map((action, idx) => ({
+                step: idx + 1,
+                action: action.verb,
+                description: `${action.verb.charAt(0).toUpperCase() + action.verb.slice(1)} ${action.target}`,
+                dependsOn: idx > 0 ? [idx] : [],
+            }));
+        }
+        else {
+            // Split by conjunctions, commas, or sentence boundaries
+            const segments = description
+                .split(/(?:\s+and\s+|\s*,\s*|\.\s+|\s+then\s+)/i)
+                .map((s) => s.trim())
+                .filter((s) => s.length > 3);
+            if (segments.length > 1) {
+                steps = segments.map((seg, idx) => ({
+                    step: idx + 1,
+                    action: "execute",
+                    description: seg.charAt(0).toUpperCase() + seg.slice(1),
+                    dependsOn: idx > 0 ? [idx] : [],
+                }));
+            }
+            else {
+                // Single task — generate analysis → implementation → verification steps
+                steps = [
+                    {
+                        step: 1,
+                        action: "analyze",
+                        description: `Analyze requirements: ${description.substring(0, 100)}`,
+                        dependsOn: [],
+                    },
+                    {
+                        step: 2,
+                        action: "implement",
+                        description: `Implement changes for: ${description.substring(0, 80)}`,
+                        dependsOn: [1],
+                    },
+                    {
+                        step: 3,
+                        action: "verify",
+                        description: "Verify implementation and check for regressions",
+                        dependsOn: [2],
+                    },
+                ];
+            }
+        }
+        // Add file-scope step if files are present
+        if (fileCount > 0 && steps.length > 0) {
+            steps.unshift({
+                step: 0,
+                action: "scan",
+                description: `Scan ${fileCount} provided file(s) for context`,
+                dependsOn: [],
+            });
+            // Re-number and adjust deps
+            steps = steps.map((s, idx) => ({
+                ...s,
+                step: idx + 1,
+                dependsOn: idx === 0 ? [] : s.dependsOn.map((d) => d + 1),
+            }));
+        }
+        // --- Estimate complexity ---
+        const complexity = this.estimateComplexityFromText(lower);
+        // --- Required tools based on keywords ---
+        const tools = [];
+        if (/\b(file|read|write|edit|create)\b/i.test(lower))
+            tools.push("file_operations");
+        if (/\b(test|spec|jest|mocha|vitest)\b/i.test(lower))
+            tools.push("testing_framework");
+        if (/\b(git|commit|branch|merge|pr)\b/i.test(lower))
+            tools.push("version_control");
+        if (/\b(npm|yarn|pnpm|install|package)\b/i.test(lower))
+            tools.push("package_manager");
+        if (/\b(api|endpoint|http|fetch|request)\b/i.test(lower))
+            tools.push("http_client");
+        if (/\b(db|database|sql|query|schema|migration)\b/i.test(lower))
+            tools.push("database");
+        if (/\b(docker|container|deploy|ci|cd)\b/i.test(lower))
+            tools.push("devops");
+        if (tools.length === 0)
+            tools.push("code_editor");
+        // --- Risks ---
+        const risks = [];
+        if (/\b(refactor|migrate|restructure)\b/i.test(lower))
+            risks.push("Breaking changes in dependent code");
+        if (/\b(delete|remove|drop)\b/i.test(lower))
+            risks.push("Data or code loss if not backed up");
+        if (/\b(security|auth|password|token|secret)\b/i.test(lower))
+            risks.push("Security-sensitive changes require careful review");
+        if (fileCount > 10)
+            risks.push(`Large scope: ${fileCount} files may have cascading impacts`);
+        if (/\b(production|prod|live)\b/i.test(lower))
+            risks.push("Changes target production environment");
+        if (risks.length === 0)
+            risks.push("Standard development risk — verify with tests");
+        return {
+            goal: task.prompt,
+            steps,
+            ...complexity,
+            requiredTools: tools,
+            risks,
+            fileScope: fileCount,
+            note: "Plan generated via local keyword analysis (no model available)",
+        };
+    }
+    /**
+     * Estimate complexity from task description text.
+     */
+    estimateComplexityFromText(text) {
+        const lower = text.toLowerCase();
+        const wordCount = text.split(/\s+/).length;
+        // High complexity indicators
+        const highKeywords = /\b(refactor|migrate|integrate|redesign|architect|overhaul|rewrite|restructure|distributed|concurrent|multi.?thread)\b/i;
+        // Low complexity indicators
+        const lowKeywords = /\b(rename|move|delete|remove|typo|comment|log|print|bump|update version|fix typo)\b/i;
+        let complexity;
+        let time;
+        if (highKeywords.test(lower) || wordCount > 80) {
+            complexity = "high";
+            time = "15-30 minutes";
+        }
+        else if (lowKeywords.test(lower) && wordCount < 20) {
+            complexity = "low";
+            time = "1-3 minutes";
+        }
+        else {
+            complexity = "medium";
+            time = "5-10 minutes";
+        }
+        return { estimatedComplexity: complexity, estimatedTime: time };
+    }
+}
+export class AnalyzerAgent extends SubAgent {
+    async performTask(task) {
+        this.updateStatus("running", "Analyzing code");
+        const files = task.context.files;
+        const fileContents = files
+            .map((f) => `File: ${f.path}\n\n${f.content}`)
+            .join("\n\n---\n\n");
+        const prompt = `Analyze the following code files for issues, patterns, and improvements:
+
+${fileContents}
+
+Please provide:
+1. Code quality issues
+2. Security vulnerabilities
+3. Performance bottlenecks
+4. Best practice violations
+5. Complexity metrics
+6. Maintainability assessment
+
+Format as structured JSON.`;
+        const response = await this.callModel(prompt);
+        if (!response) {
+            return this.localAnalysisFallback(files);
+        }
+        // Parse AI response
+        try {
+            const analysis = JSON.parse(response);
+            return analysis;
+        }
+        catch {
+            return {
+                file: task.context.files[0]?.path || "unknown",
+                analysis: response,
+                issues: [],
+                metrics: this.computeFileMetrics(files),
+            };
+        }
+    }
+    /**
+     * Local fallback: perform real static analysis on provided files without a model.
+     */
+    localAnalysisFallback(files) {
+        const allIssues = [];
+        const perFileMetrics = [];
+        for (const file of files) {
+            const content = file.content || "";
+            const lines = content.split("\n");
+            const lineCount = lines.length;
+            // --- Basic metrics ---
+            let blankLines = 0;
+            let commentLines = 0;
+            let importCount = 0;
+            let exportCount = 0;
+            // --- Function/class detection ---
+            const functionMatches = content.match(/\b(?:function\s+\w+|(?:const|let|var)\s+\w+\s*=\s*(?:async\s+)?(?:\([^)]*\)|[a-zA-Z_$]\w*)\s*=>|(?:async\s+)?(?:get|set|static\s+)?\w+\s*\([^)]*\)\s*\{)/g) || [];
+            const classMatches = content.match(/\bclass\s+\w+/g) || [];
+            // --- Cyclomatic complexity (count decision points) ---
+            let cyclomaticComplexity = 1; // Base
+            const decisionPatterns = /\b(?:if|else\s+if|case|for|while|do|catch|\?\?|&&|\|\||[?]:)/g;
+            // @ts-ignore
+            let _decMatch;
+            while ((_decMatch = decisionPatterns.exec(content)) !== null) {
+                cyclomaticComplexity++;
+            }
+            // --- Nesting depth analysis ---
+            let maxNesting = 0;
+            let currentNesting = 0;
+            for (const ch of content) {
+                if (ch === "{") {
+                    currentNesting++;
+                    if (currentNesting > maxNesting)
+                        maxNesting = currentNesting;
+                }
+                else if (ch === "}") {
+                    currentNesting = Math.max(0, currentNesting - 1);
+                }
+            }
+            // --- Longest function length ---
+            let longestFn = 0;
+            let fnNesting = 0;
+            let fnStartLine = -1;
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                const trimmed = line.trim();
+                // Track blank/comment/import/export lines
+                if (trimmed === "") {
+                    blankLines++;
+                }
+                else if (trimmed.startsWith("//") ||
+                    trimmed.startsWith("/*") ||
+                    trimmed.startsWith("*")) {
+                    commentLines++;
+                }
+                if (/^import\s/.test(trimmed))
+                    importCount++;
+                if (/^export\s/.test(trimmed))
+                    exportCount++;
+                // Simple function length tracking
+                if (/(?:function\s+\w+|=>\s*\{|\)\s*\{)\s*$/.test(trimmed) &&
+                    fnStartLine === -1) {
+                    fnStartLine = i;
+                    fnNesting = 0;
+                }
+                if (fnStartLine !== -1) {
+                    for (const ch of line) {
+                        if (ch === "{")
+                            fnNesting++;
+                        if (ch === "}")
+                            fnNesting--;
+                    }
+                    if (fnNesting <= 0 && fnStartLine !== -1) {
+                        const fnLen = i - fnStartLine + 1;
+                        if (fnLen > longestFn)
+                            longestFn = fnLen;
+                        fnStartLine = -1;
+                    }
+                }
+            }
+            perFileMetrics.push({
+                file: file.path,
+                linesOfCode: lineCount,
+                blankLines,
+                commentLines,
+                functions: functionMatches.length,
+                classes: classMatches.length,
+                imports: importCount,
+                exports: exportCount,
+                cyclomaticComplexity,
+                maxNestingDepth: maxNesting,
+                longestFunctionLength: longestFn,
+            });
+            // --- Issue detection ---
+            // Long functions (>50 lines)
+            if (longestFn > 50) {
+                allIssues.push({
+                    type: "maintainability",
+                    severity: longestFn > 100 ? "high" : "medium",
+                    file: file.path,
+                    description: `Longest function is ${longestFn} lines (threshold: 50)`,
+                    recommendation: "Break large functions into smaller, focused helper functions",
+                });
+            }
+            // Deep nesting (>4 levels)
+            if (maxNesting > 4) {
+                allIssues.push({
+                    type: "complexity",
+                    severity: maxNesting > 6 ? "high" : "medium",
+                    file: file.path,
+                    description: `Maximum nesting depth is ${maxNesting} levels (threshold: 4)`,
+                    recommendation: "Use early returns, guard clauses, or extract nested logic into functions",
+                });
+            }
+            // High cyclomatic complexity
+            if (cyclomaticComplexity > 20) {
+                allIssues.push({
+                    type: "complexity",
+                    severity: cyclomaticComplexity > 40 ? "high" : "medium",
+                    file: file.path,
+                    description: `Cyclomatic complexity is ${cyclomaticComplexity} (threshold: 20)`,
+                    recommendation: "Simplify control flow; consider strategy pattern or lookup tables",
+                });
+            }
+            // TODO/FIXME comments
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                if (/\bTODO\b/i.test(line)) {
+                    allIssues.push({
+                        type: "best_practice",
+                        severity: "low",
+                        file: file.path,
+                        line: i + 1,
+                        description: `TODO comment: ${line.trim().substring(0, 100)}`,
+                        recommendation: "Address TODO items or create tracking issues",
+                    });
+                }
+                if (/\bFIXME\b/i.test(line)) {
+                    allIssues.push({
+                        type: "best_practice",
+                        severity: "medium",
+                        file: file.path,
+                        line: i + 1,
+                        description: `FIXME comment: ${line.trim().substring(0, 100)}`,
+                        recommendation: "FIXME indicates known bugs — prioritize fixing",
+                    });
+                }
+            }
+            // console.log statements
+            const consoleLogLines = [];
+            for (let i = 0; i < lines.length; i++) {
+                if (/\bconsole\.(log|debug|info)\b/.test(lines[i]) &&
+                    !/\/\//.test(lines[i].split("console")[0])) {
+                    consoleLogLines.push(i + 1);
+                }
+            }
+            if (consoleLogLines.length > 0) {
+                allIssues.push({
+                    type: "best_practice",
+                    severity: "low",
+                    file: file.path,
+                    line: consoleLogLines[0],
+                    description: `Found ${consoleLogLines.length} console.log/debug/info statement(s) at lines: ${consoleLogLines.slice(0, 5).join(", ")}${consoleLogLines.length > 5 ? "..." : ""}`,
+                    recommendation: "Remove debug logging or replace with a proper logging framework",
+                });
+            }
+            // Unused imports detection (basic: imported names not found elsewhere in file)
+            const importLines = lines.filter((l) => /^import\s/.test(l.trim()));
+            for (const impLine of importLines) {
+                const namedImports = impLine.match(/\{\s*([^}]+)\s*\}/);
+                if (namedImports) {
+                    const names = namedImports[1]
+                        .split(",")
+                        .map((n) => n
+                        .trim()
+                        .split(/\s+as\s+/)
+                        .pop()
+                        ?.trim())
+                        .filter(Boolean);
+                    for (const name of names) {
+                        if (!name)
+                            continue;
+                        // Count occurrences outside import lines
+                        const restOfFile = lines
+                            .filter((l) => !/^import\s/.test(l.trim()))
+                            .join("\n");
+                        const nameRegex = new RegExp(`\\b${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "g");
+                        const usageCount = (restOfFile.match(nameRegex) || []).length;
+                        if (usageCount === 0) {
+                            allIssues.push({
+                                type: "best_practice",
+                                severity: "low",
+                                file: file.path,
+                                description: `Potentially unused import: '${name}'`,
+                                recommendation: "Remove unused imports to keep the codebase clean",
+                            });
+                        }
+                    }
+                }
+            }
+            // 'any' type usage in TypeScript files
+            if (/\.tsx?$/.test(file.path)) {
+                const anyMatches = [];
+                for (let i = 0; i < lines.length; i++) {
+                    if (/:\s*any\b|as\s+any\b|<any>/.test(lines[i])) {
+                        anyMatches.push(i + 1);
+                    }
+                }
+                if (anyMatches.length > 0) {
+                    allIssues.push({
+                        type: "type_safety",
+                        severity: anyMatches.length > 5 ? "medium" : "low",
+                        file: file.path,
+                        line: anyMatches[0],
+                        description: `Found ${anyMatches.length} 'any' type usage(s) at lines: ${anyMatches.slice(0, 5).join(", ")}${anyMatches.length > 5 ? "..." : ""}`,
+                        recommendation: "Replace 'any' with specific types for better type safety",
+                    });
+                }
+            }
+            // Missing error handling in async functions
+            const asyncFnPattern = /\basync\s+(?:function\s+\w+|\w+\s*=\s*async|\([^)]*\)\s*=>)/g;
+            const asyncCount = (content.match(asyncFnPattern) || []).length;
+            const tryCatchCount = (content.match(/\btry\s*\{/g) || []).length;
+            const catchCount = (content.match(/\.catch\s*\(/g) || []).length;
+            if (asyncCount > 0 && tryCatchCount + catchCount < asyncCount * 0.5) {
+                allIssues.push({
+                    type: "error_handling",
+                    severity: "medium",
+                    file: file.path,
+                    description: `${asyncCount} async function(s) but only ${tryCatchCount + catchCount} error handler(s) — potential unhandled rejections`,
+                    recommendation: "Wrap async operations in try/catch or add .catch() handlers",
+                });
+            }
+            // Hardcoded strings that look like secrets
+            for (let i = 0; i < lines.length; i++) {
+                if (/(?:password|secret|apiKey|api_key|token|AUTH)\s*[:=]\s*["'][^"']{8,}["']/i.test(lines[i])) {
+                    allIssues.push({
+                        type: "security",
+                        severity: "high",
+                        file: file.path,
+                        line: i + 1,
+                        description: "Potential hardcoded secret or credential detected",
+                        recommendation: "Move secrets to environment variables or a secure vault",
+                    });
+                }
+            }
+            // Very long lines (>120 chars)
+            const longLines = lines.filter((l) => l.length > 120).length;
+            if (longLines > 10) {
+                allIssues.push({
+                    type: "style",
+                    severity: "low",
+                    file: file.path,
+                    description: `${longLines} lines exceed 120 characters`,
+                    recommendation: "Consider reformatting for readability (use prettier or similar)",
+                });
+            }
+        }
+        // --- Aggregate metrics ---
+        const totalLOC = perFileMetrics.reduce((s, m) => s + m.linesOfCode, 0);
+        const totalFunctions = perFileMetrics.reduce((s, m) => s + m.functions, 0);
+        const totalClasses = perFileMetrics.reduce((s, m) => s + m.classes, 0);
+        const avgComplexity = perFileMetrics.length > 0
+            ? perFileMetrics.reduce((s, m) => s + m.cyclomaticComplexity, 0) /
+                perFileMetrics.length
+            : 0;
+        // Maintainability index (simplified Halstead-based formula)
+        // Higher is better. Penalize for high complexity, deep nesting, low comment ratio.
+        const commentRatio = totalLOC > 0
+            ? perFileMetrics.reduce((s, m) => s + m.commentLines, 0) / totalLOC
+            : 0;
+        const avgNesting = perFileMetrics.length > 0
+            ? perFileMetrics.reduce((s, m) => s + m.maxNestingDepth, 0) /
+                perFileMetrics.length
+            : 0;
+        const maintainabilityIndex = Math.max(0, Math.min(100, 100 - avgComplexity * 0.5 - avgNesting * 3 + commentRatio * 30));
+        // Sort issues by severity
+        const severityOrder = {
+            high: 0,
+            medium: 1,
+            low: 2,
+        };
+        allIssues.sort((a, b) => (severityOrder[a.severity] ?? 3) - (severityOrder[b.severity] ?? 3));
+        return {
+            filesAnalyzed: files.map((f) => f.path),
+            issues: allIssues,
+            metrics: {
+                totalLinesOfCode: totalLOC,
+                totalFunctions,
+                totalClasses,
+                averageCyclomaticComplexity: Math.round(avgComplexity * 10) / 10,
+                maintainabilityIndex: Math.round(maintainabilityIndex * 10) / 10,
+            },
+            perFileMetrics,
+            summary: {
+                totalIssues: allIssues.length,
+                highSeverity: allIssues.filter((i) => i.severity === "high").length,
+                mediumSeverity: allIssues.filter((i) => i.severity === "medium").length,
+                lowSeverity: allIssues.filter((i) => i.severity === "low").length,
+                issueTypes: [...new Set(allIssues.map((i) => i.type))],
+            },
+            note: "Analysis performed via local static analysis (no model available)",
+        };
+    }
+    /**
+     * Compute basic file metrics for JSON parse fallback.
+     */
+    computeFileMetrics(files) {
+        const totalLOC = files.reduce((sum, f) => sum + (f.content || "").split("\n").length, 0);
+        const totalFunctions = files.reduce((sum, f) => sum + ((f.content || "").match(/\bfunction\s+\w+/g) || []).length, 0);
+        const avgLineLength = totalLOC > 0
+            ? Math.round(files.reduce((sum, f) => sum + f.content.length, 0) / totalLOC)
+            : 0;
+        return {
+            linesOfCode: totalLOC,
+            functions: totalFunctions,
+            averageLineLength: avgLineLength,
+        };
+    }
+}
+export class ReviewerAgent extends SubAgent {
+    async performTask(task) {
+        this.updateStatus("running", "Reviewing changes");
+        const analysisOutput = task.context.metadata?.analyze_output;
+        const prompt = `Review the following code analysis and provide feedback:
+
+Analysis: ${JSON.stringify(analysisOutput, null, 2)}
+
+Task: ${task.prompt}
+
+Please provide:
+1. Overall assessment
+2. Fixes reviewed
+3. Blocking issues (if any)
+4. Recommendations for improvement
+
+Format as structured JSON.`;
+        const response = await this.callModel(prompt);
+        if (!response) {
+            return this.localReviewFallback(task);
+        }
+        try {
+            return JSON.parse(response);
+        }
+        catch {
+            return {
+                reviewId: uuidv4(),
+                review: response,
+                // @ts-ignore
+                ...this.localReviewFallback(task),
+            };
+        }
+    }
+    /**
+     * Local fallback: review code quality based on analysis output and file content.
+     */
+    localReviewFallback(task) {
+        const analysisOutput = task.context.metadata?.analyze_output;
+        const files = task.context.files;
+        const fixesReviewed = [];
+        const blockingIssues = [];
+        const recommendations = [];
+        let assessmentPoints = 0;
+        let maxPoints = 0;
+        // --- Review analysis output if available ---
+        if (analysisOutput && typeof analysisOutput === "object") {
+            const analysis = analysisOutput;
+            const issues = analysis.issues || [];
+            // Check for blocking issues from analysis
+            for (const issue of issues) {
+                const severity = issue.severity || "low";
+                if (severity === "high" || severity === "critical") {
+                    blockingIssues.push({
+                        severity,
+                        description: issue.description ||
+                            "High severity issue from analysis",
+                        file: issue.file,
+                    });
+                }
+            }
+            if (issues.length > 0) {
+                fixesReviewed.push({
+                    file: "analysis",
+                    status: blockingIssues.length > 0 ? "needs_attention" : "reviewed",
+                    notes: `Analysis found ${issues.length} issue(s), ${blockingIssues.length} blocking`,
+                });
+            }
+        }
+        // --- Review each file for common quality issues ---
+        for (const file of files) {
+            const content = file.content || "";
+            const lines = content.split("\n");
+            const fileIssues = [];
+            maxPoints += 5; // 5 quality checks per file
+            // 1. Error handling presence
+            const hasAsync = /\basync\b/.test(content);
+            const hasTryCatch = /\btry\s*\{/.test(content);
+            const hasCatch = /\.catch\s*\(/.test(content);
+            if (hasAsync && !hasTryCatch && !hasCatch) {
+                fileIssues.push("Missing error handling for async operations");
+            }
+            else {
+                assessmentPoints++;
+            }
+            // 2. Type safety (TS files)
+            if (/\.tsx?$/.test(file.path)) {
+                const anyCount = (content.match(/:\s*any\b|as\s+any\b/g) || []).length;
+                if (anyCount > 3) {
+                    fileIssues.push(`Excessive 'any' types (${anyCount} occurrences) — weakens type safety`);
+                }
+                else {
+                    assessmentPoints++;
+                }
+            }
+            else {
+                assessmentPoints++; // Non-TS files get a pass on type safety
+            }
+            // 3. Naming conventions check
+            const badNames = content.match(/\b(?:const|let|var)\s+(?:[a-z]|_\d)\s*=/g) || [];
+            const singleCharVars = badNames.filter((m) => /\s[a-z_]\s*=/.test(m) && !/\b(i|j|k|x|y|z|e|_)\s*=/.test(m));
+            if (singleCharVars.length > 3) {
+                fileIssues.push(`Multiple single-character variable names — use descriptive names`);
+            }
+            else {
+                assessmentPoints++;
+            }
+            // 4. Null/undefined safety
+            const nullAccess = (content.match(/\.\w+\.\w+/g) || []).length; // chain access count
+            const optionalChaining = (content.match(/\?\./g) || []).length;
+            const nullChecks = (content.match(/!==?\s*(?:null|undefined)|typeof\s+\w+\s*!==?\s*["']undefined["']/g) || []).length;
+            if (nullAccess > 10 && optionalChaining === 0 && nullChecks < 2) {
+                fileIssues.push("Multiple property chains without null checks — consider optional chaining (?.)");
+            }
+            else {
+                assessmentPoints++;
+            }
+            // 5. Hardcoded values
+            const hardcoded = [];
+            for (let i = 0; i < lines.length; i++) {
+                // Magic numbers (excluding common ones like 0, 1, 2, -1, 100)
+                if (/(?:timeout|delay|interval|limit|max|min|size|count|threshold)\s*[:=]\s*\d{3,}/i.test(lines[i])) {
+                    hardcoded.push(`line ${i + 1}: hardcoded numeric value`);
+                }
+            }
+            if (hardcoded.length > 2) {
+                fileIssues.push(`${hardcoded.length} hardcoded magic numbers — extract as named constants`);
+            }
+            else {
+                assessmentPoints++;
+            }
+            if (fileIssues.length > 0) {
+                fixesReviewed.push({
+                    file: file.path,
+                    status: fileIssues.some((i) => i.includes("error handling") || i.includes("type safety"))
+                        ? "needs_attention"
+                        : "minor_issues",
+                    notes: fileIssues.join("; "),
+                });
+                for (const issue of fileIssues) {
+                    recommendations.push(`[${file.path}] ${issue}`);
+                }
+            }
+            else {
+                fixesReviewed.push({
+                    file: file.path,
+                    status: "passed",
+                    notes: "No significant quality issues detected",
+                });
+            }
+        }
+        // --- Calculate confidence based on how much analysis was possible ---
+        const confidence = maxPoints > 0
+            ? Math.round((assessmentPoints / maxPoints) * 100) / 100
+            : 0.3;
+        // --- Build overall assessment ---
+        let overallAssessment;
+        if (blockingIssues.length > 0) {
+            overallAssessment = `Blocking issues found: ${blockingIssues.length} high/critical issue(s) require attention before proceeding.`;
+        }
+        else if (recommendations.length > 3) {
+            overallAssessment = `Code has ${recommendations.length} quality concerns that should be addressed. Review the recommendations for improvements.`;
+        }
+        else if (recommendations.length > 0) {
+            overallAssessment = `Code is generally acceptable with ${recommendations.length} minor suggestion(s). Consider addressing them in a follow-up.`;
+        }
+        else if (files.length === 0) {
+            overallAssessment =
+                "No files provided for review. Unable to perform meaningful analysis.";
+        }
+        else {
+            overallAssessment = `Code passed basic quality checks across ${files.length} file(s). No significant issues detected.`;
+        }
+        // --- Standard recommendations ---
+        if (files.length > 0) {
+            const totalLOC = files.reduce((s, f) => s + (f.content || "").split("\n").length, 0);
+            if (totalLOC > 500 && !files.some((f) => /test|spec/i.test(f.path))) {
+                recommendations.push("Consider adding unit tests — no test files detected for this codebase");
+            }
+        }
+        return {
+            reviewId: uuidv4(),
+            fixesReviewed,
+            overallAssessment,
+            blockingIssues,
+            recommendations,
+            confidence,
+            qualityScore: maxPoints > 0 ? `${assessmentPoints}/${maxPoints}` : "N/A",
+            note: "Review performed via local static analysis (no model available)",
+        };
+    }
+}
+export class RewriterAgent extends SubAgent {
+    async performTask(task) {
+        this.updateStatus("running", "Applying fixes");
+        const analysisOutput = task.context.metadata?.analyze_output;
+        const reviewOutput = task.context.metadata?.review_output;
+        const files = task.context.files;
+        const fileContents = files
+            .map((f) => `File: ${f.path}\n\n${f.content}`)
+            .join("\n\n---\n\n");
+        const prompt = `Apply fixes to the following code based on the analysis and review:
+
+Analysis: ${JSON.stringify(analysisOutput, null, 2)}
+
+Review: ${JSON.stringify(reviewOutput, null, 2)}
+
+Task: ${task.prompt}
+
+Code Files:
+${fileContents}
+
+Please provide:
+1. Specific code changes needed
+2. New files to create (if any)
+3. Files to delete (if any)
+4. Explanation of each change
+
+Format as structured JSON with file paths as keys and change objects as values.`;
+        const response = await this.callModel(prompt);
+        if (!response) {
+            return this.localRewriteFallback(files, analysisOutput, reviewOutput);
+        }
+        try {
+            return JSON.parse(response);
+        }
+        catch {
+            return {
+                changes: [],
+                newFiles: [],
+                deletedFiles: [],
+                explanation: response,
+            };
+        }
+    }
+    /**
+     * Local fallback: apply basic code transformations without a model.
+     */
+    localRewriteFallback(
+    // @ts-ignore
+    _files, _analysisOutput, _reviewOutput) {
+        const changes = [];
+        for (const file of files) {
+            const content = file.content || "";
+            if (!content.trim())
+                continue;
+            const transformations = [];
+            let result = content;
+            // --- 1. Remove trailing whitespace ---
+            const beforeTrailing = result;
+            result = result.replace(/[ \t]+$/gm, "");
+            if (result !== beforeTrailing) {
+                transformations.push("Removed trailing whitespace");
+            }
+            // --- 2. Normalize line endings to LF ---
+            if (result.includes("\r\n")) {
+                result = result.replace(/\r\n/g, "\n");
+                transformations.push("Normalized line endings (CRLF → LF)");
+            }
+            // --- 3. Normalize indentation (detect and standardize) ---
+            const lines = result.split("\n");
+            const tabLines = lines.filter((l) => l.startsWith("\t")).length;
+            const spaceLines = lines.filter((l) => /^ {2,}/.test(l)).length;
+            // Only normalize if there's a clear mix
+            if (tabLines > 0 && spaceLines > tabLines * 2) {
+                // Convert tabs to 2-space indent
+                result = result.replace(/^\t+/gm, (match) => "  ".repeat(match.length));
+                transformations.push("Converted tab indentation to 2-space");
+            }
+            // --- 4. Add missing semicolons for JS/TS files ---
+            if (/\.[jt]sx?$/.test(file.path)) {
+                const resultLines = result.split("\n");
+                const semiFixedLines = resultLines.map((line) => {
+                    const trimmed = line.trim();
+                    // Skip lines that don't need semicolons
+                    if (!trimmed ||
+                        trimmed.endsWith(";") ||
+                        trimmed.endsWith("{") ||
+                        trimmed.endsWith("}") ||
+                        trimmed.endsWith("(") ||
+                        trimmed.endsWith(",") ||
+                        trimmed.endsWith("*/") ||
+                        trimmed.startsWith("//") ||
+                        trimmed.startsWith("/*") ||
+                        trimmed.startsWith("*") ||
+                        trimmed.startsWith("import ") ||
+                        trimmed.startsWith("export ") ||
+                        /^(?:if|else|for|while|switch|case|default|try|catch|finally|do|class|interface|type|enum)\b/.test(trimmed) ||
+                        trimmed.endsWith("=>") ||
+                        trimmed.endsWith("?") ||
+                        trimmed.endsWith(":") ||
+                        trimmed.endsWith("||") ||
+                        trimmed.endsWith("&&")) {
+                        return line;
+                    }
+                    // Add semicolons to statement-like lines ending with closing paren, string, number, identifier
+                    if (/(?:\)|\]|['"`]|\w)\s*$/.test(trimmed)) {
+                        // Check if it's a standalone statement (assignment, return, throw, const/let/var)
+                        if (/^(?:return|throw|const|let|var|yield)\b/.test(trimmed) ||
+                            /^[\w$]+\s*[+\-*/]?=\s/.test(trimmed) ||
+                            /^(?:await\s+)?[\w$]+\s*\(/.test(trimmed)) {
+                            return line.replace(/\s*$/, ";");
+                        }
+                    }
+                    return line;
+                });
+                const semiResult = semiFixedLines.join("\n");
+                if (semiResult !== result) {
+                    result = semiResult;
+                    transformations.push("Added missing semicolons to statement lines");
+                }
+            }
+            // --- 5. Sort imports alphabetically ---
+            if (/\.[jt]sx?$/.test(file.path)) {
+                const importResult = this.sortImports(result);
+                if (importResult !== result) {
+                    result = importResult;
+                    transformations.push("Sorted import statements alphabetically");
+                }
+            }
+            // --- 6. Remove consecutive blank lines (keep max 1) ---
+            const beforeBlank = result;
+            result = result.replace(/\n{3,}/g, "\n\n");
+            if (result !== beforeBlank) {
+                transformations.push("Collapsed excessive blank lines");
+            }
+            // --- 7. Ensure file ends with newline ---
+            if (!result.endsWith("\n")) {
+                result += "\n";
+                transformations.push("Added trailing newline");
+            }
+            if (transformations.length > 0) {
+                changes.push({
+                    file: file.path,
+                    original: content,
+                    rewritten: result,
+                    transformations,
+                });
+            }
+        }
+        return {
+            changes,
+            newFiles: [],
+            deletedFiles: [],
+            summary: changes.length > 0
+                ? `Applied basic formatting transformations to ${changes.length} file(s): ${changes.map((c) => c.transformations.join(", ")).join("; ")}`
+                : "No transformations needed — files already well-formatted",
+            note: "Only basic code formatting applied (no model available for semantic rewrites)",
+        };
+    }
+    /**
+     * Sort import statements alphabetically while preserving groups.
+     */
+    sortImports(content) {
+        const lines = content.split("\n");
+        const importGroups = [];
+        let groupStart = -1;
+        let currentImports = [];
+        for (let i = 0; i < lines.length; i++) {
+            const trimmed = lines[i].trim();
+            if (/^import\s/.test(trimmed)) {
+                if (groupStart === -1)
+                    groupStart = i;
+                currentImports.push(lines[i]);
+            }
+            else {
+                if (currentImports.length > 1) {
+                    importGroups.push({
+                        start: groupStart,
+                        end: groupStart + currentImports.length - 1,
+                        imports: [...currentImports],
+                    });
+                }
+                groupStart = -1;
+                currentImports = [];
+            }
+        }
+        // Handle trailing import group
+        if (currentImports.length > 1) {
+            importGroups.push({
+                start: groupStart,
+                end: groupStart + currentImports.length - 1,
+                imports: [...currentImports],
+            });
+        }
+        if (importGroups.length === 0)
+            return content;
+        // Sort each group and rebuild
+        const resultLines = [...lines];
+        let changed = false;
+        for (const group of importGroups) {
+            const sorted = [...group.imports].sort((a, b) => {
+                // Extract the source module for comparison
+                const srcA = (a.match(/from\s+["']([^"']+)["']/) || [])[1] || a;
+                const srcB = (b.match(/from\s+["']([^"']+)["']/) || [])[1] || b;
+                return srcA.localeCompare(srcB);
+            });
+            const isAlreadySorted = sorted.every((line, idx) => line === group.imports[idx]);
+            if (!isAlreadySorted) {
+                for (let i = 0; i < sorted.length; i++) {
+                    resultLines[group.start + i] = sorted[i];
+                }
+                changed = true;
+            }
+        }
+        return changed ? resultLines.join("\n") : content;
+    }
+}
+export class UiDesignerAgent extends SubAgent {
+    async performTask(task) {
+        this.updateStatus("running", "Generating UI mockups");
+        const files = task.context.files;
+        const uiFiles = files.filter((f) => f.content.includes("div") ||
+            f.content.includes("button") ||
+            f.content.includes("<") ||
+            /\.(tsx?|jsx?|html|svelte|vue)$/.test(f.path));
+        if (uiFiles.length === 0) {
+            // No UI files found - still analyze the task prompt for UI generation
+            return this.localUiDesignFallback([], task);
+        }
+        const uiContent = uiFiles
+            .map((f) => `File: ${f.path}\n\n${f.content}`)
+            .join("\n\n---\n\n");
+        const prompt = `Design UI improvements for the following code:
+
+${uiContent}
+
+Task: ${task.prompt}
+
+Please provide:
+1. Detected UI frameworks
+2. ASCII mockups for new UI components
+3. Accessibility issues
+4. Design suggestions
+
+Format as structured JSON.`;
+        const response = await this.callModel(prompt);
+        if (!response) {
+            return this.localUiDesignFallback(uiFiles, task);
+        }
+        try {
+            return JSON.parse(response);
+        }
+        catch {
+            return {
+                detectedFrameworks: this.detectFrameworks(uiFiles),
+                mockups: [
+                    {
+                        type: "ascii",
+                        content: response,
+                        viewport: "desktop",
+                    },
+                ],
+                accessibilityIssues: this.detectA11yIssues(uiFiles),
+                designSuggestions: [],
+            };
+        }
+    }
+    /**
+     * Local fallback: generate a real UI analysis and skeletal component.
+     */
+    localUiDesignFallback(uiFiles, task) {
+        const prompt = task.prompt || "";
+        const lower = prompt.toLowerCase();
+        // --- Detect frameworks from file content ---
+        const frameworks = this.detectFrameworks(uiFiles);
+        // --- Detect UI keywords to determine component type ---
+        const uiKeywords = {
+            form: [
+                "form",
+                "input",
+                "submit",
+                "field",
+                "validation",
+                "textarea",
+                "select",
+            ],
+            button: ["button", "btn", "click", "action", "cta"],
+            layout: [
+                "layout",
+                "grid",
+                "flex",
+                "container",
+                "wrapper",
+                "sidebar",
+                "header",
+                "footer",
+            ],
+            page: ["page", "view", "screen", "route", "dashboard"],
+            modal: ["modal", "dialog", "popup", "overlay"],
+            list: ["list", "table", "grid", "card", "item", "row"],
+            nav: ["nav", "navigation", "menu", "breadcrumb", "tab", "sidebar"],
+        };
+        const detectedTypes = [];
+        for (const [type, keywords] of Object.entries(uiKeywords)) {
+            if (keywords.some((kw) => lower.includes(kw))) {
+                detectedTypes.push(type);
+            }
+        }
+        if (detectedTypes.length === 0)
+            detectedTypes.push("component");
+        // --- Detect accessibility issues in existing files ---
+        const accessibilityIssues = this.detectA11yIssues(uiFiles);
+        // --- Generate skeletal component based on detected type ---
+        const primaryType = detectedTypes[0];
+        const componentName = this.inferComponentName(prompt);
+        const isReact = frameworks.includes("react") || frameworks.includes("next.js");
+        let componentCode;
+        let asciiMockup;
+        switch (primaryType) {
+            case "form":
+                asciiMockup = [
+                    `+${"─".repeat(40)}+`,
+                    `│  ${componentName.padEnd(38)}│`,
+                    `│${"─".repeat(40)}│`,
+                    `│  Label:                               │`,
+                    `│  ┌──────────────────────────────────┐  │`,
+                    `│  │ Input field                       │  │`,
+                    `│  └──────────────────────────────────┘  │`,
+                    `│  Label:                               │`,
+                    `│  ┌──────────────────────────────────┐  │`,
+                    `│  │ Input field                       │  │`,
+                    `│  └──────────────────────────────────┘  │`,
+                    `│                                        │`,
+                    `│       ┌──────────────────────┐         │`,
+                    `│       │      Submit          │         │`,
+                    `│       └──────────────────────┘         │`,
+                    `+${"─".repeat(40)}+`,
+                ].join("\n");
+                componentCode = isReact
+                    ? this.generateReactForm(componentName)
+                    : this.generateHtmlForm(componentName);
+                break;
+            case "modal":
+                asciiMockup = [
+                    `  ┌${"─".repeat(36)}┐`,
+                    `  │  ${componentName.padEnd(30)}  [X] │`,
+                    `  │${"─".repeat(36)}│`,
+                    `  │                                    │`,
+                    `  │  Content area                      │`,
+                    `  │                                    │`,
+                    `  │${"─".repeat(36)}│`,
+                    `  │          [Cancel]   [Confirm]      │`,
+                    `  └${"─".repeat(36)}┘`,
+                ].join("\n");
+                componentCode = isReact
+                    ? this.generateReactModal(componentName)
+                    : this.generateHtmlModal(componentName);
+                break;
+            case "nav":
+                asciiMockup = [
+                    `+${"─".repeat(50)}+`,
+                    `│  Logo    │  Home  │  About  │  Contact  │  ☰  │`,
+                    `+${"─".repeat(50)}+`,
+                ].join("\n");
+                componentCode = isReact
+                    ? this.generateReactNav(componentName)
+                    : `<nav role="navigation" aria-label="Main navigation">\n  <ul>\n    <li><a href="/">Home</a></li>\n    <li><a href="/about">About</a></li>\n    <li><a href="/contact">Contact</a></li>\n  </ul>\n</nav>`;
+                break;
+            case "list":
+                asciiMockup = [
+                    `+${"─".repeat(42)}+`,
+                    `│  ${componentName.padEnd(40)}│`,
+                    `│${"─".repeat(42)}│`,
+                    `│  ┌──────────────────────────────────┐  │`,
+                    `│  │  Item 1              [Action]     │  │`,
+                    `│  ├──────────────────────────────────┤  │`,
+                    `│  │  Item 2              [Action]     │  │`,
+                    `│  ├──────────────────────────────────┤  │`,
+                    `│  │  Item 3              [Action]     │  │`,
+                    `│  └──────────────────────────────────┘  │`,
+                    `+${"─".repeat(42)}+`,
+                ].join("\n");
+                componentCode = isReact
+                    ? this.generateReactList(componentName)
+                    : `<section aria-label="${componentName}">\n  <h2>${componentName}</h2>\n  <ul role="list">\n    <li role="listitem">Item 1</li>\n    <li role="listitem">Item 2</li>\n  </ul>\n</section>`;
+                break;
+            default: // generic component / page / layout / button
+                asciiMockup = [
+                    `+${"─".repeat(44)}+`,
+                    `│  ${componentName.padEnd(42)}│`,
+                    `│${"─".repeat(44)}│`,
+                    `│                                            │`,
+                    `│  ┌────────────────────────────────────────┐│`,
+                    `│  │                                        ││`,
+                    `│  │       Main Content Area                 ││`,
+                    `│  │                                        ││`,
+                    `│  └────────────────────────────────────────┘│`,
+                    `│                                            │`,
+                    `│  [Primary Action]    [Secondary Action]    │`,
+                    `+${"─".repeat(44)}+`,
+                ].join("\n");
+                componentCode = isReact
+                    ? this.generateReactComponent(componentName)
+                    : `<section aria-label="${componentName}">\n  <h2>${componentName}</h2>\n  <div class="content">\n    <p>Main content area</p>\n  </div>\n  <div class="actions">\n    <button type="button">Primary Action</button>\n  </div>\n</section>`;
+        }
+        // --- Design suggestions based on analysis ---
+        const designSuggestions = [];
+        if (!uiFiles.some((f) => f.content.includes("@media") || f.content.includes("responsive"))) {
+            designSuggestions.push("Add responsive breakpoints for mobile/tablet viewports");
+        }
+        if (!uiFiles.some((f) => f.content.includes("dark") || f.content.includes("theme"))) {
+            designSuggestions.push("Consider implementing dark mode / theme support");
+        }
+        if (!uiFiles.some((f) => /loading|spinner|skeleton/i.test(f.content))) {
+            designSuggestions.push("Add loading states (skeleton screens or spinners) for async content");
+        }
+        if (!uiFiles.some((f) => /error|fallback/i.test(f.content))) {
+            designSuggestions.push("Add error boundary and fallback UI for graceful error handling");
+        }
+        designSuggestions.push("Ensure consistent spacing and typography using design tokens");
+        return {
+            detectedFrameworks: frameworks,
+            detectedComponentTypes: detectedTypes,
+            mockups: [
+                {
+                    type: "ascii",
+                    content: asciiMockup,
+                    viewport: "desktop",
+                    componentName,
+                },
+            ],
+            generatedComponent: {
+                name: componentName,
+                code: componentCode,
+                framework: isReact ? "React/TSX" : "HTML",
+            },
+            accessibilityIssues,
+            designSuggestions,
+            note: "UI design generated via local keyword analysis (no model available)",
+        };
+    }
+    /**
+     * Detect UI frameworks from file contents.
+     */
+    detectFrameworks(files) {
+        const frameworks = new Set();
+        for (const file of files) {
+            const c = file.content || "";
+            if (/\bimport\s.*from\s+["']react["']|React\.createElement|jsx/i.test(c))
+                frameworks.add("react");
+            if (/\bimport\s.*from\s+["']next/i.test(c) ||
+                /\bgetServerSideProps|getStaticProps\b/.test(c))
+                frameworks.add("next.js");
+            if (/\bimport\s.*from\s+["']vue["']|createApp|defineComponent/.test(c))
+                frameworks.add("vue");
+            if (/\bimport\s.*from\s+["']svelte["']|<script\s+lang=["']ts["']/.test(c) &&
+                file.path.endsWith(".svelte"))
+                frameworks.add("svelte");
+            if (/tailwind|className=["'][^"']*(?:flex|grid|p-|m-|text-)/.test(c))
+                frameworks.add("tailwind");
+            if (/\bimport\s.*from\s+["']@radix-ui/.test(c))
+                frameworks.add("radix-ui");
+            if (/\bimport\s.*from\s+["']@shadcn/.test(c) ||
+                /\bimport\s.*from\s+["']@\/components\/ui/.test(c))
+                frameworks.add("shadcn/ui");
+            if (/<html|<body|<head/i.test(c))
+                frameworks.add("html");
+        }
+        return [...frameworks];
+    }
+    /**
+     * Detect accessibility issues in UI files.
+     */
+    detectA11yIssues(files) {
+        const issues = [];
+        for (const file of files) {
+            const c = file.content || "";
+            // Images without alt
+            if (/<img\b(?![^>]*\balt\b)/i.test(c)) {
+                issues.push({
+                    file: file.path,
+                    issue: "Image element missing 'alt' attribute",
+                    severity: "high",
+                });
+            }
+            // Buttons without text content or aria-label
+            if (/<button[^>]*>\s*<(?:img|svg|icon)/i.test(c) &&
+                !/<button[^>]*aria-label/i.test(c)) {
+                issues.push({
+                    file: file.path,
+                    issue: "Icon-only button missing aria-label",
+                    severity: "high",
+                });
+            }
+            // onClick on non-interactive elements
+            if (/\bonClick\b.*<(?:div|span|p)\b/i.test(c) &&
+                !/role=["']button["']/i.test(c)) {
+                issues.push({
+                    file: file.path,
+                    issue: "Click handler on non-interactive element without role='button'",
+                    severity: "medium",
+                });
+            }
+            // Missing form labels
+            if (/<input\b(?![^>]*aria-label)(?![^>]*id=["'](\w+)["'])/i.test(c)) {
+                issues.push({
+                    file: file.path,
+                    issue: "Form input potentially missing associated label",
+                    severity: "medium",
+                });
+            }
+            // Missing lang attribute
+            if (/<html\b(?![^>]*\blang\b)/i.test(c)) {
+                issues.push({
+                    file: file.path,
+                    issue: "HTML element missing 'lang' attribute",
+                    severity: "medium",
+                });
+            }
+            // Color contrast (heuristic: very light text colors)
+            if (/color:\s*#(?:eee|ddd|ccc|fff|fafafa)/i.test(c)) {
+                issues.push({
+                    file: file.path,
+                    issue: "Potentially low color contrast text detected",
+                    severity: "low",
+                });
+            }
+        }
+        return issues;
+    }
+    /**
+     * Infer component name from task prompt.
+     */
+    inferComponentName(prompt) {
+        // Try to extract a meaningful name from the prompt
+        const match = prompt.match(/(?:create|build|generate|design|add)\s+(?:a\s+)?(\w[\w\s]{1,30}?)(?:\s+(?:component|page|form|modal|dialog|view|section|panel|widget))?$/i);
+        if (match) {
+            return match[1]
+                .trim()
+                .split(/\s+/)
+                .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+                .join("");
+        }
+        return "Component";
+    }
+    generateReactForm(name) {
+        return `import React, { FormEvent, useState } from "react";
+
+interface ${name}Props {
+  onSubmit?: (data: Record<string, string>) => void;
+}
+
+export function ${name}({ onSubmit }: ${name}Props) {
+  const [formData, setFormData] = useState<Record<string, string>>({});
+
+  const handleSubmit = (e: FormEvent) => {
+    e.preventDefault();
+    onSubmit?.(formData);
+  };
+
+  return (
+    <form onSubmit={handleSubmit} role="form" aria-label="${name}">
+      <fieldset>
+        <legend>${name}</legend>
+        <div>
+          <label htmlFor="${name.toLowerCase()}-field-1">Field 1</label>
+          <input
+            id="${name.toLowerCase()}-field-1"
+            type="text"
+            required
+            aria-required="true"
+            onChange={(e) => setFormData(prev => ({ ...prev, field1: e.target.value }))}
+          />
+        </div>
+        <div>
+          <label htmlFor="${name.toLowerCase()}-field-2">Field 2</label>
+          <input
+            id="${name.toLowerCase()}-field-2"
+            type="text"
+            onChange={(e) => setFormData(prev => ({ ...prev, field2: e.target.value }))}
+          />
+        </div>
+        <button type="submit">Submit</button>
+      </fieldset>
+    </form>
+  );
+}`;
+    }
+    generateHtmlForm(name) {
+        return `<form role="form" aria-label="${name}">
+  <fieldset>
+    <legend>${name}</legend>
+    <div>
+      <label for="${name.toLowerCase()}-field-1">Field 1</label>
+      <input id="${name.toLowerCase()}-field-1" type="text" required aria-required="true" />
+    </div>
+    <div>
+      <label for="${name.toLowerCase()}-field-2">Field 2</label>
+      <input id="${name.toLowerCase()}-field-2" type="text" />
+    </div>
+    <button type="submit">Submit</button>
+  </fieldset>
+</form>`;
+    }
+    generateReactModal(name) {
+        return `import React, { useEffect, useRef } from "react";
+
+interface ${name}Props {
+  isOpen: boolean;
+  onClose: () => void;
+  title: string;
+  children: React.ReactNode;
+}
+
+export function ${name}({ isOpen, onClose, title, children }: ${name}Props) {
+  const dialogRef = useRef<HTMLDialogElement>(null);
+
+  useEffect(() => {
+    if (isOpen) {
+      dialogRef.current?.showModal();
+    } else {
+      dialogRef.current?.close();
+    }
+  }, [isOpen]);
+
+  return (
+    <dialog
+      ref={dialogRef}
+      role="dialog"
+      aria-modal="true"
+      aria-label={title}
+      onClose={onClose}
+    >
+      <header>
+        <h2>{title}</h2>
+        <button type="button" onClick={onClose} aria-label="Close dialog">✕</button>
+      </header>
+      <div role="document">{children}</div>
+      <footer>
+        <button type="button" onClick={onClose}>Cancel</button>
+        <button type="button">Confirm</button>
+      </footer>
+    </dialog>
+  );
+}`;
+    }
+    generateHtmlModal(name) {
+        return `<dialog role="dialog" aria-modal="true" aria-label="${name}">
+  <header>
+    <h2>${name}</h2>
+    <button type="button" aria-label="Close dialog">✕</button>
+  </header>
+  <div role="document">
+    <p>Modal content goes here</p>
+  </div>
+  <footer>
+    <button type="button">Cancel</button>
+    <button type="button">Confirm</button>
+  </footer>
+</dialog>`;
+    }
+    generateReactNav(name) {
+        return `import React from "react";
+
+interface NavItem {
+  label: string;
+  href: string;
+  active?: boolean;
+}
+
+interface ${name}Props {
+  items: NavItem[];
+  logo?: React.ReactNode;
+}
+
+export function ${name}({ items, logo }: ${name}Props) {
+  return (
+    <nav role="navigation" aria-label="Main navigation">
+      {logo && <div aria-hidden="true">{logo}</div>}
+      <ul role="menubar">
+        {items.map((item) => (
+          <li key={item.href} role="none">
+            <a
+              href={item.href}
+              role="menuitem"
+              aria-current={item.active ? "page" : undefined}
+            >
+              {item.label}
+            </a>
+          </li>
+        ))}
+      </ul>
+    </nav>
+  );
+}`;
+    }
+    generateReactList(name) {
+        return `import React from "react";
+
+interface ListItem {
+  id: string;
+  title: string;
+  description?: string;
+}
+
+interface ${name}Props {
+  items: ListItem[];
+  onAction?: (id: string) => void;
+  emptyMessage?: string;
+}
+
+export function ${name}({ items, onAction, emptyMessage = "No items found" }: ${name}Props) {
+  if (items.length === 0) {
+    return (
+      <section aria-label="${name}">
+        <p role="status">{emptyMessage}</p>
+      </section>
+    );
+  }
+
+  return (
+    <section aria-label="${name}">
+      <h2>${name}</h2>
+      <ul role="list">
+        {items.map((item) => (
+          <li key={item.id} role="listitem">
+            <div>
+              <h3>{item.title}</h3>
+              {item.description && <p>{item.description}</p>}
+            </div>
+            {onAction && (
+              <button
+                type="button"
+                onClick={() => onAction(item.id)}
+                aria-label={\`Action for \${item.title}\`}
+              >
+                Action
+              </button>
+            )}
+          </li>
+        ))}
+      </ul>
+    </section>
+  );
+}`;
+    }
+    generateReactComponent(name) {
+        return `import React from "react";
+
+interface ${name}Props {
+  title?: string;
+  children?: React.ReactNode;
+}
+
+export function ${name}({ title = "${name}", children }: ${name}Props) {
+  return (
+    <section aria-label={title}>
+      <header>
+        <h2>{title}</h2>
+      </header>
+      <div role="region" aria-label="Content">
+        {children || <p>Main content area</p>}
+      </div>
+      <footer>
+        <button type="button">Primary Action</button>
+      </footer>
+    </section>
+  );
+}`;
+    }
+}
+export class ResearcherAgent extends SubAgent {
+    async performTask(task) {
+        this.updateStatus("running", "Researching information");
+        const query = task.prompt;
+        let webResult = null;
+        try {
+            webResult = await this.webSearch(query, 3);
+        }
+        catch (error) {
+            console.warn(`Web search failed for query "${query}": ${error}`);
+            // Continue without web results
+        }
+        if (webResult) {
+            const analysisPrompt = `Analyze the following web search results for the query "${query}":
+
+${webResult}
+
+Please extract:
+1. Key findings
+2. Verified facts
+3. Relevant sources
+4. Summary
+
+Format as structured JSON.`;
+            const analysisResponse = await this.callModel(analysisPrompt);
+            if (analysisResponse) {
+                try {
+                    return JSON.parse(analysisResponse);
+                }
+                catch {
+                    // Fall through to local analysis with web results
+                }
+            }
+        }
+        return this.localResearchFallback(query, webResult, task);
+    }
+    /**
+     * Local fallback: extract topics, search local files, and return findings.
+     */
+    localResearchFallback(_query, _webResult, _task) {
+        const lower = query.toLowerCase();
+        // --- Extract key topics from the query ---
+        const stopWords = new Set([
+            "the",
+            "a",
+            "an",
+            "and",
+            "or",
+            "but",
+            "in",
+            "on",
+            "at",
+            "to",
+            "for",
+            "of",
+            "with",
+            "by",
+            "from",
+            "is",
+            "are",
+            "was",
+            "were",
+            "be",
+            "been",
+            "being",
+            "have",
+            "has",
+            "had",
+            "do",
+            "does",
+            "did",
+            "will",
+            "would",
+            "could",
+            "should",
+            "may",
+            "might",
+            "must",
+            "can",
+            "this",
+            "that",
+            "these",
+            "those",
+            "what",
+            "how",
+            "why",
+            "when",
+            "where",
+            "which",
+            "who",
+            "about",
+            "into",
+            "through",
+            "during",
+            "before",
+            "after",
+            "it",
+            "its",
+            "my",
+            "your",
+            "we",
+            "they",
+            "them",
+            "our",
+            "not",
+            "no",
+            "if",
+        ]);
+        const words = query
+            .split(/\W+/)
+            .filter((w) => w.length > 2 && !stopWords.has(w.toLowerCase()));
+        const topics = [...new Set(words.map((w) => w.toLowerCase()))];
+        // --- Identify technical concepts ---
+        const technicalPatterns = {
+            programming_language: /\b(typescript|javascript|python|rust|go|java|c\+\+|ruby|php|swift|kotlin)\b/i,
+            framework: /\b(react|next\.?js|vue|angular|svelte|express|fastify|django|flask|spring)\b/i,
+            tool: /\b(webpack|vite|esbuild|rollup|babel|eslint|prettier|jest|vitest|docker|kubernetes)\b/i,
+            concept: /\b(api|rest|graphql|websocket|auth|oauth|jwt|database|sql|nosql|cache|queue|cicd|devops)\b/i,
+            pattern: /\b(singleton|factory|observer|strategy|decorator|middleware|hook|context|provider|reducer)\b/i,
+        };
+        const identifiedConcepts = {};
+        for (const [category, pattern] of Object.entries(technicalPatterns)) {
+            const matches = query.match(pattern);
+            if (matches) {
+                identifiedConcepts[category] = [
+                    ...new Set(matches.map((m) => m.toLowerCase())),
+                ];
+            }
+        }
+        // --- Scan local context files for relevant content ---
+        const localFindings = [];
+        const contextFiles = task.context.files;
+        for (const file of contextFiles) {
+            const content = (file.content || "").toLowerCase();
+            const matchedTopics = topics.filter((topic) => content.includes(topic));
+            if (matchedTopics.length > 0) {
+                // Determine relevance based on match density
+                const matchRatio = matchedTopics.length / Math.max(topics.length, 1);
+                const relevance = matchRatio > 0.5 ? "high" : matchRatio > 0.2 ? "medium" : "low";
+                localFindings.push({
+                    file: file.path,
+                    relevance,
+                    matchedTopics,
+                });
+            }
+        }
+        // Sort by relevance
+        const relevanceOrder = {
+            high: 0,
+            medium: 1,
+            low: 2,
+        };
+        localFindings.sort((a, b) => (relevanceOrder[a.relevance] ?? 3) - (relevanceOrder[b.relevance] ?? 3));
+        // --- Build results ---
+        const results = [];
+        // Add web results if available
+        if (webResult) {
+            results.push({
+                title: "Web Search Results",
+                url: "",
+                snippet: webResult.substring(0, 500),
+                relevance: 0.7,
+                source: "web_search",
+            });
+        }
+        // Add local file findings
+        for (const finding of localFindings.slice(0, 10)) {
+            const file = contextFiles.find((f) => f.path === finding.file);
+            const snippet = file
+                ? this.extractRelevantSnippet(file.content, finding.matchedTopics)
+                : "";
+            results.push({
+                title: `Local: ${finding.file}`,
+                url: finding.file,
+                snippet,
+                relevance: finding.relevance === "high"
+                    ? 0.9
+                    : finding.relevance === "medium"
+                        ? 0.6
+                        : 0.3,
+                source: "local_file",
+            });
+        }
+        // --- Key findings ---
+        const keyFindings = [];
+        if (localFindings.length > 0) {
+            keyFindings.push(`Found ${localFindings.length} relevant local file(s) matching query topics`);
+            const highRelevance = localFindings.filter((f) => f.relevance === "high");
+            if (highRelevance.length > 0) {
+                keyFindings.push(`High relevance files: ${highRelevance.map((f) => f.file).join(", ")}`);
+            }
+        }
+        if (Object.keys(identifiedConcepts).length > 0) {
+            for (const [category, concepts] of Object.entries(identifiedConcepts)) {
+                keyFindings.push(`Identified ${category}: ${concepts.join(", ")}`);
+            }
+        }
+        if (webResult) {
+            keyFindings.push("Web search results available but model-based analysis unavailable");
+        }
+        if (keyFindings.length === 0) {
+            keyFindings.push("No matching content found in local project files");
+            keyFindings.push("External research requires a model connection for deeper analysis");
+        }
+        return {
+            query,
+            topics,
+            identifiedConcepts,
+            results,
+            localFindings,
+            keyFindings,
+            verifiedFacts: [],
+            limitations: [
+                webResult
+                    ? "Web results retrieved but could not be analyzed without a model"
+                    : "Web search unavailable — results limited to local file scanning",
+                "Deep semantic analysis requires model availability",
+            ],
+            note: "Research performed via local keyword matching and file scanning (no model available)",
+        };
+    }
+    /**
+     * Extract a relevant snippet from file content based on matched topics.
+     */
+    extractRelevantSnippet(content, topics) {
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+            const lower = lines[i].toLowerCase();
+            if (topics.some((t) => lower.includes(t))) {
+                // Return surrounding context (3 lines before and after)
+                const start = Math.max(0, i - 2);
+                const end = Math.min(lines.length, i + 3);
+                return lines.slice(start, end).join("\n").substring(0, 300);
+            }
+        }
+        return content.substring(0, 200);
+    }
+}
+// ============================================================================
+// Gatekeeper Agent
+// ============================================================================
+export class GatekeeperAgent extends SubAgent {
+    reviewConfig;
+    revisionHistory = [];
+    constructor(messageBus, toolBridge, config) {
+        super("gatekeeper", { mode: "subagent", ...config }, messageBus, toolBridge);
+        this.reviewConfig = {
+            reviewLevel: config?.reviewConfig?.reviewLevel || "standard",
+            criteria: config?.reviewConfig?.criteria || this.getDefaultCriteria(),
+            autoApproveThreshold: config?.reviewConfig?.autoApproveThreshold || 0.8,
+            maxRevisions: config?.reviewConfig?.maxRevisions || 3,
+            enableParallelReview: config?.reviewConfig?.enableParallelReview || true,
+            strictMode: config?.reviewConfig?.strictMode || false,
+        };
+    }
+    getDefaultCriteria() {
+        return {
+            correctness: { enabled: true, weight: 0.25 },
+            completeness: { enabled: true, weight: 0.2 },
+            codeQuality: { enabled: true, weight: 0.15 },
+            security: { enabled: true, weight: 0.2 },
+            performance: { enabled: true, weight: 0.1 },
+            documentation: { enabled: true, weight: 0.1 },
+        };
+    }
+    async performTask(task) {
+        const startTime = Date.now();
+        this.updateStatus("running", "Reviewing agent work");
+        const phaseId = task.context.metadata?.phaseId || "unknown";
+        const agentType = task.context.metadata?.agentType || "analyzer";
+        const workOutput = task.context.metadata?.workOutput || task.prompt;
+        try {
+            // Perform comprehensive review based on criteria
+            const review = await this.performComprehensiveReview(workOutput, task.context);
+            const reviewDuration = Date.now() - startTime;
+            return {
+                ...review,
+                reviewId: uuidv4(),
+                phaseId,
+                agentType,
+                workOutput,
+                metadata: {
+                    reviewDuration,
+                    criteriaChecked: this.getCriteriaCheckList(),
+                    warnings: this.generateWarnings(review),
+                },
+            };
+        }
+        catch (error) {
+            this.updateStatus("error", "Gatekeeper review failed");
+            throw error;
+        }
+    }
+    async performComprehensiveReview(workOutput, context) {
+        // Build review prompt based on criteria
+        const prompt = this.buildReviewPrompt(workOutput, context);
+        const response = await this.callModel(prompt);
+        // Parse the review response
+        const parsedReview = this.parseReviewResponse(response);
+        // Calculate overall decision
+        const decision = this.calculateDecision(parsedReview.issues, parsedReview.suggestions);
+        // Calculate confidence score
+        const confidence = this.calculateConfidence(parsedReview);
+        return {
+            decision,
+            reasoning: parsedReview.reasoning ||
+                "Review completed based on criteria evaluation",
+            issues: parsedReview.issues || [],
+            suggestions: parsedReview.suggestions || [],
+            confidence,
+        };
+    }
+    buildReviewPrompt(workOutput, context) {
+        const criteria = this.reviewConfig.criteria;
+        const outputStr = typeof workOutput === "string"
+            ? workOutput
+            : JSON.stringify(workOutput, null, 2);
+        let criteriaStr = "Review criteria:\n";
+        if (criteria.correctness.enabled)
+            criteriaStr += "- Correctness: Code functions as intended\n";
+        if (criteria.completeness.enabled)
+            criteriaStr += "- Completeness: All requirements addressed\n";
+        if (criteria.codeQuality.enabled)
+            criteriaStr += "- Code Quality: Clean, maintainable code\n";
+        if (criteria.security.enabled)
+            criteriaStr += "- Security: No vulnerabilities\n";
+        if (criteria.performance.enabled)
+            criteriaStr += "- Performance: Efficient implementation\n";
+        if (criteria.documentation.enabled)
+            criteriaStr += "- Documentation: Clear docs/comments\n";
+        return `You are a senior code reviewer acting as a gatekeeper for a multi-agent coding system.
+
+Agent Type: Gatekeeper Review
+Phase: Reviewing work output
+
+Output to Review:
+${outputStr.substring(0, 8000)}
+
+${criteriaStr}
+
+Context Files: ${context.files.map((f) => f.path).join(", ")}
+
+Provide your review in JSON format:
+{
+  "decision": "approve|request_revision|restart_from_scratch|escalate",
+  "reasoning": "Brief explanation of the decision",
+  "issues": [
+    {
+      "id": "issue-1",
+      "severity": "critical|high|medium|low",
+      "category": "correctness|completeness|code_quality|security|performance|style|best_practice|consistency",
+      "description": "Issue description",
+      "location": { "file": "...", "line": ... },
+      "evidence": "Why this is an issue",
+      "remediation": "How to fix"
+    }
+  ],
+  "suggestions": [
+    {
+      "id": "suggest-1",
+      "priority": "must|should|could",
+      "category": "...",
+      "description": "Suggestion description",
+      "rationale": "Why this helps",
+      "example": "Optional code example"
+    }
+  ]
+}
+
+Only include issues and suggestions that are relevant and actionable.`;
+    }
+    parseReviewResponse(response) {
+        const defaultResult = {
+            decision: "approve",
+            reasoning: "Review completed, no critical issues found",
+            issues: [],
+            suggestions: [],
+        };
+        if (!response) {
+            return defaultResult;
+        }
+        try {
+            // Try to parse as JSON
+            const parsed = JSON.parse(response);
+            return {
+                decision: parsed.decision || "approve",
+                reasoning: parsed.reasoning || defaultResult.reasoning,
+                issues: (parsed.issues || []).map((issue, idx) => ({
+                    id: issue.id || `issue-${idx}`,
+                    severity: issue.severity || "medium",
+                    category: issue.category || "code_quality",
+                    description: issue.description || "Issue identified",
+                    location: issue.location,
+                    evidence: issue.evidence || "",
+                    remediation: issue.remediation || "",
+                })),
+                suggestions: (parsed.suggestions || []).map((sug, idx) => ({
+                    id: sug.id || `suggest-${idx}`,
+                    priority: sug.priority || "should",
+                    category: sug.category || "code_quality",
+                    description: sug.description || "Suggestion",
+                    rationale: sug.rationale || "",
+                    example: sug.example,
+                })),
+            };
+        }
+        catch {
+            // Fallback: analyze response text
+            return this.analyzeResponseText(response);
+        }
+    }
+    analyzeResponseText(response) {
+        const lowerResponse = response.toLowerCase();
+        // Check for negative indicators
+        const hasCritical = lowerResponse.includes("critical") || lowerResponse.includes("error");
+        const hasMajorIssues = lowerResponse.includes("major") || lowerResponse.includes("serious");
+        const needsWork = lowerResponse.includes("needs work") ||
+            lowerResponse.includes("should fix");
+        let decision = "approve";
+        if (hasCritical) {
+            decision = "request_revision";
+        }
+        else if (hasMajorIssues) {
+            decision = "request_revision";
+        }
+        else if (needsWork) {
+            decision = "request_revision";
+        }
+        return {
+            decision,
+            reasoning: response.substring(0, 500),
+            issues: [],
+            suggestions: [],
+        };
+    }
+    calculateDecision(issues, suggestions) {
+        // Critical issues = restart or escalate
+        const criticalCount = issues.filter((i) => i.severity === "critical").length;
+        if (criticalCount > 0) {
+            return this.reviewConfig.strictMode ? "restart_from_scratch" : "escalate";
+        }
+        // High severity issues = request revision
+        const highCount = issues.filter((i) => i.severity === "high").length;
+        if (highCount > 0) {
+            return "request_revision";
+        }
+        // Must-have suggestions = request revision
+        const mustHave = suggestions.filter((s) => s.priority === "must").length;
+        if (mustHave > 0) {
+            return "request_revision";
+        }
+        // Medium issues = request revision if strict mode
+        const mediumCount = issues.filter((i) => i.severity === "medium").length;
+        if (mediumCount > 2 && this.reviewConfig.strictMode) {
+            return "request_revision";
+        }
+        return "approve";
+    }
+    calculateConfidence(parsedReview) {
+        let confidence = 1.0;
+        // Reduce confidence based on issue count
+        confidence -= parsedReview.issues.length * 0.05;
+        // Reduce confidence based on critical/high issues
+        const criticalHighCount = parsedReview.issues.filter((i) => i.severity === "critical" || i.severity === "high").length;
+        confidence -= criticalHighCount * 0.15;
+        // Boost confidence for thorough reviews
+        if (this.reviewConfig.reviewLevel === "thorough") {
+            confidence += 0.1;
+        }
+        return Math.max(0, Math.min(1, confidence));
+    }
+    getCriteriaCheckList() {
+        const criteria = this.reviewConfig.criteria;
+        const checks = [];
+        if (criteria.correctness.enabled)
+            checks.push("correctness");
+        if (criteria.completeness.enabled)
+            checks.push("completeness");
+        if (criteria.codeQuality.enabled)
+            checks.push("codeQuality");
+        if (criteria.security.enabled)
+            checks.push("security");
+        if (criteria.performance.enabled)
+            checks.push("performance");
+        if (criteria.documentation.enabled)
+            checks.push("documentation");
+        return checks;
+    }
+    generateWarnings(review) {
+        const warnings = [];
+        if (review.decision === "request_revision") {
+            warnings.push("Review flagged for revision");
+        }
+        if (review.decision === "restart_from_scratch") {
+            warnings.push("Major issues detected, restart recommended");
+        }
+        if (review.issues.length > 5) {
+            warnings.push("High number of issues detected");
+        }
+        return warnings;
+    }
+    // Add revision to history
+    addRevision(iteration, phaseId, originalIssue, revision) {
+        this.revisionHistory.push({
+            iteration,
+            phaseId,
+            originalIssue,
+            revision,
+            outcome: "accepted",
+        });
+    }
+    // Get revision history
+    getRevisionHistory() {
+        return [...this.revisionHistory];
+    }
+    // Get current review config
+    getConfig() {
+        return { ...this.reviewConfig };
+    }
+    // Update review config
+    updateConfig(config) {
+        this.reviewConfig = { ...this.reviewConfig, ...config };
+    }
+}
+// ============================================================================
+// Gatekeeper Coordinator - Orchestrates multiple gatekeeper reviews
+// ============================================================================
+export class GatekeeperCoordinator {
+    gatekeepers = new Map();
+    reviewQueue = [];
+    isProcessing = false;
+    constructor(messageBus, toolBridge, maxConcurrentReviews = 4) {
+        // Initialize gatekeepers as per spec
+        for (let i = 0; i < maxConcurrentReviews; i++) {
+            const gatekeeper = new GatekeeperAgent(messageBus, toolBridge);
+            this.gatekeepers.set(`gatekeeper-${i}`, gatekeeper);
+        }
+    }
+    // Get an available gatekeeper
+    getAvailableGatekeeper() {
+        for (const [, gatekeeper] of this.gatekeepers) {
+            const status = gatekeeper.getStatus();
+            if (status.status === "idle" || status.status === "completed") {
+                return gatekeeper;
+            }
+        }
+        return null;
+    }
+    // Submit work for gatekeeper review
+    async submitForReview(task) {
+        const gatekeeper = this.getAvailableGatekeeper();
+        if (!gatekeeper) {
+            // Queue the review
+            return new Promise((resolve, reject) => {
+                this.reviewQueue.push({
+                    task,
+                    gatekeeper: this.gatekeepers.values().next().value,
+                    resolve,
+                    reject,
+                });
+                this.processQueue();
+            });
+        }
+        return this.performReview(gatekeeper, task);
+    }
+    // Perform review with a specific gatekeeper
+    async performReview(gatekeeper, task) {
+        try {
+            const result = await gatekeeper.execute(task);
+            this.processQueue(); // Try to process next in queue
+            return result;
+        }
+        catch (error) {
+            this.processQueue();
+            throw error;
+        }
+    }
+    // Process queued reviews
+    async processQueue() {
+        if (this.isProcessing || this.reviewQueue.length === 0) {
+            return;
+        }
+        this.isProcessing = true;
+        while (this.reviewQueue.length > 0) {
+            const gatekeeper = this.getAvailableGatekeeper();
+            if (!gatekeeper) {
+                break;
+            }
+            const queueItem = this.reviewQueue.shift();
+            this.performReview(gatekeeper, queueItem.task)
+                .then(queueItem.resolve)
+                .catch(queueItem.reject);
+        }
+        this.isProcessing = false;
+    }
+    // Review all phase outputs
+    async reviewAllPhases(phaseOutputs) {
+        const phaseReviews = [];
+        const revisionHistory = [];
+        let totalConfidence = 0;
+        // Review each phase in parallel (if enabled)
+        const reviewPromises = phaseOutputs.map(async (phase) => {
+            const gatekeeper = this.getAvailableGatekeeper();
+            if (!gatekeeper) {
+                throw new Error("No gatekeeper available for review");
+            }
+            const task = {
+                id: uuidv4(),
+                type: "gatekeeper",
+                prompt: JSON.stringify(phase.output),
+                context: {
+                    ...phase.context,
+                    metadata: {
+                        ...phase.context.metadata,
+                        phaseId: phase.phaseId,
+                        agentType: phase.agentType,
+                        workOutput: phase.output,
+                    },
+                },
+                successCriteria: "Complete gatekeeper review",
+            };
+            const review = await this.performReview(gatekeeper, task);
+            phaseReviews.push(review);
+            totalConfidence += review.confidence;
+            return review;
+        });
+        await Promise.all(reviewPromises);
+        // Calculate overall decision
+        const avgConfidence = phaseReviews.length > 0 ? totalConfidence / phaseReviews.length : 0;
+        const needsRevision = phaseReviews.some((r) => r.decision === "request_revision");
+        const needsRestart = phaseReviews.some((r) => r.decision === "restart_from_scratch");
+        const hasEscalation = phaseReviews.some((r) => r.decision === "escalate");
+        let overallDecision = "approve";
+        if (needsRestart) {
+            overallDecision = "restart_from_scratch";
+        }
+        else if (needsRevision) {
+            overallDecision = "request_revision";
+        }
+        else if (hasEscalation) {
+            overallDecision = "escalate";
+        }
+        // Collect all issues and suggestions
+        const allIssues = phaseReviews.flatMap((r) => r.issues);
+        const allSuggestions = phaseReviews.flatMap((r) => r.suggestions);
+        // Build master decision
+        const masterDecision = this.buildMasterDecision(overallDecision, allIssues, allSuggestions, phaseReviews);
+        return {
+            overallDecision,
+            confidence: avgConfidence,
+            phaseReviews,
+            masterDecision,
+            summary: this.generateSummary(phaseReviews, overallDecision, avgConfidence),
+            nextSteps: this.generateNextSteps(masterDecision, allIssues),
+            revisionHistory,
+        };
+    }
+    buildMasterDecision(overallDecision, allIssues, allSuggestions, phaseReviews) {
+        switch (overallDecision) {
+            case "approve":
+                return {
+                    action: "proceed",
+                    reasoning: "All phases passed gatekeeper review",
+                    affectedPhases: [],
+                };
+            case "request_revision":
+                return {
+                    action: "modify_plan",
+                    reasoning: `Revision needed: ${allIssues.length} issues, ${allSuggestions.length} suggestions`,
+                    affectedPhases: phaseReviews
+                        .filter((r) => r.decision === "request_revision")
+                        .map((r) => r.phaseId),
+                };
+            case "restart_from_scratch":
+                return {
+                    action: "restart",
+                    reasoning: `Critical issues require restart: ${allIssues.filter((i) => i.severity === "critical").length} critical issues`,
+                    affectedPhases: phaseReviews.map((r) => r.phaseId),
+                };
+            case "escalate":
+                return {
+                    action: "stop",
+                    reasoning: "Escalation required due to unresolvable issues",
+                    affectedPhases: phaseReviews
+                        .filter((r) => r.decision === "escalate")
+                        .map((r) => r.phaseId),
+                };
+            default:
+                return {
+                    action: "proceed",
+                    reasoning: "Default decision: proceed",
+                    affectedPhases: [],
+                };
+        }
+    }
+    generateSummary(phaseReviews, decision, confidence) {
+        const passed = phaseReviews.filter((r) => r.decision === "approve").length;
+        const revised = phaseReviews.filter((r) => r.decision === "request_revision").length;
+        const restarted = phaseReviews.filter((r) => r.decision === "restart_from_scratch").length;
+        const escalated = phaseReviews.filter((r) => r.decision === "escalate").length;
+        return `Gatekeeper Review Summary:
+- Total Phases Reviewed: ${phaseReviews.length}
+- Passed: ${passed}
+- Requested Revision: ${revised}
+- Restarted: ${restarted}
+- Escalated: ${escalated}
+- Overall Decision: ${decision}
+- Confidence: ${(confidence * 100).toFixed(1)}%
+- Total Issues Found: ${phaseReviews.reduce((sum, r) => sum + r.issues.length, 0)}
+- Total Suggestions: ${phaseReviews.reduce((sum, r) => sum + r.suggestions.length, 0)}`;
+    }
+    generateNextSteps(decision, issues) {
+        const steps = [];
+        switch (decision.action) {
+            case "proceed":
+                steps.push("Proceed to next pipeline phase");
+                steps.push("Synthesize final output");
+                break;
+            case "modify_plan":
+                steps.push("Collect revision requirements from gatekeeper");
+                steps.push("Send modified plan back to affected agents");
+                steps.push("Re-run affected phases with corrections");
+                break;
+            case "restart":
+                steps.push("Clear current phase outputs");
+                steps.push("Restart pipeline from beginning");
+                steps.push("Apply learnings from previous attempts");
+                break;
+            case "stop":
+                steps.push("Report critical issues to user");
+                steps.push("Request human intervention");
+                steps.push("Await further instructions");
+                break;
+        }
+        // Add issue-specific steps
+        if (issues.length > 0) {
+            steps.push(`Address ${issues.length} identified issues`);
+        }
+        return steps;
+    }
+    // Get all gatekeepers status
+    getGatekeeperStatuses() {
+        const statuses = new Map();
+        for (const [id, gatekeeper] of this.gatekeepers) {
+            statuses.set(id, gatekeeper.getStatus());
+        }
+        return statuses;
+    }
+    // Shutdown all gatekeepers
+    async shutdown() {
+        for (const [, gatekeeper] of this.gatekeepers) {
+            await gatekeeper.stop();
+        }
+        this.reviewQueue = [];
+    }
+}
+// ============================================================================
+// Factory Function
+// ============================================================================
+export function createAgent(type, messageBus, toolBridge, config, projectRoot) {
+    switch (type) {
+        case "master":
+            return new MasterAgent(messageBus, toolBridge, config, projectRoot);
+        case "planner":
+            return new PlannerAgent(type, config || {}, messageBus, toolBridge);
+        case "analyzer":
+            return new AnalyzerAgent(type, config || {}, messageBus, toolBridge);
+        case "reviewer":
+            return new ReviewerAgent(type, config || {}, messageBus, toolBridge);
+        case "rewriter":
+            return new RewriterAgent(type, config || {}, messageBus, toolBridge);
+        case "ui_designer":
+            return new UiDesignerAgent(type, config || {}, messageBus, toolBridge);
+        case "researcher":
+            return new ResearcherAgent(type, config || {}, messageBus, toolBridge);
+        case "gatekeeper":
+            return new GatekeeperAgent(messageBus, toolBridge, config);
+        default:
+            throw new Error(`Unknown agent type: ${type}`);
+    }
+}
+//# sourceMappingURL=base-agents.js.map