synapsexcoder 6.0.0

package/dist/agents/internal-gatekeeper.js

@@ -0,0 +1,1130 @@
+// @ts-nocheck
+/**
+ * Internal Gatekeeper - Subagent Self-Review System
+ *
+ * Each subagent has its own internal gatekeeper that reviews work
+ * before returning to the Master Agent. Implements the APPROVE/DECLINE
+ * decision loop with retry capability.
+ */
+// ============================================================================
+// Error Indicators — patterns that signal broken/invalid output
+// ============================================================================
+const ERROR_INDICATORS = [
+    /\bundefined\b/i,
+    /\bnull\b(?!\s*[=!<>])/i, // "null" as a standalone value, not a comparison
+    /\bNaN\b/,
+    /stack\s*trace/i,
+    /\bat\s+\S+\s+\(/i, // stack trace lines like "at Module._compile ("
+    /Error:\s+/,
+    /TypeError:\s+/,
+    /ReferenceError:\s+/,
+    /SyntaxError:\s+/,
+    /ENOENT/,
+    /EACCES/,
+    /EPERM/,
+    /Cannot read propert/i,
+    /is not a function/i,
+    /is not defined/i,
+    /Unexpected token/i,
+    /FATAL/i,
+    /PANIC/i,
+];
+// ============================================================================
+// Internal Gatekeeper
+// ============================================================================
+export class InternalGatekeeper {
+    agentType;
+    toolBridge;
+    config;
+    retryHistory = [];
+    constructor(agentType, toolBridge, config) {
+        this.agentType = agentType;
+        this.toolBridge = toolBridge;
+        this.config = {
+            maxRetries: config?.maxRetries ?? 3,
+            strictMode: config?.strictMode ?? false,
+            autoApproveThreshold: config?.autoApproveThreshold ?? 0.8,
+            model: config?.model,
+        };
+    }
+    /**
+     * Review subagent work and return APPROVE or DECLINE decision.
+     * Implements retry loop: DECLINE -> TRASH & RESTART -> Re-review
+     */
+    async review(work) {
+        const attempt = this.retryHistory.length + 1;
+        console.log(`🔒 [${this.agentType}] Internal Gatekeeper: Review attempt ${attempt}/${this.config.maxRetries + 1}`);
+        // Perform review using AI
+        const reviewResult = await this.performReview(work);
+        const result = {
+            approved: reviewResult.decision === "approve",
+            decision: reviewResult.decision,
+            confidence: reviewResult.confidence,
+            issues: reviewResult.issues,
+            suggestions: reviewResult.suggestions,
+            reasoning: reviewResult.reasoning,
+            retryCount: attempt - 1,
+        };
+        // Record in history
+        this.retryHistory.push({
+            attempt,
+            decision: reviewResult.decision,
+            issues: reviewResult.issues,
+            timestamp: Date.now(),
+        });
+        // Log decision
+        if (reviewResult.decision === "approve") {
+            console.log(`✅ [${this.agentType}] Internal Gatekeeper: APPROVED (confidence: ${(reviewResult.confidence * 100).toFixed(1)}%)`);
+        }
+        else {
+            console.log(`❌ [${this.agentType}] Internal Gatekeeper: DECLINED (issues: ${reviewResult.issues.length})`);
+            if (reviewResult.issues.length > 0) {
+                console.log(`   Issues:`);
+                reviewResult.issues.forEach((issue, idx) => {
+                    console.log(`   ${idx + 1}. [${issue.severity}] ${issue.description}`);
+                });
+            }
+        }
+        return result;
+    }
+    /**
+     * Perform the actual review using AI
+     */
+    async performReview(work) {
+        const criteria = this.getReviewCriteria();
+        const outputStr = this.formatOutput(work.output);
+        const prompt = `You are an Internal Gatekeeper for a subagent (${this.agentType}) in a multi-agent coding system.
+
+Your job is to review the work produced by the subagent BEFORE it returns to the Master Agent.
+You must APPROVE if the work meets quality standards, or DECLINE if it needs revision.
+
+## SUBAGENT TYPE: ${this.agentType}
+
+## WORK OUTPUT TO REVIEW:
+${outputStr}
+
+## REVIEW CRITERIA FOR ${this.agentType.toUpperCase()}:
+${criteria}
+
+## CONTEXT:
+- Task: ${work.task.prompt.substring(0, 500)}
+- Files: ${work.task.context.files.map((f) => f.path).join(", ")}
+
+Respond with ONLY a JSON object (no other text):
+{
+  "decision": "approve" | "decline",
+  "confidence": 0.0-1.0,
+  "reasoning": "Brief explanation",
+  "issues": [
+    {
+      "id": "issue-N",
+      "severity": "critical" | "high" | "medium" | "low",
+      "category": "correctness | completeness | code_quality | security | performance",
+      "description": "Issue description",
+      "evidence": "Evidence from the work",
+      "remediation": "How to fix"
+    }
+  ],
+  "suggestions": [
+    {
+      "id": "suggest-N",
+      "priority": "must" | "should" | "could",
+      "category": "...",
+      "description": "Suggestion",
+      "rationale": "Why this helps"
+    }
+  ]
+}`;
+        try {
+            // Use the configured model or fall back to grok-code-fast-1
+            const modelToUse = this.config.model || "github-copilot/grok-code-fast-1";
+            const toolResult = await this.toolBridge.callModel(prompt, {
+                model: modelToUse,
+            });
+            const response = toolResult?.success
+                ? toolResult.output
+                : null;
+            if (!response) {
+                // Model returned no response — fall back to local code analysis
+                console.warn(`⚠️ [${this.agentType}] Model returned no response, running local analysis fallback`);
+                return this.performLocalAnalysisFallback(work, "model_no_response");
+            }
+            return this.parseReviewResponse(response);
+        }
+        catch (error) {
+            // Model call threw — fall back to local code analysis (NEVER auto-approve)
+            console.warn(`⚠️ [${this.agentType}] Model call failed: ${error}, running local analysis fallback`);
+            return this.performLocalAnalysisFallback(work, `model_error: ${String(error)}`);
+        }
+    }
+    /**
+     * Get review criteria based on agent type
+     */
+    getReviewCriteria() {
+        const criteriaMap = {
+            planner: `
+- COMPLETENESS: Are all required steps included?
+- LOGICAL FLOW: Are steps in correct order?
+- DEPENDENCIES: Are dependencies properly identified?
+- RISK ASSESSMENT: Are potential risks identified?
+- Does the plan address the task requirements?`,
+            analyzer: `
+- ACCURACY: Are identified issues correct?
+- COMPLETENESS: Are all issues found?
+- FALSE POSITIVES: Are there any false positives?
+- SEVERITY: Are severity levels appropriate?
+- Does it cover syntax, logic, security, performance?`,
+            reviewer: `
+- REASONING: Is the reasoning sound?
+- COMPLETENESS: Are all aspects reviewed?
+- ACCURACY: Are conclusions correct?
+- ALTERNATIVES: Are alternatives considered?
+- Does it provide actionable feedback?`,
+            rewriter: `
+- SYNTAX: Is the code syntactically correct?
+- REGRESSIONS: Are there potential regressions?
+- SAFETY: Are changes safe to apply?
+- COMPLETENESS: Are all required changes made?
+- Does it properly fix the identified issues?`,
+            ui_designer: `
+- VALIDITY: Is the design valid?
+- ACCESSIBILITY: Are accessibility issues addressed?
+- RESPONSIVENESS: Is it responsive?
+- QUALITY: Is the visual design good?
+- Does it match the UI requirements?`,
+            researcher: `
+- RELIABILITY: Are sources reliable?
+- RELEVANCE: Is information relevant?
+- COMPLETENESS: Is research thorough?
+- CITATIONS: Are sources cited?
+- Does it answer the research question?`,
+            gatekeeper: `
+- FAIRNESS: Is the review fair?
+- THOROUGHNESS: Is the review thorough?
+- ACCURACY: Are decisions accurate?`,
+            master: `
+- ORCHESTRATION: Is coordination effective?`,
+        };
+        return criteriaMap[this.agentType] || criteriaMap.analyzer;
+    }
+    // ==========================================================================
+    // Local Analysis Fallback — replaces dangerous auto-approve
+    // ==========================================================================
+    /**
+     * Perform local rule-based analysis when model call fails.
+     * This is the CRITICAL safety net — it uses structural validation and
+     * quality heuristics to make a conservative decision without AI.
+     *
+     * Design principle: when in doubt, DECLINE rather than approve.
+     */
+    performLocalAnalysisFallback(work, failureReason) {
+        const outputStr = this.formatOutput(work.output);
+        const structural = this.validateStructure(work, outputStr);
+        const quality = this.evaluateQualityHeuristics(work, outputStr);
+        // Build detailed check breakdown for transparency
+        const structuralSummary = structural.checks
+            .map((c) => `  ${c.passed ? "✅" : "❌"} ${c.name}: ${c.detail}`)
+            .join("\n");
+        const qualitySummary = quality.checks
+            .map((c) => `  ${c.passed ? "✅" : "❌"} ${c.name} (w=${c.weight}): ${c.detail}`)
+            .join("\n");
+        const checkBreakdown = `[Local Analysis Fallback — ${failureReason}]\nStructural (valid=${structural.valid}):\n${structuralSummary}\nQuality (score=${(quality.score * 100).toFixed(1)}%):\n${qualitySummary}`;
+        console.log(`🔍 [${this.agentType}] Local analysis fallback:\n${checkBreakdown}`);
+        // Decision logic — conservative approach
+        const issues = [];
+        const suggestions = [];
+        let decision;
+        let confidence;
+        let reasoning;
+        // Always note that this is a fallback review
+        suggestions.push({
+            id: "suggest-fallback-rerun",
+            priority: "should",
+            category: "correctness",
+            description: "This review was performed via local heuristics due to model failure. Re-run with model verification when available.",
+            rationale: `Model was unavailable: ${failureReason}`,
+        });
+        // Collect issues from failed structural checks
+        for (const check of structural.checks) {
+            if (!check.passed) {
+                issues.push({
+                    id: `struct-${check.name.replace(/\s+/g, "-").toLowerCase()}`,
+                    severity: "high",
+                    category: "correctness",
+                    description: `Structural validation failed: ${check.name}`,
+                    evidence: check.detail,
+                    remediation: `Fix the structural issue: ${check.detail}`,
+                });
+            }
+        }
+        // Collect issues from failed quality checks
+        for (const check of quality.checks) {
+            if (!check.passed) {
+                issues.push({
+                    id: `quality-${check.name.replace(/\s+/g, "-").toLowerCase()}`,
+                    severity: check.weight >= 0.2 ? "medium" : "low",
+                    category: "code_quality",
+                    description: `Quality heuristic failed: ${check.name}`,
+                    evidence: check.detail,
+                    remediation: `Improve quality: ${check.detail}`,
+                });
+            }
+        }
+        if (!structural.valid) {
+            // Structural validation FAILED — always DECLINE
+            decision = "decline";
+            confidence = Math.max(0.5, 1.0 - quality.score);
+            reasoning = `DECLINED (local fallback): Structural validation failed. ${issues.length} issue(s) found. Quality score: ${(quality.score * 100).toFixed(1)}%. Failure reason: ${failureReason}`;
+        }
+        else if (quality.score < 0.4) {
+            // Quality score below 40% — DECLINE
+            decision = "decline";
+            confidence = Math.max(0.4, 1.0 - quality.score);
+            reasoning = `DECLINED (local fallback): Quality score too low (${(quality.score * 100).toFixed(1)}% < 40% threshold). ${issues.length} issue(s) found. Failure reason: ${failureReason}`;
+        }
+        else if (quality.score < 0.7) {
+            // Quality score 40-70% — DECLINE with request for changes
+            // We lean conservative: this range means "not confident enough to approve"
+            decision = "decline";
+            confidence = 0.5;
+            reasoning = `DECLINED (local fallback): Quality score in uncertain range (${(quality.score * 100).toFixed(1)}%, needs ≥70% for approval). ${issues.length} issue(s) found. Failure reason: ${failureReason}`;
+            suggestions.push({
+                id: "suggest-improve-quality",
+                priority: "must",
+                category: "completeness",
+                description: `Quality score is ${(quality.score * 100).toFixed(1)}%. Improve the output to exceed 70% threshold for approval.`,
+                rationale: "Without model verification, only high-quality outputs are approved.",
+            });
+        }
+        else {
+            // Structural valid AND quality > 70% — APPROVE with capped confidence
+            // Cap at 0.85 since we have no model verification
+            decision = "approve";
+            confidence = Math.min(0.85, quality.score * 0.8);
+            reasoning = `APPROVED (local fallback): Structural validation passed. Quality score: ${(quality.score * 100).toFixed(1)}%. Confidence capped at ${(confidence * 100).toFixed(1)}% (no model verification). Failure reason: ${failureReason}`;
+        }
+        return { decision, confidence, issues, suggestions, reasoning };
+    }
+    // ==========================================================================
+    // Structural Validation — checks basic correctness of output shape
+    // ==========================================================================
+    /**
+     * Validate the structural integrity of work output.
+     * Checks: non-empty, parseable, expected shape for agent type, no error indicators.
+     */
+    validateStructure(work, outputStr) {
+        const checks = [];
+        // Check 1: Output exists and is non-null
+        const outputExists = work.output != null;
+        checks.push({
+            name: "Output exists",
+            passed: outputExists,
+            detail: outputExists
+                ? "Output is non-null"
+                : "Output is null or undefined",
+        });
+        if (!outputExists) {
+            return { valid: false, checks };
+        }
+        // Check 2: Output is non-empty
+        const trimmed = outputStr.trim();
+        const nonEmpty = trimmed.length > 0;
+        checks.push({
+            name: "Non-empty output",
+            passed: nonEmpty,
+            detail: nonEmpty
+                ? `Output has ${trimmed.length} characters`
+                : "Output is empty or whitespace-only",
+        });
+        if (!nonEmpty) {
+            return { valid: false, checks };
+        }
+        // Check 3: Minimum length (not trivially short)
+        const minLength = this.getMinimumLengthForAgent(work.agentType);
+        const meetsMinLength = trimmed.length >= minLength;
+        checks.push({
+            name: "Minimum length",
+            passed: meetsMinLength,
+            detail: meetsMinLength
+                ? `Output length ${trimmed.length} ≥ minimum ${minLength}`
+                : `Output length ${trimmed.length} < minimum ${minLength} for ${work.agentType}`,
+        });
+        // Check 4: Parseable as JSON/structured data (if output is an object or looks like JSON)
+        let parseableCheck = true;
+        if (typeof work.output === "string") {
+            const looksLikeJson = trimmed.startsWith("{") || trimmed.startsWith("[");
+            if (looksLikeJson) {
+                try {
+                    JSON.parse(trimmed);
+                    checks.push({
+                        name: "JSON parseable",
+                        passed: true,
+                        detail: "Output parses as valid JSON",
+                    });
+                }
+                catch {
+                    parseableCheck = false;
+                    checks.push({
+                        name: "JSON parseable",
+                        passed: false,
+                        detail: "Output looks like JSON but fails to parse",
+                    });
+                }
+            }
+            else {
+                checks.push({
+                    name: "JSON parseable",
+                    passed: true,
+                    detail: "Output is not JSON-shaped (string content), skipping parse check",
+                });
+            }
+        }
+        else if (typeof work.output === "object") {
+            // Object output — verify it can round-trip through JSON
+            try {
+                JSON.stringify(work.output);
+                checks.push({
+                    name: "JSON parseable",
+                    passed: true,
+                    detail: "Object output serializes to valid JSON",
+                });
+            }
+            catch {
+                parseableCheck = false;
+                checks.push({
+                    name: "JSON parseable",
+                    passed: false,
+                    detail: "Object output cannot be serialized to JSON",
+                });
+            }
+        }
+        else {
+            checks.push({
+                name: "JSON parseable",
+                passed: true,
+                detail: `Output type is ${typeof work.output}, parse check not applicable`,
+            });
+        }
+        // Check 5: Expected structure for agent type
+        const structureResult = this.checkExpectedStructure(work, outputStr);
+        checks.push(structureResult);
+        // Check 6: No error indicators in output
+        const errorIndicators = this.detectErrorIndicators(outputStr);
+        const noErrors = errorIndicators.length === 0;
+        checks.push({
+            name: "No error indicators",
+            passed: noErrors,
+            detail: noErrors
+                ? "No error patterns detected"
+                : `Found error indicators: ${errorIndicators.join(", ")}`,
+        });
+        // Valid only if all critical checks pass (exists, non-empty, min-length, parseable, no errors)
+        const valid = outputExists && nonEmpty && meetsMinLength && parseableCheck && noErrors;
+        return { valid, checks };
+    }
+    /**
+     * Get minimum output length based on agent type.
+     * Different agents produce different amounts of output.
+     */
+    getMinimumLengthForAgent(agentType) {
+        const minimums = {
+            planner: 100, // Plans need steps, dependencies
+            analyzer: 80, // Analysis needs findings
+            reviewer: 80, // Reviews need assessments
+            rewriter: 50, // Rewrites can be small targeted fixes
+            ui_designer: 100, // UI output needs structure
+            researcher: 100, // Research needs findings, sources
+            gatekeeper: 50, // Gatekeeper output can be concise
+            master: 30, // Master coordination can be terse
+        };
+        return minimums[agentType] ?? 50;
+    }
+    /**
+     * Check if output has the expected structure for the given agent type.
+     * Each agent type has characteristic patterns in its output.
+     */
+    checkExpectedStructure(work, outputStr) {
+        // Agent-type-specific structural expectations
+        const expectations = {
+            planner: {
+                patterns: [
+                    /(?:step|phase|stage)\s*\d/i,
+                    /(?:depend|prerequisite|requires|before|after)/i,
+                    /(?:goal|objective|target|outcome)/i,
+                    /(?:estimate|timeline|duration|time)/i,
+                    /(?:\d+[\.\)]\s|\-\s|\*\s)/m, // numbered/bulleted lists
+                ],
+                minMatches: 2,
+                description: "Planner output should have steps/phases, dependencies, and goals",
+            },
+            analyzer: {
+                patterns: [
+                    /(?:issue|problem|finding|defect|bug|vulnerability)/i,
+                    /(?:severity|critical|high|medium|low|priority)/i,
+                    /(?:file|line|location|at\s)/i,
+                    /(?:recommend|suggest|fix|remediat)/i,
+                ],
+                minMatches: 2,
+                description: "Analyzer output should have issues with severity and recommendations",
+            },
+            reviewer: {
+                patterns: [
+                    /(?:review|assess|evaluat|examin)/i,
+                    /(?:quality|correct|complet|accura)/i,
+                    /(?:approved?|decline|accept|reject|pass|fail)/i,
+                    /(?:feedback|comment|note|observation)/i,
+                ],
+                minMatches: 2,
+                description: "Reviewer output should have assessments, quality judgments, and feedback",
+            },
+            rewriter: {
+                patterns: [
+                    /(?:function|class|const|let|var|import|export|def |return)/i,
+                    /(?:\{[\s\S]*\}|\([\s\S]*\))/,
+                    /(?:fix|change|modif|updat|refactor)/i,
+                ],
+                minMatches: 1,
+                description: "Rewriter output should contain code with functions/classes and change indicators",
+            },
+            ui_designer: {
+                patterns: [
+                    /(?:component|layout|design|view|page|screen)/i,
+                    /(?:style|css|class|tailwind|color|theme)/i,
+                    /(?:<\w+[\s>]|jsx|tsx|html|svg)/i,
+                    /(?:responsive|mobile|desktop|tablet|breakpoint)/i,
+                ],
+                minMatches: 2,
+                description: "UI designer output should have component/layout structure and styling",
+            },
+            researcher: {
+                patterns: [
+                    /(?:source|reference|citation|link|url|http)/i,
+                    /(?:finding|result|discover|evidence|data)/i,
+                    /(?:conclusion|summary|overview)/i,
+                    /(?:relevant|related|similar|comparison)/i,
+                ],
+                minMatches: 2,
+                description: "Researcher output should have sources, findings, and conclusions",
+            },
+            gatekeeper: {
+                patterns: [
+                    /(?:approve|decline|decision|verdict)/i,
+                    /(?:issue|concern|problem)/i,
+                    /(?:confidence|score|rating)/i,
+                ],
+                minMatches: 1,
+                description: "Gatekeeper output should have a decision and confidence score",
+            },
+            master: {
+                patterns: [
+                    /(?:dispatch|coordinate|assign|delegate|route)/i,
+                    /(?:agent|subagent|task)/i,
+                ],
+                minMatches: 1,
+                description: "Master output should have coordination and agent dispatch info",
+            },
+        };
+        const expectation = expectations[work.agentType] ?? expectations.analyzer;
+        const matches = expectation.patterns.filter((p) => p.test(outputStr));
+        const passed = matches.length >= expectation.minMatches;
+        return {
+            name: `Expected structure (${work.agentType})`,
+            passed,
+            detail: passed
+                ? `Matched ${matches.length}/${expectation.patterns.length} expected patterns (need ≥${expectation.minMatches})`
+                : `Only matched ${matches.length}/${expectation.patterns.length} patterns (need ≥${expectation.minMatches}). ${expectation.description}`,
+        };
+    }
+    /**
+     * Detect error indicators in output text.
+     * Returns a list of matched error pattern descriptions.
+     */
+    detectErrorIndicators(outputStr) {
+        const found = [];
+        for (const pattern of ERROR_INDICATORS) {
+            if (pattern.test(outputStr)) {
+                found.push(pattern.source);
+            }
+        }
+        return found;
+    }
+    // ==========================================================================
+    // Quality Heuristics — rule-based scoring per agent type
+    // ==========================================================================
+    /**
+     * Evaluate quality heuristics based on agent type.
+     * Returns a weighted score between 0.0-1.0 with detailed check breakdown.
+     */
+    evaluateQualityHeuristics(work, outputStr) {
+        // Run common checks first, then agent-specific checks
+        const commonChecks = this.runCommonQualityChecks(outputStr);
+        const agentChecks = this.runAgentSpecificQualityChecks(work, outputStr);
+        const allChecks = [...commonChecks, ...agentChecks];
+        // Calculate weighted score
+        const totalWeight = allChecks.reduce((sum, c) => sum + c.weight, 0);
+        const earnedWeight = allChecks
+            .filter((c) => c.passed)
+            .reduce((sum, c) => sum + c.weight, 0);
+        const score = totalWeight > 0 ? earnedWeight / totalWeight : 0;
+        return { score, checks: allChecks };
+    }
+    /**
+     * Common quality checks applicable to all agent types.
+     */
+    runCommonQualityChecks(outputStr) {
+        const checks = [];
+        const trimmed = outputStr.trim();
+        // Check: Reasonable length (not suspiciously short)
+        const reasonableLength = trimmed.length >= 50;
+        checks.push({
+            name: "Reasonable length",
+            passed: reasonableLength,
+            weight: 0.15,
+            detail: reasonableLength
+                ? `Length ${trimmed.length} chars is reasonable`
+                : `Length ${trimmed.length} chars is suspiciously short`,
+        });
+        // Check: Has substantive content (not just boilerplate/filler)
+        const fillerPatterns = /^(ok|done|completed|finished|success|no issues?|looks good|lgtm)\s*\.?$/im;
+        const notJustFiller = !fillerPatterns.test(trimmed);
+        checks.push({
+            name: "Substantive content",
+            passed: notJustFiller,
+            weight: 0.2,
+            detail: notJustFiller
+                ? "Output contains substantive content"
+                : "Output appears to be only filler/boilerplate text",
+        });
+        // Check: No excessive repetition (same line repeated many times)
+        const lines = trimmed.split("\n").filter((l) => l.trim().length > 0);
+        const uniqueLines = new Set(lines.map((l) => l.trim()));
+        const repetitionRatio = lines.length > 0 ? uniqueLines.size / lines.length : 1;
+        const notExcessivelyRepetitive = repetitionRatio > 0.3;
+        checks.push({
+            name: "No excessive repetition",
+            passed: notExcessivelyRepetitive,
+            weight: 0.1,
+            detail: notExcessivelyRepetitive
+                ? `Repetition ratio: ${(repetitionRatio * 100).toFixed(0)}% unique lines`
+                : `Too repetitive: only ${(repetitionRatio * 100).toFixed(0)}% unique lines`,
+        });
+        // Check: No placeholder markers left
+        const placeholderPattern = /\[(?:TODO|PLACEHOLDER|INSERT|FILL|TBD)\]|\.{3,}(?:\s*$)/im;
+        const noPlaceholders = !placeholderPattern.test(trimmed);
+        checks.push({
+            name: "No placeholders",
+            passed: noPlaceholders,
+            weight: 0.15,
+            detail: noPlaceholders
+                ? "No placeholder markers detected"
+                : "Found placeholder markers (TODO, INSERT, TBD, etc.) in output",
+        });
+        return checks;
+    }
+    /**
+     * Agent-type-specific quality checks.
+     * Each agent type has unique expectations for what constitutes quality output.
+     */
+    runAgentSpecificQualityChecks(work, outputStr) {
+        switch (work.agentType) {
+            case "planner":
+                return this.checkPlannerQuality(outputStr);
+            case "analyzer":
+                return this.checkAnalyzerQuality(outputStr);
+            case "reviewer":
+                return this.checkReviewerQuality(outputStr);
+            case "rewriter":
+                return this.checkRewriterQuality(work, outputStr);
+            case "ui_designer":
+                return this.checkUIDesignerQuality(outputStr);
+            case "researcher":
+                return this.checkResearcherQuality(outputStr);
+            default:
+                return this.checkGenericQuality(outputStr);
+        }
+    }
+    /**
+     * Planner output: should have numbered steps, dependencies, clear structure.
+     */
+    checkPlannerQuality(outputStr) {
+        const checks = [];
+        // Has numbered/ordered steps
+        const stepPattern = /(?:\d+[\.\)]\s|\bstep\s+\d+)/gi;
+        const stepMatches = outputStr.match(stepPattern);
+        const hasSteps = (stepMatches?.length ?? 0) >= 2;
+        checks.push({
+            name: "Has ordered steps",
+            passed: hasSteps,
+            weight: 0.15,
+            detail: hasSteps
+                ? `Found ${stepMatches?.length ?? 0} ordered steps`
+                : "Missing ordered steps (need at least 2)",
+        });
+        // Mentions dependencies or ordering
+        const hasDeps = /(?:depend|prerequisite|requires|before|after|block)/i.test(outputStr);
+        checks.push({
+            name: "Mentions dependencies",
+            passed: hasDeps,
+            weight: 0.1,
+            detail: hasDeps
+                ? "Dependencies/ordering mentioned"
+                : "No dependency or ordering mentions found",
+        });
+        // Has sections or structured formatting
+        const hasSections = /(?:#{1,3}\s|\*\*[^*]+\*\*|={3,}|-{3,})/m.test(outputStr);
+        checks.push({
+            name: "Structured formatting",
+            passed: hasSections,
+            weight: 0.05,
+            detail: hasSections
+                ? "Output has structured sections"
+                : "Output lacks clear section structure",
+        });
+        // Addresses the task (references files from context if any)
+        const hasSpecifics = /(?:file|component|module|service|api|endpoint)/i.test(outputStr);
+        checks.push({
+            name: "Task-specific content",
+            passed: hasSpecifics,
+            weight: 0.1,
+            detail: hasSpecifics
+                ? "References specific files/components"
+                : "Lacks specific file/component references",
+        });
+        return checks;
+    }
+    /**
+     * Analyzer output: should have issues with severity and structured findings.
+     */
+    checkAnalyzerQuality(outputStr) {
+        const checks = [];
+        // Has severity indicators
+        const hasSeverity = /(?:critical|high|medium|low|severity|priority|warning|info)/i.test(outputStr);
+        checks.push({
+            name: "Has severity levels",
+            passed: hasSeverity,
+            weight: 0.15,
+            detail: hasSeverity
+                ? "Severity levels present"
+                : "Missing severity level indicators",
+        });
+        // Has structured findings (not just prose)
+        const hasFindings = /(?:issue|finding|problem|defect|bug|vulnerability|violation)/i.test(outputStr);
+        checks.push({
+            name: "Has structured findings",
+            passed: hasFindings,
+            weight: 0.15,
+            detail: hasFindings
+                ? "Structured findings present"
+                : "Missing structured findings/issues",
+        });
+        // Has remediation/recommendations
+        const hasRemediation = /(?:recommend|suggest|fix|remediat|resolution|solution)/i.test(outputStr);
+        checks.push({
+            name: "Has remediation advice",
+            passed: hasRemediation,
+            weight: 0.1,
+            detail: hasRemediation
+                ? "Remediation advice present"
+                : "Missing remediation/fix recommendations",
+        });
+        return checks;
+    }
+    /**
+     * Reviewer output: should have quality assessment and actionable feedback.
+     */
+    checkReviewerQuality(outputStr) {
+        const checks = [];
+        // Has an explicit decision/assessment
+        const hasDecision = /(?:approved?|decline|accept|reject|pass|fail|verdict|recommend)/i.test(outputStr);
+        checks.push({
+            name: "Has explicit decision",
+            passed: hasDecision,
+            weight: 0.15,
+            detail: hasDecision
+                ? "Contains an explicit review decision"
+                : "Missing explicit approve/decline decision",
+        });
+        // Has reasoning/justification
+        const hasReasoning = /(?:because|reason|rationale|since|due to|given that|therefore)/i.test(outputStr);
+        checks.push({
+            name: "Has reasoning",
+            passed: hasReasoning,
+            weight: 0.1,
+            detail: hasReasoning
+                ? "Reasoning/justification provided"
+                : "Missing reasoning for the decision",
+        });
+        // Has actionable feedback
+        const hasFeedback = /(?:should|could|consider|improve|change|add|remove|ensure)/i.test(outputStr);
+        checks.push({
+            name: "Has actionable feedback",
+            passed: hasFeedback,
+            weight: 0.15,
+            detail: hasFeedback
+                ? "Actionable feedback present"
+                : "Missing actionable improvement suggestions",
+        });
+        return checks;
+    }
+    /**
+     * Rewriter output: should contain code that differs from input, with balanced syntax.
+     */
+    checkRewriterQuality(work, outputStr) {
+        const checks = [];
+        // Has actual code content
+        const codePatterns = /(?:function|class|const|let|var|import|export|def |return|if\s*\(|for\s*\(|while\s*\()/i;
+        const hasCode = codePatterns.test(outputStr);
+        checks.push({
+            name: "Contains code",
+            passed: hasCode,
+            weight: 0.2,
+            detail: hasCode
+                ? "Code content detected"
+                : "No recognizable code patterns found",
+        });
+        // Check balanced braces/brackets/parens
+        const balanced = this.checkBalancedDelimiters(outputStr);
+        checks.push({
+            name: "Balanced delimiters",
+            passed: balanced.balanced,
+            weight: 0.15,
+            detail: balanced.balanced
+                ? "All braces, brackets, and parens are balanced"
+                : `Unbalanced delimiters: ${balanced.detail}`,
+        });
+        // Output differs from input (not a no-op)
+        const inputStr = this.formatOutput(work.task.prompt);
+        const isDifferent = outputStr.trim() !== inputStr.trim() &&
+            !outputStr.includes("no changes needed");
+        checks.push({
+            name: "Output differs from input",
+            passed: isDifferent,
+            weight: 0.05,
+            detail: isDifferent
+                ? "Output contains modifications"
+                : "Output appears identical to input or explicitly states no changes",
+        });
+        return checks;
+    }
+    /**
+     * UI designer output: should have component structure, styling, and accessibility mentions.
+     */
+    checkUIDesignerQuality(outputStr) {
+        const checks = [];
+        // Has component/layout structure
+        const hasStructure = /(?:<\w+|component|layout|container|wrapper|grid|flex|section)/i.test(outputStr);
+        checks.push({
+            name: "Has component structure",
+            passed: hasStructure,
+            weight: 0.15,
+            detail: hasStructure
+                ? "Component/layout structure detected"
+                : "Missing component or layout structure",
+        });
+        // Has styling references
+        const hasStyling = /(?:style|css|class|className|tailwind|color|bg-|text-|p-|m-|w-|h-)/i.test(outputStr);
+        checks.push({
+            name: "Has styling",
+            passed: hasStyling,
+            weight: 0.1,
+            detail: hasStyling
+                ? "Styling references found"
+                : "Missing styling/CSS references",
+        });
+        // Mentions accessibility
+        const hasA11y = /(?:aria-|role=|alt=|accessib|wcag|screen.?reader|semantic)/i.test(outputStr);
+        checks.push({
+            name: "Accessibility awareness",
+            passed: hasA11y,
+            weight: 0.1,
+            detail: hasA11y
+                ? "Accessibility considerations present"
+                : "No accessibility mentions (aria, role, alt, etc.)",
+        });
+        // Has responsive design mentions
+        const hasResponsive = /(?:responsive|mobile|desktop|tablet|breakpoint|media|sm:|md:|lg:|xl:)/i.test(outputStr);
+        checks.push({
+            name: "Responsive design",
+            passed: hasResponsive,
+            weight: 0.05,
+            detail: hasResponsive
+                ? "Responsive design considerations present"
+                : "No responsive design mentions",
+        });
+        return checks;
+    }
+    /**
+     * Researcher output: should have sources, findings, and evidence.
+     */
+    checkResearcherQuality(outputStr) {
+        const checks = [];
+        // Has source references
+        const hasSources = /(?:source|reference|citation|http|url|link|according to|per )/i.test(outputStr);
+        checks.push({
+            name: "Has source references",
+            passed: hasSources,
+            weight: 0.15,
+            detail: hasSources
+                ? "Source references found"
+                : "Missing source references or citations",
+        });
+        // Has key findings
+        const hasFindings = /(?:finding|result|discover|evidence|data|conclusion|insight)/i.test(outputStr);
+        checks.push({
+            name: "Has key findings",
+            passed: hasFindings,
+            weight: 0.15,
+            detail: hasFindings
+                ? "Key findings present"
+                : "Missing key findings or evidence",
+        });
+        // Has summary or conclusion
+        const hasSummary = /(?:summary|conclusion|overview|in summary|to summarize|key takeaway)/i.test(outputStr);
+        checks.push({
+            name: "Has summary/conclusion",
+            passed: hasSummary,
+            weight: 0.1,
+            detail: hasSummary
+                ? "Summary/conclusion present"
+                : "Missing summary or concluding section",
+        });
+        return checks;
+    }
+    /**
+     * Generic quality checks for agent types without specific heuristics.
+     */
+    checkGenericQuality(outputStr) {
+        const checks = [];
+        const hasStructure = /(?:#{1,3}\s|\*\*[^*]+\*\*|\d+[\.\)]\s|\-\s\S)/m.test(outputStr);
+        checks.push({
+            name: "Has structure",
+            passed: hasStructure,
+            weight: 0.2,
+            detail: hasStructure
+                ? "Output has recognizable structure"
+                : "Output lacks clear structure (headings, lists, etc.)",
+        });
+        const hasDetail = outputStr.length >= 100;
+        checks.push({
+            name: "Has sufficient detail",
+            passed: hasDetail,
+            weight: 0.2,
+            detail: hasDetail
+                ? `Output has ${outputStr.length} characters of detail`
+                : `Output is too brief (${outputStr.length} chars)`,
+        });
+        return checks;
+    }
+    /**
+     * Check if delimiters ({}, [], ()) are balanced in the output.
+     * Important for code output — unbalanced delimiters usually mean broken code.
+     */
+    checkBalancedDelimiters(text) {
+        // Strip string literals and comments to avoid false positives
+        const stripped = text
+            .replace(/\/\/.*$/gm, "") // single-line comments
+            .replace(/\/\*[\s\S]*?\*\//g, "") // multi-line comments
+            .replace(/#.*$/gm, "") // Python-style comments
+            .replace(/"(?:[^"\\]|\\.)*"/g, '""') // double-quoted strings
+            .replace(/'(?:[^'\\]|\\.)*'/g, "''") // single-quoted strings
+            .replace(/`(?:[^`\\]|\\.)*`/g, "``"); // template literals
+        let braces = 0;
+        let brackets = 0;
+        let parens = 0;
+        for (const ch of stripped) {
+            if (ch === "{")
+                braces++;
+            else if (ch === "}")
+                braces--;
+            else if (ch === "[")
+                brackets++;
+            else if (ch === "]")
+                brackets--;
+            else if (ch === "(")
+                parens++;
+            else if (ch === ")")
+                parens--;
+            // Early exit: if any counter goes negative, we have a closing without opening
+            if (braces < 0 || brackets < 0 || parens < 0) {
+                const problems = [];
+                if (braces < 0)
+                    problems.push("extra closing }");
+                if (brackets < 0)
+                    problems.push("extra closing ]");
+                if (parens < 0)
+                    problems.push("extra closing )");
+                return { balanced: false, detail: problems.join(", ") };
+            }
+        }
+        if (braces === 0 && brackets === 0 && parens === 0) {
+            return { balanced: true, detail: "All delimiters balanced" };
+        }
+        const problems = [];
+        if (braces !== 0)
+            problems.push(`braces off by ${braces > 0 ? "+" : ""}${braces}`);
+        if (brackets !== 0)
+            problems.push(`brackets off by ${brackets > 0 ? "+" : ""}${brackets}`);
+        if (parens !== 0)
+            problems.push(`parens off by ${parens > 0 ? "+" : ""}${parens}`);
+        return { balanced: false, detail: problems.join(", ") };
+    }
+    // ==========================================================================
+    // Output Formatting
+    // ==========================================================================
+    /**
+     * Format output for review
+     */
+    formatOutput(output) {
+        if (!output)
+            return "No output provided";
+        if (typeof output === "string") {
+            return output.substring(0, 6000);
+        }
+        try {
+            const jsonStr = JSON.stringify(output, null, 2);
+            return jsonStr.substring(0, 6000);
+        }
+        catch {
+            return String(output).substring(0, 6000);
+        }
+    }
+    /**
+     * Parse the review response
+     */
+    parseReviewResponse(response) {
+        try {
+            // Try to extract JSON from response
+            const jsonMatch = response.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                return this.analyzeTextDecision(response);
+            }
+            const parsed = JSON.parse(jsonMatch[0]);
+            // Determine decision
+            let decision = "approve";
+            if (parsed.decision) {
+                if (parsed.decision === "decline") {
+                    decision = "decline";
+                }
+                else if (parsed.decision === "approve") {
+                    decision = "approve";
+                }
+                else {
+                    // Handle other decisions like "request_revision"
+                    decision =
+                        parsed.decision === "request_revision" ? "decline" : "approve";
+                }
+            }
+            // Check for critical issues that should trigger decline
+            const criticalIssues = (parsed.issues || []).filter((i) => i.severity === "critical");
+            const highIssues = (parsed.issues || []).filter((i) => i.severity === "high");
+            const mustHaveSuggestions = (parsed.suggestions || []).filter((s) => s.priority === "must");
+            // Override decision based on issue severity
+            if (criticalIssues.length > 0) {
+                decision = "decline";
+            }
+            else if (highIssues.length > 0 && this.config.strictMode) {
+                decision = "decline";
+            }
+            else if (mustHaveSuggestions.length > 0) {
+                decision = "decline";
+            }
+            // Calculate confidence
+            let confidence = parsed.confidence ?? 0.7;
+            confidence -= parsed.issues?.length * 0.05 || 0;
+            confidence = Math.max(0, Math.min(1, confidence));
+            return {
+                decision,
+                confidence,
+                reasoning: parsed.reasoning || "Review completed",
+                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",
+                    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 || "",
+                })),
+            };
+        }
+        catch {
+            return this.analyzeTextDecision(response);
+        }
+    }
+    /**
+     * Analyze text response when JSON parsing fails
+     */
+    analyzeTextDecision(response) {
+        const lower = response.toLowerCase();
+        // Check for negative indicators
+        const hasCritical = lower.includes("critical");
+        const hasHigh = lower.includes("high severity");
+        const hasMajor = lower.includes("major issue");
+        const needsWork = lower.includes("needs work") || lower.includes("should fix");
+        let decision = "approve";
+        if (hasCritical || hasHigh || hasMajor || needsWork) {
+            decision = "decline";
+        }
+        return {
+            decision,
+            confidence: decision === "approve" ? 0.6 : 0.4,
+            reasoning: response.substring(0, 300),
+            issues: decision === "decline"
+                ? [
+                    {
+                        id: "text-issue-1",
+                        severity: "medium",
+                        category: "code_quality",
+                        description: "Issue detected from text analysis",
+                        evidence: response.substring(0, 200),
+                        remediation: "Review and fix the identified issues",
+                    },
+                ]
+                : [],
+            suggestions: [],
+        };
+    }
+    /**
+     * Check if max retries exceeded
+     */
+    hasExceededMaxRetries() {
+        return this.retryHistory.length >= this.config.maxRetries;
+    }
+    /**
+     * Get current retry count
+     */
+    getRetryCount() {
+        return this.retryHistory.length;
+    }
+    /**
+     * Get retry history
+     */
+    getRetryHistory() {
+        return [...this.retryHistory];
+    }
+    /**
+     * Reset history for new task
+     */
+    reset() {
+        this.retryHistory = [];
+    }
+    /**
+     * Get config
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+}
+// ============================================================================
+// Factory
+// ============================================================================
+export function createInternalGatekeeper(agentType, toolBridge, config) {
+    return new InternalGatekeeper(agentType, toolBridge, config);
+}
+//# sourceMappingURL=internal-gatekeeper.js.map