@simonren/quorum 0.7.0

package/dist/schema.js

@@ -0,0 +1,536 @@
+/**
+ * Structured Output Schemas for AI Review
+ *
+ * Uses Zod for strict validation of reviewer output.
+ * This replaces the fragile regex-based markdown validation.
+ */
+import { z } from 'zod';
+// =============================================================================
+// SEVERITY & CONFIDENCE SCALES
+// =============================================================================
+export const SeverityLevel = z.enum(['critical', 'high', 'medium', 'low', 'info']);
+export const ConfidenceLevel = z.enum(['verified', 'high', 'medium', 'low', 'uncertain']);
+// Numeric confidence score (0-1)
+export const ConfidenceScore = z.number().min(0).max(1);
+/**
+ * Sentinel used when a reviewer omits `confidence` on a finding, agreement,
+ * or disagreement. Confidence is required by the Zod schema, but external
+ * CLIs occasionally drop the field — rather than reject the whole review,
+ * normalization fills it with this midpoint value. 0.5 reads as "the
+ * reviewer did not commit to a confidence" without skewing the result
+ * toward "confidently right" or "confidently wrong".
+ */
+export const DEFAULT_FINDING_CONFIDENCE = 0.5;
+// =============================================================================
+// CODE LOCATION
+// =============================================================================
+export const CodeLocation = z.object({
+    file: z.string().describe('Relative file path from working directory'),
+    line_start: z.number().int().positive().optional().describe('Starting line number'),
+    line_end: z.number().int().positive().optional().describe('Ending line number'),
+    column_start: z.number().int().nonnegative().optional().describe('Starting column'),
+    column_end: z.number().int().nonnegative().optional().describe('Ending column'),
+});
+// =============================================================================
+// REVIEW FINDING
+// =============================================================================
+export const ReviewFinding = z.object({
+    id: z.string().describe('Unique identifier for this finding'),
+    category: z.enum([
+        'security',
+        'performance',
+        'architecture',
+        'correctness',
+        'maintainability',
+        'scalability',
+        'testing',
+        'documentation',
+        'best-practice',
+        'other'
+    ]).describe('Primary category of the finding'),
+    severity: SeverityLevel.describe('Impact severity level'),
+    confidence: ConfidenceScore.describe('Confidence in this finding (0-1). Required. If the reviewer omits this field, normalizeReviewOutput fills it with DEFAULT_FINDING_CONFIDENCE (0.5) so the whole review is not dropped.'),
+    title: z.string().max(120).describe('Brief title summarizing the issue'),
+    description: z.string().describe('Detailed explanation of the finding'),
+    location: CodeLocation.optional().describe('Where in the code this applies'),
+    evidence: z.string().optional().describe('Code snippet or proof supporting the finding'),
+    suggestion: z.string().optional().describe('Recommended fix or improvement'),
+    // Security-specific metadata
+    cwe_id: z.string().regex(/^CWE-\d+$/).optional().describe('CWE identifier for security issues'),
+    owasp_category: z.string().optional().describe('OWASP Top 10 category if applicable'),
+    // Tags for filtering
+    tags: z.array(z.string()).optional().describe('Additional classification tags'),
+});
+// =============================================================================
+// AGREEMENT/DISAGREEMENT WITH CC's WORK
+// =============================================================================
+export const Agreement = z.object({
+    original_claim: z.string().describe("The claim from CC's output being validated"),
+    assessment: z.enum(['correct', 'mostly_correct', 'partially_correct']),
+    confidence: ConfidenceScore,
+    supporting_evidence: z.string().optional().describe('Evidence supporting agreement'),
+    notes: z.string().optional().describe('Additional context or caveats'),
+});
+export const Disagreement = z.object({
+    original_claim: z.string().describe("The claim from CC's output being challenged"),
+    issue: z.enum(['incorrect', 'misleading', 'incomplete', 'outdated', 'hallucinated']),
+    confidence: ConfidenceScore,
+    reason: z.string().describe('Why this claim is problematic'),
+    correction: z.string().optional().describe('The correct assessment'),
+    evidence: z.string().optional().describe('Evidence supporting the disagreement'),
+});
+// =============================================================================
+// ALTERNATIVE APPROACH
+// =============================================================================
+export const Alternative = z.object({
+    topic: z.string().describe('What aspect this alternative addresses'),
+    current_approach: z.string().describe("Description of CC's approach"),
+    alternative: z.string().describe('The suggested alternative'),
+    tradeoffs: z.object({
+        pros: z.array(z.string()),
+        cons: z.array(z.string()),
+    }),
+    recommendation: z.enum(['strongly_prefer', 'consider', 'situational', 'informational']),
+});
+// =============================================================================
+// RISK ASSESSMENT
+// =============================================================================
+export const RiskAssessment = z.object({
+    overall_level: z.enum(['critical', 'high', 'medium', 'low', 'minimal']),
+    score: z.number().min(0).max(100).describe('Numeric risk score 0-100'),
+    summary: z.string().max(300).describe('Brief risk summary'),
+    top_concerns: z.array(z.string()).describe('Top risk factors'),
+    mitigations: z.array(z.string()).optional().describe('Suggested mitigations'),
+});
+// =============================================================================
+// UNCERTAINTY & QUESTION RESPONSES
+// =============================================================================
+export const UncertaintyResponse = z.object({
+    uncertainty_index: z.number().int().positive().describe('1-based index of the uncertainty being addressed'),
+    verified: z.boolean().describe('Whether the uncertainty was verified'),
+    finding: z.string().describe('What the reviewer found'),
+    recommendation: z.string().nullable().optional().describe('What CC should do'),
+});
+export const QuestionAnswer = z.object({
+    question_index: z.number().int().positive().describe('1-based index of the question being answered'),
+    answer: z.string().describe('The reviewer answer'),
+    confidence: ConfidenceScore.nullable().optional().describe('Confidence in the answer (0-1)'),
+});
+// =============================================================================
+// COMPLETE REVIEW OUTPUT (Single Reviewer)
+// =============================================================================
+export const ReviewOutput = z.object({
+    reviewer: z.string().describe('Name of the reviewing model'),
+    timestamp: z.string().datetime().nullable().optional(),
+    // Core sections
+    findings: z.array(ReviewFinding).describe('New issues discovered'),
+    agreements: z.array(Agreement).describe("Validation of CC's correct assessments"),
+    disagreements: z.array(Disagreement).describe("Challenges to CC's claims"),
+    alternatives: z.array(Alternative).describe('Alternative approaches to consider'),
+    // Responses to CC's uncertainties and questions — nullable because OpenAI strict mode sends null
+    uncertainty_responses: z.array(UncertaintyResponse).nullable().optional().describe('Responses to CC uncertainties'),
+    question_answers: z.array(QuestionAnswer).nullable().optional().describe('Answers to CC questions'),
+    // Summary
+    risk_assessment: RiskAssessment,
+    // Metadata — nullable because OpenAI strict mode sends null
+    files_examined: z.array(z.string()).nullable().optional().describe('Files the reviewer actually read'),
+    execution_notes: z.string().nullable().optional().describe('Notes about the review process'),
+});
+// =============================================================================
+// PEER REVIEW (Model reviewing another model's output)
+// =============================================================================
+export const PeerScore = z.object({
+    finding_id: z.string(),
+    validity: z.enum(['valid', 'questionable', 'invalid', 'cannot_assess']),
+    confidence: ConfidenceScore,
+    notes: z.string().optional(),
+});
+export const PeerReview = z.object({
+    reviewer: z.string().describe('Model doing the peer review'),
+    reviewed_model: z.string().describe('Model being reviewed (anonymized)'),
+    scores: z.array(PeerScore),
+    overall_quality: z.number().min(0).max(1),
+    summary: z.string().optional(),
+});
+// =============================================================================
+// JSON SCHEMA GENERATION FOR PROMPTS
+// =============================================================================
+/**
+ * Generate a simplified JSON schema for embedding in prompts.
+ * External CLIs don't support Zod directly, so we provide a JSON schema.
+ */
+export function getReviewOutputJsonSchema() {
+    return {
+        type: 'object',
+        additionalProperties: false,
+        required: ['reviewer', 'findings', 'agreements', 'disagreements', 'alternatives', 'risk_assessment', 'uncertainty_responses', 'question_answers'],
+        properties: {
+            reviewer: { type: 'string' },
+            findings: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: ['id', 'category', 'severity', 'confidence', 'title', 'description'],
+                    properties: {
+                        id: { type: 'string' },
+                        category: {
+                            type: 'string',
+                            enum: ['security', 'performance', 'architecture', 'correctness',
+                                'maintainability', 'scalability', 'testing', 'documentation',
+                                'best-practice', 'other']
+                        },
+                        severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low', 'info'] },
+                        confidence: { type: 'number', minimum: 0, maximum: 1 },
+                        title: { type: 'string', maxLength: 120 },
+                        description: { type: 'string' }
+                    }
+                }
+            },
+            agreements: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: ['original_claim', 'assessment', 'confidence'],
+                    properties: {
+                        original_claim: { type: 'string' },
+                        assessment: { type: 'string', enum: ['correct', 'mostly_correct', 'partially_correct'] },
+                        confidence: { type: 'number', minimum: 0, maximum: 1 }
+                    }
+                }
+            },
+            disagreements: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: ['original_claim', 'issue', 'confidence', 'reason'],
+                    properties: {
+                        original_claim: { type: 'string' },
+                        issue: { type: 'string', enum: ['incorrect', 'misleading', 'incomplete', 'outdated', 'hallucinated'] },
+                        confidence: { type: 'number', minimum: 0, maximum: 1 },
+                        reason: { type: 'string' }
+                    }
+                }
+            },
+            alternatives: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: ['topic', 'current_approach', 'alternative', 'tradeoffs', 'recommendation'],
+                    properties: {
+                        topic: { type: 'string' },
+                        current_approach: { type: 'string' },
+                        alternative: { type: 'string' },
+                        tradeoffs: {
+                            type: 'object',
+                            additionalProperties: false,
+                            required: ['pros', 'cons'],
+                            properties: {
+                                pros: { type: 'array', items: { type: 'string' } },
+                                cons: { type: 'array', items: { type: 'string' } }
+                            }
+                        },
+                        recommendation: { type: 'string', enum: ['strongly_prefer', 'consider', 'situational', 'informational'] }
+                    }
+                }
+            },
+            uncertainty_responses: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: ['uncertainty_index', 'verified', 'finding', 'recommendation'],
+                    properties: {
+                        uncertainty_index: { type: 'integer', minimum: 1 },
+                        verified: { type: 'boolean' },
+                        finding: { type: 'string' },
+                        recommendation: { anyOf: [{ type: 'string' }, { type: 'null' }] }
+                    }
+                }
+            },
+            question_answers: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: ['question_index', 'answer', 'confidence'],
+                    properties: {
+                        question_index: { type: 'integer', minimum: 1 },
+                        answer: { type: 'string' },
+                        confidence: { anyOf: [{ type: 'number', minimum: 0, maximum: 1 }, { type: 'null' }] }
+                    }
+                }
+            },
+            risk_assessment: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['overall_level', 'score', 'summary', 'top_concerns'],
+                properties: {
+                    overall_level: { type: 'string', enum: ['critical', 'high', 'medium', 'low', 'minimal'] },
+                    score: { type: 'number', minimum: 0, maximum: 100 },
+                    summary: { type: 'string', maxLength: 300 },
+                    top_concerns: { type: 'array', items: { type: 'string' } }
+                }
+            }
+        }
+    };
+}
+/**
+ * Fill `confidence` with the sentinel when an object-shaped item omits it.
+ * Leaves non-object items alone so downstream Zod validation still surfaces
+ * a useful error for genuinely malformed entries.
+ */
+function fillMissingConfidence(item) {
+    if (!item || typeof item !== 'object' || Array.isArray(item))
+        return item;
+    const obj = item;
+    if (typeof obj.confidence === 'number')
+        return obj;
+    return { ...obj, confidence: DEFAULT_FINDING_CONFIDENCE };
+}
+/**
+ * Normalize reviewer output that deviates from the strict schema.
+ * Handles common patterns from external CLIs (e.g. Gemini returning
+ * agreements as strings instead of objects, missing required fields).
+ *
+ * Notably: `confidence` is required on findings/agreements/disagreements,
+ * but reviewers occasionally drop it. Rather than reject the whole review,
+ * we fill the missing field with DEFAULT_FINDING_CONFIDENCE so the rest of
+ * the review survives validation.
+ */
+function normalizeReviewOutput(parsed) {
+    const normalized = { ...parsed };
+    // Default reviewer if missing
+    if (!normalized.reviewer) {
+        normalized.reviewer = 'external';
+    }
+    // Normalize agreements: string[] -> Agreement[], then fill missing confidence
+    if (Array.isArray(normalized.agreements)) {
+        normalized.agreements = normalized.agreements.map((a) => {
+            if (typeof a === 'string') {
+                return { original_claim: a, assessment: 'correct', confidence: DEFAULT_FINDING_CONFIDENCE };
+            }
+            return fillMissingConfidence(a);
+        });
+    }
+    else {
+        normalized.agreements = normalized.agreements ?? [];
+    }
+    // Default missing arrays
+    normalized.disagreements = normalized.disagreements ?? [];
+    normalized.alternatives = normalized.alternatives ?? [];
+    normalized.findings = normalized.findings ?? [];
+    // Fill missing confidence on findings and disagreements (Zod requires it;
+    // dropping the whole review for one missing scalar is worse than a sentinel)
+    if (Array.isArray(normalized.findings)) {
+        normalized.findings = normalized.findings.map(fillMissingConfidence);
+    }
+    if (Array.isArray(normalized.disagreements)) {
+        normalized.disagreements = normalized.disagreements.map(fillMissingConfidence);
+    }
+    // Normalize optional response arrays — drop non-array values
+    if (normalized.uncertainty_responses !== undefined && !Array.isArray(normalized.uncertainty_responses)) {
+        delete normalized.uncertainty_responses;
+    }
+    if (normalized.question_answers !== undefined && !Array.isArray(normalized.question_answers)) {
+        delete normalized.question_answers;
+    }
+    // Normalize risk_assessment from simplified formats
+    if (!normalized.risk_assessment) {
+        const ra = normalized.risk_assessment;
+        normalized.risk_assessment = {
+            overall_level: 'medium',
+            score: 50,
+            summary: 'Risk assessment not provided by reviewer',
+            top_concerns: [],
+        };
+    }
+    else if (typeof normalized.risk_assessment === 'object') {
+        const ra = normalized.risk_assessment;
+        // Handle "level" instead of "overall_level", with case normalization
+        if (ra.level && !ra.overall_level) {
+            ra.overall_level = typeof ra.level === 'string' ? ra.level.toLowerCase() : ra.level;
+        }
+        else if (typeof ra.overall_level === 'string') {
+            ra.overall_level = ra.overall_level.toLowerCase();
+        }
+        // Default missing fields
+        ra.score = ra.score ?? 50;
+        ra.summary = ra.summary ?? 'No summary provided';
+        ra.top_concerns = ra.top_concerns ?? [];
+    }
+    return normalized;
+}
+/**
+ * Attempt to parse and validate reviewer output.
+ * Returns the validated output or null if invalid.
+ */
+export function parseReviewOutput(rawOutput) {
+    try {
+        // Try to extract JSON from the output (may be wrapped in markdown code blocks)
+        let jsonStr = rawOutput;
+        // Gemini CLI with --output-format json wraps the response in an envelope:
+        // { "session_id": "...", "response": "```json\n{...}\n```" }
+        // Try to unwrap this envelope first, but only if it matches the envelope shape.
+        try {
+            const envelope = JSON.parse(rawOutput);
+            if (envelope && typeof envelope.session_id === 'string' && typeof envelope.response === 'string') {
+                jsonStr = envelope.response;
+            }
+        }
+        catch {
+            // Not a valid JSON envelope, continue with raw output
+        }
+        // Extract from ```json ... ``` blocks
+        const jsonBlockMatch = jsonStr.match(/```(?:json)?\s*([\s\S]*?)```/);
+        if (jsonBlockMatch) {
+            jsonStr = jsonBlockMatch[1].trim();
+        }
+        // Try to find JSON object boundaries
+        const jsonStart = jsonStr.indexOf('{');
+        const jsonEnd = jsonStr.lastIndexOf('}');
+        if (jsonStart !== -1 && jsonEnd !== -1 && jsonEnd > jsonStart) {
+            jsonStr = jsonStr.slice(jsonStart, jsonEnd + 1);
+        }
+        const parsed = JSON.parse(jsonStr);
+        // Try direct parse first
+        const result = ReviewOutput.safeParse(parsed);
+        if (result.success) {
+            return result.data;
+        }
+        // Normalize common deviations from external CLIs (e.g. Gemini)
+        // Only attempt if parsed object has at least one recognizable review field
+        const recognizedFields = ['findings', 'agreements', 'disagreements', 'alternatives', 'risk_assessment', 'reviewer'];
+        const hasRecognizedField = typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed) &&
+            recognizedFields.some(f => f in parsed);
+        if (!hasRecognizedField) {
+            return null;
+        }
+        const normalized = normalizeReviewOutput(parsed);
+        const retryResult = ReviewOutput.safeParse(normalized);
+        if (retryResult.success) {
+            return retryResult.data;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if a review output contains substantive content worth returning.
+ * Centralizes the "is this review empty?" check that was duplicated in adapters.
+ */
+export function isSubstantiveReview(output) {
+    if (output.findings.length > 0)
+        return true;
+    if (output.disagreements && output.disagreements.length > 0)
+        return true;
+    if (output.uncertainty_responses && output.uncertainty_responses.length > 0)
+        return true;
+    if (output.question_answers && output.question_answers.length > 0)
+        return true;
+    if (output.risk_assessment.overall_level !== 'medium' || output.risk_assessment.score !== 50)
+        return true;
+    if (output.agreements && output.agreements.length > 0)
+        return true;
+    if (output.alternatives && output.alternatives.length > 0)
+        return true;
+    return false;
+}
+/**
+ * Convert legacy markdown format to structured output (best effort).
+ * This provides backwards compatibility during transition.
+ */
+export function parseLegacyMarkdownOutput(markdown, reviewer) {
+    try {
+        const output = {
+            reviewer,
+            findings: [],
+            agreements: [],
+            disagreements: [],
+            alternatives: [],
+            risk_assessment: {
+                overall_level: 'medium',
+                score: 50,
+                summary: 'Unable to parse structured risk assessment',
+                top_concerns: [],
+            },
+        };
+        // Parse ## Agreements section
+        const agreementsMatch = markdown.match(/## Agreements\n([\s\S]*?)(?=##|$)/);
+        if (agreementsMatch) {
+            const lines = agreementsMatch[1].split('\n').filter(l => l.trim().startsWith('-'));
+            for (const line of lines) {
+                const content = line.replace(/^-\s*/, '').trim();
+                if (content) {
+                    output.agreements.push({
+                        original_claim: content.split(':')[0] || content,
+                        assessment: 'correct',
+                        confidence: DEFAULT_FINDING_CONFIDENCE,
+                    });
+                }
+            }
+        }
+        // Parse ## Disagreements section
+        const disagreementsMatch = markdown.match(/## Disagreements\n([\s\S]*?)(?=##|$)/);
+        if (disagreementsMatch) {
+            const lines = disagreementsMatch[1].split('\n').filter(l => l.trim().startsWith('-'));
+            for (const line of lines) {
+                const content = line.replace(/^-\s*/, '').trim();
+                if (content) {
+                    output.disagreements.push({
+                        original_claim: content.split(':')[0] || content,
+                        issue: 'incorrect',
+                        confidence: DEFAULT_FINDING_CONFIDENCE,
+                        reason: content,
+                    });
+                }
+            }
+        }
+        // Parse ## Additions section as findings
+        const additionsMatch = markdown.match(/## Additions\n([\s\S]*?)(?=##|$)/);
+        if (additionsMatch) {
+            const lines = additionsMatch[1].split('\n').filter(l => l.trim().startsWith('-'));
+            let idx = 0;
+            for (const line of lines) {
+                const content = line.replace(/^-\s*/, '').trim();
+                if (content) {
+                    const locationMatch = content.match(/([^:]+):(\d+)/);
+                    output.findings.push({
+                        id: `legacy-${idx++}`,
+                        category: 'other',
+                        severity: 'medium',
+                        confidence: DEFAULT_FINDING_CONFIDENCE,
+                        title: content.slice(0, 100),
+                        description: content,
+                        location: locationMatch ? {
+                            file: locationMatch[1],
+                            line_start: parseInt(locationMatch[2]),
+                        } : undefined,
+                    });
+                }
+            }
+        }
+        // Parse ## Risk Assessment
+        const riskMatch = markdown.match(/## Risk Assessment\n([\s\S]*?)(?=##|$)/);
+        if (riskMatch) {
+            const riskContent = riskMatch[1].trim();
+            const levelMatch = riskContent.match(/\b(critical|high|medium|low|minimal)\b/i);
+            if (levelMatch) {
+                output.risk_assessment.overall_level = levelMatch[1].toLowerCase();
+                output.risk_assessment.score = {
+                    critical: 90, high: 70, medium: 50, low: 30, minimal: 10
+                }[output.risk_assessment.overall_level];
+            }
+            output.risk_assessment.summary = riskContent.slice(0, 300);
+        }
+        return output;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/tools/consult.d.ts

@@ -0,0 +1,104 @@
+/**
+ * MCP Tool — multi_consult
+ *
+ * Asks Codex, Gemini, and Claude (Opus) the same question in parallel.
+ * Returns each model's structured 5-section response to CC for synthesis.
+ */
+import { z } from 'zod';
+/**
+ * Returns the directory's *canonical* absolute path if it's safe to use as a
+ * workingDir, or null if it resolves to a sensitive system location. We deny
+ * roots like `/`, `/etc`, `~`, `~/.ssh`, etc. — paths *inside* a project root
+ * are fine. The check resolves symlinks via realpath so a symlinked alias of
+ * a sensitive directory is also caught.
+ */
+export declare function checkSensitiveWorkingDir(input: string): {
+    ok: true;
+    resolved: string;
+} | {
+    ok: false;
+    reason: string;
+};
+export interface SectionValidation {
+    missing: string[];
+}
+/**
+ * Lightweight check for the 5 expected `## …` headers in a model's consult
+ * response. Behaviors:
+ * - Strips fenced code blocks first so a quoted format-example skeleton
+ *   doesn't falsely satisfy the check.
+ * - Requires the section name as a word boundary at the start of an H2 line,
+ *   but tolerates trailing decoration (colon, em-dash continuation, etc.).
+ * - Case-sensitive on the section name. Bare bold (`**Recommendation**`),
+ *   wrong level (`### Recommendation`), and ALL-CAPS variants all count as
+ *   missing — that's the signal we want CC to see when models drift.
+ */
+export declare function validateConsultSections(output: string): SectionValidation;
+export declare const ConsultInputSchema: z.ZodObject<{
+    workingDir: z.ZodString;
+    question: z.ZodString;
+    relevantFiles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    customPrompt: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+    reasoningEffort: z.ZodOptional<z.ZodEnum<["high", "xhigh"]>>;
+    serviceTier: z.ZodOptional<z.ZodEnum<["default", "fast", "flex"]>>;
+}, "strip", z.ZodTypeAny, {
+    workingDir: string;
+    question: string;
+    reasoningEffort?: "high" | "xhigh" | undefined;
+    serviceTier?: "default" | "fast" | "flex" | undefined;
+    relevantFiles?: string[] | undefined;
+    customPrompt?: string | undefined;
+}, {
+    workingDir: string;
+    question: string;
+    reasoningEffort?: "high" | "xhigh" | undefined;
+    serviceTier?: "default" | "fast" | "flex" | undefined;
+    relevantFiles?: string[] | undefined;
+    customPrompt?: string | undefined;
+}>;
+export type ConsultInput = z.infer<typeof ConsultInputSchema>;
+export declare function handleMultiConsult(input: ConsultInput): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+export declare const MULTI_CONSULT_TOOL_DEFINITION: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            workingDir: {
+                type: string;
+                description: string;
+            };
+            question: {
+                type: string;
+                description: string;
+            };
+            relevantFiles: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            customPrompt: {
+                type: string;
+                description: string;
+            };
+            reasoningEffort: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            serviceTier: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};