centient 2.20.0

package/dist/tools/consultation/peerReviewContract.js

@@ -0,0 +1,731 @@
+import { extractFullSessionContext, estimateTokens, } from "../../utils/contextBuilder.js";
+export var ReviewContractStatus;
+(function (ReviewContractStatus) {
+    ReviewContractStatus["DRAFT"] = "draft";
+    ReviewContractStatus["NEGOTIATING"] = "negotiating";
+    ReviewContractStatus["APPROVED"] = "approved";
+    ReviewContractStatus["EXECUTING"] = "executing";
+    ReviewContractStatus["VALIDATING"] = "validating";
+    ReviewContractStatus["COMPLETE"] = "complete";
+    ReviewContractStatus["FAILED"] = "failed";
+})(ReviewContractStatus || (ReviewContractStatus = {}));
+export var ReviewVerdict;
+(function (ReviewVerdict) {
+    ReviewVerdict["APPROVED"] = "approved";
+    ReviewVerdict["CONCERNS"] = "concerns";
+    ReviewVerdict["REJECTED"] = "rejected";
+})(ReviewVerdict || (ReviewVerdict = {}));
+export function createReviewContract(sessionId, context, options = {}) {
+    const { focusAreas = [], maxIterations = 3, minConfidence = 0.7, enableSubcontracting = false, } = options;
+    const reviewDimensions = [
+        "Architectural Coherence",
+        "Decision Quality",
+        "Risk Assessment",
+        "Pattern Application",
+        "Constraint Compliance",
+        "Gaps or Omissions",
+    ];
+    const deliverables = [
+        {
+            name: "Overall Assessment",
+            required: true,
+            description: "Clear verdict: Approved, Concerns, or Rejected with reasoning",
+            validationMethod: "structure",
+        },
+        {
+            name: "Architectural Coherence Analysis",
+            required: true,
+            description: "Analysis of how decisions form a coherent whole",
+            validationMethod: "presence",
+        },
+        {
+            name: "Key Strengths",
+            required: true,
+            description: "Bullet points of what was done well",
+            validationMethod: "presence",
+        },
+        {
+            name: "Concerns",
+            required: true,
+            description: "Bullet points of risks or issues identified",
+            validationMethod: "presence",
+        },
+        {
+            name: "Recommendations",
+            required: true,
+            description: "Actionable suggestions for improvement",
+            validationMethod: "presence",
+        },
+        {
+            name: "Confidence Statement",
+            required: true,
+            description: "Confidence level (High/Medium/Low) with reasoning",
+            validationMethod: "structure",
+        },
+    ];
+    if (focusAreas.includes("security")) {
+        deliverables.push({
+            name: "Security Analysis",
+            required: true,
+            description: "Dedicated security review of decisions and patterns",
+            validationMethod: "presence",
+        });
+    }
+    if (focusAreas.includes("performance")) {
+        deliverables.push({
+            name: "Performance Analysis",
+            required: true,
+            description: "Performance implications of architectural decisions",
+            validationMethod: "presence",
+        });
+    }
+    const acceptanceCriteria = [
+        {
+            criterion: "All required deliverables present",
+            validationMethod: "automated",
+            weight: 0.3,
+        },
+        {
+            criterion: "Clear verdict stated (Approved/Concerns/Rejected)",
+            validationMethod: "automated",
+            weight: 0.2,
+        },
+        {
+            criterion: "Each decision addressed or acknowledged",
+            validationMethod: "llm_judge",
+            threshold: 0.8,
+            weight: 0.2,
+        },
+        {
+            criterion: "Recommendations are actionable and specific",
+            validationMethod: "llm_judge",
+            weight: 0.15,
+        },
+        {
+            criterion: "Confidence level justified with reasoning",
+            validationMethod: "automated",
+            weight: 0.15,
+        },
+    ];
+    return {
+        id: `review-${sessionId}-${Date.now()}`,
+        sessionId,
+        version: "1.0.0",
+        status: ReviewContractStatus.DRAFT,
+        createdAt: new Date().toISOString(),
+        scope: {
+            reviewDimensions,
+            focusAreas,
+            excludedTopics: [],
+            contextSize: {
+                decisions: context.decisions.length,
+                patterns: context.patterns.length,
+                hypotheses: context.hypotheses.length,
+                blockers: context.blockers.length,
+                constraints: context.constraints.length,
+                totalItems: context.decisions.length +
+                    context.patterns.length +
+                    context.hypotheses.length +
+                    context.blockers.length +
+                    context.constraints.length,
+            },
+        },
+        deliverables,
+        acceptanceCriteria,
+        constraints: {
+            maxIterations,
+            minConfidence,
+            maxTokenBudget: 8000,
+            timeoutMs: 120000,
+            requiredVerdict: true,
+        },
+        negotiationAllowed: true,
+        subcontractingAllowed: enableSubcontracting,
+        auditLog: [
+            {
+                timestamp: new Date().toISOString(),
+                event: "contract_created",
+                details: { sessionId, focusAreas },
+            },
+        ],
+    };
+}
+export function analyzeContractFeasibility(contract, context) {
+    const issues = [];
+    const clarificationsNeeded = [];
+    if (contract.scope.contextSize.totalItems === 0) {
+        issues.push({
+            type: "missing_context",
+            field: "scope.contextSize",
+            description: "Session has no decisions, patterns, or hypotheses to review",
+            suggestion: "Ensure session has recorded decisions before requesting review",
+            blocking: true,
+        });
+    }
+    const decisionsWithoutRationale = context.decisions.filter((d) => !d.content.toLowerCase().includes("because") &&
+        !d.content.toLowerCase().includes("rationale") &&
+        !d.content.toLowerCase().includes("reason"));
+    if (decisionsWithoutRationale.length > context.decisions.length * 0.5) {
+        issues.push({
+            type: "missing_context",
+            field: "decisions",
+            description: `${decisionsWithoutRationale.length}/${context.decisions.length} decisions lack explicit rationale`,
+            suggestion: "Consider adding rationale to key decisions for more meaningful review",
+            blocking: false,
+        });
+        clarificationsNeeded.push("Should the review infer rationale from context, or flag missing rationale as a concern?");
+    }
+    if (contract.scope.contextSize.totalItems > 30) {
+        issues.push({
+            type: "scope_too_broad",
+            field: "scope",
+            description: `Large session (${contract.scope.contextSize.totalItems} items) may result in shallow review`,
+            suggestion: "Consider focusing on critical decisions only, or enable subcontracting",
+            blocking: false,
+        });
+    }
+    for (const focus of contract.scope.focusAreas) {
+        const hasMatchingContent = context.decisions.some((d) => d.content.toLowerCase().includes(focus.toLowerCase()));
+        if (!hasMatchingContent) {
+            issues.push({
+                type: "ambiguity",
+                field: `focusAreas.${focus}`,
+                description: `Focus area "${focus}" has no matching decisions`,
+                suggestion: `Remove focus area or clarify what aspects of "${focus}" should be evaluated`,
+                blocking: false,
+            });
+        }
+    }
+    const estimatedTokens = Math.ceil(contract.scope.contextSize.totalItems * 150);
+    const estimatedIterations = contract.scope.contextSize.totalItems > 15 ? 2 : 1;
+    const blockingIssues = issues.filter((i) => i.blocking);
+    return {
+        feasible: blockingIssues.length === 0,
+        issues,
+        clarificationsNeeded,
+        estimatedEffort: {
+            tokens: estimatedTokens,
+            iterations: estimatedIterations,
+        },
+    };
+}
+export function validateReviewResponse(contract, response, iteration) {
+    const deliverableResults = [];
+    const criteriaResults = [];
+    const responseLower = response.toLowerCase();
+    for (const deliverable of contract.deliverables) {
+        let present = false;
+        let quality = 0;
+        let evidence = "";
+        switch (deliverable.name) {
+            case "Overall Assessment":
+                present =
+                    /overall assessment/i.test(response) ||
+                        /\*\*\[?(approved|concerns|rejected)\]?\.?\*\*/i.test(response) ||
+                        /\[(approved|concerns|rejected)\]/i.test(response);
+                quality = present ? 1.0 : 0;
+                evidence = present
+                    ? "Overall assessment section found"
+                    : "No overall assessment section";
+                break;
+            case "Architectural Coherence Analysis":
+                present =
+                    /architectural coherence/i.test(response) ||
+                        /coherence/i.test(response) ||
+                        /coherent/i.test(response) ||
+                        /decisions.*together/i.test(response) ||
+                        /work.*together/i.test(response);
+                quality = present ? 0.8 : 0;
+                evidence = present
+                    ? "Coherence analysis present"
+                    : "Missing coherence analysis";
+                break;
+            case "Key Strengths":
+                present = /strengths/i.test(response) || /done well/i.test(response);
+                const strengthBullets = (response.match(/^[-*]\s+.+$/gm) || []).length;
+                quality = present ? Math.min(strengthBullets / 3, 1.0) : 0;
+                evidence = present
+                    ? `${strengthBullets} strength items found`
+                    : "No strengths section";
+                break;
+            case "Concerns":
+                present =
+                    /concerns/i.test(response) ||
+                        /risks/i.test(response) ||
+                        /issues/i.test(response);
+                quality = present ? 0.8 : 0;
+                evidence = present
+                    ? "Concerns section present"
+                    : "Missing concerns section";
+                break;
+            case "Recommendations":
+                present =
+                    /recommendations/i.test(response) || /suggestions/i.test(response);
+                quality = present ? 0.8 : 0;
+                evidence = present
+                    ? "Recommendations present"
+                    : "Missing recommendations";
+                break;
+            case "Confidence Statement":
+                present =
+                    /confidence/i.test(response) && /(high|medium|low)/i.test(response);
+                quality = present ? 1.0 : 0;
+                evidence = present
+                    ? "Confidence level stated"
+                    : "Missing confidence level";
+                break;
+            case "Security Analysis":
+                present = /security/i.test(response);
+                quality = present ? 0.8 : 0;
+                evidence = present
+                    ? "Security analysis present"
+                    : "Missing security analysis";
+                break;
+            case "Performance Analysis":
+                present = /performance/i.test(response);
+                quality = present ? 0.8 : 0;
+                evidence = present
+                    ? "Performance analysis present"
+                    : "Missing performance analysis";
+                break;
+            default:
+                present = responseLower.includes(deliverable.name.toLowerCase());
+                quality = present ? 0.5 : 0;
+                evidence = present ? "Section found" : "Section missing";
+        }
+        deliverableResults.push({
+            deliverable: deliverable.name,
+            present,
+            quality,
+            evidence,
+        });
+    }
+    for (const criterion of contract.acceptanceCriteria) {
+        let passed = false;
+        let score = 0;
+        switch (criterion.criterion) {
+            case "All required deliverables present":
+                const requiredMet = deliverableResults.filter((d, i) => contract.deliverables[i]?.required && d.present).length;
+                const requiredTotal = contract.deliverables.filter((d) => d.required).length;
+                passed = requiredMet === requiredTotal;
+                score = requiredTotal > 0 ? requiredMet / requiredTotal : 1;
+                break;
+            case "Clear verdict stated (Approved/Concerns/Rejected)":
+                passed =
+                    /\*\*\[?(approved|concerns|rejected)\]?\.?\*\*/i.test(response) ||
+                        /\[(approved|concerns|rejected)\]/i.test(response) ||
+                        /^#+.*assessment[\s\S]{0,50}(approved|concerns|rejected)/im.test(response);
+                score = passed ? 1.0 : 0;
+                break;
+            case "Confidence level justified with reasoning":
+                const hasConfidence = /confidence.*:?\s*(high|medium|low)/i.test(response);
+                const hasReasoning = /confidence.{0,50}(because|due to|given|since)/i.test(response);
+                passed = hasConfidence && hasReasoning;
+                score = hasConfidence ? (hasReasoning ? 1.0 : 0.5) : 0;
+                break;
+            default:
+                passed = true;
+                score = 0.7;
+        }
+        criteriaResults.push({
+            criterion: criterion.criterion,
+            passed,
+            score,
+            evidence: passed ? "Criterion met" : "Criterion not met",
+        });
+    }
+    const allDeliverablesMet = deliverableResults
+        .filter((_, i) => contract.deliverables[i]?.required)
+        .every((d) => d.present);
+    const allCriteriaPassed = criteriaResults.every((c) => c.passed);
+    const overallScore = criteriaResults.reduce((sum, c, i) => sum + c.score * (contract.acceptanceCriteria[i]?.weight ?? 0), 0);
+    let verdict = null;
+    const verdictPatterns = {
+        approved: /(\*\*\[?approved\]?\.?\*\*|\[approved\]|^#+.*assessment[\s\S]{0,50}approved)/im,
+        concerns: /(\*\*\[?concerns\]?\.?\*\*|\[concerns\]|^#+.*assessment[\s\S]{0,50}concerns)/im,
+        rejected: /(\*\*\[?rejected\]?\.?\*\*|\[rejected\]|^#+.*assessment[\s\S]{0,50}rejected)/im,
+    };
+    if (verdictPatterns.approved.test(response)) {
+        verdict = ReviewVerdict.APPROVED;
+    }
+    else if (verdictPatterns.concerns.test(response)) {
+        verdict = ReviewVerdict.CONCERNS;
+    }
+    else if (verdictPatterns.rejected.test(response)) {
+        verdict = ReviewVerdict.REJECTED;
+    }
+    let confidence = 0.5;
+    if (/high/i.test(response) && /confidence/i.test(response)) {
+        confidence = 0.9;
+    }
+    else if (/medium/i.test(response) && /confidence/i.test(response)) {
+        confidence = 0.7;
+    }
+    else if (/low/i.test(response) && /confidence/i.test(response)) {
+        confidence = 0.4;
+    }
+    const requiresIteration = !allDeliverablesMet ||
+        overallScore < contract.constraints.minConfidence ||
+        (contract.constraints.requiredVerdict && !verdict);
+    let iterationFeedback;
+    if (requiresIteration && iteration < contract.constraints.maxIterations) {
+        const missing = deliverableResults
+            .filter((d, i) => contract.deliverables[i]?.required && !d.present)
+            .map((d) => d.deliverable);
+        if (missing.length > 0) {
+            iterationFeedback = `Missing required sections: ${missing.join(", ")}. Please provide these in your response.`;
+        }
+        else if (!verdict) {
+            iterationFeedback =
+                "Please provide a clear verdict: **[Approved]**, **[Concerns]**, or **[Rejected]** at the start of your Overall Assessment.";
+        }
+        else {
+            iterationFeedback = `Review quality score (${(overallScore * 100).toFixed(0)}%) below threshold (${contract.constraints.minConfidence * 100}%). Please provide more detailed analysis.`;
+        }
+    }
+    return {
+        deliverableResults,
+        criteriaResults,
+        allDeliverablesMet,
+        allCriteriaPassed,
+        overallScore,
+        verdict,
+        confidence,
+        iteration,
+        requiresIteration,
+        iterationFeedback,
+    };
+}
+export function decomposeToSubcontracts(contract, context) {
+    if (!contract.subcontractingAllowed) {
+        return [];
+    }
+    const subcontracts = [];
+    const parentId = contract.id;
+    const hasSecurityContent = context.decisions.some((d) => d.content.toLowerCase().includes("auth") ||
+        d.content.toLowerCase().includes("security") ||
+        d.content.toLowerCase().includes("permission") ||
+        d.content.toLowerCase().includes("encryption"));
+    if (hasSecurityContent || contract.scope.focusAreas.includes("security")) {
+        subcontracts.push({
+            id: `${parentId}-security`,
+            parentContractId: parentId,
+            specialization: "security",
+            focusAreas: [
+                "authentication",
+                "authorization",
+                "data protection",
+                "input validation",
+            ],
+            deliverables: [
+                {
+                    name: "Security Findings",
+                    required: true,
+                    description: "Security vulnerabilities or concerns identified",
+                    validationMethod: "presence",
+                },
+                {
+                    name: "Security Recommendations",
+                    required: true,
+                    description: "Specific security improvements",
+                    validationMethod: "presence",
+                },
+            ],
+            assignedModel: "o3",
+            status: ReviewContractStatus.DRAFT,
+        });
+    }
+    if (contract.scope.contextSize.totalItems > 10) {
+        subcontracts.push({
+            id: `${parentId}-architecture`,
+            parentContractId: parentId,
+            specialization: "architecture",
+            focusAreas: ["modularity", "scalability", "maintainability", "patterns"],
+            deliverables: [
+                {
+                    name: "Architectural Assessment",
+                    required: true,
+                    description: "Evaluation of architectural decisions",
+                    validationMethod: "presence",
+                },
+                {
+                    name: "Pattern Alignment",
+                    required: true,
+                    description: "Assessment of pattern usage",
+                    validationMethod: "presence",
+                },
+            ],
+            assignedModel: "gemini-3-pro-preview",
+            status: ReviewContractStatus.DRAFT,
+        });
+    }
+    subcontracts.push({
+        id: `${parentId}-completeness`,
+        parentContractId: parentId,
+        specialization: "completeness",
+        focusAreas: ["gaps", "edge cases", "error handling", "testing"],
+        deliverables: [
+            {
+                name: "Gap Analysis",
+                required: true,
+                description: "Identification of missing considerations",
+                validationMethod: "presence",
+            },
+            {
+                name: "Edge Cases",
+                required: false,
+                description: "Unaddressed edge cases",
+                validationMethod: "presence",
+            },
+        ],
+        assignedModel: "gpt-5.2",
+        status: ReviewContractStatus.DRAFT,
+    });
+    return subcontracts;
+}
+export function aggregateSubcontractResults(subcontracts) {
+    const aggregatedFindings = [];
+    const aggregatedConcerns = [];
+    const aggregatedRecommendations = [];
+    let totalConfidence = 0;
+    let completedCount = 0;
+    for (const sc of subcontracts) {
+        if (sc.result) {
+            aggregatedFindings.push(...sc.result.findings.map((f) => `[${sc.specialization}] ${f}`));
+            aggregatedConcerns.push(...sc.result.concerns.map((c) => `[${sc.specialization}] ${c}`));
+            aggregatedRecommendations.push(...sc.result.recommendations.map((r) => `[${sc.specialization}] ${r}`));
+            totalConfidence += sc.result.confidence;
+            completedCount++;
+        }
+    }
+    return {
+        aggregatedFindings,
+        aggregatedConcerns,
+        aggregatedRecommendations,
+        overallConfidence: completedCount > 0 ? totalConfidence / completedCount : 0,
+    };
+}
+export function buildContractAwarePrompt(contract, context, iteration = 1, previousValidation) {
+    const sections = [];
+    sections.push("# Peer Review Contract\n");
+    sections.push(`**Contract ID:** ${contract.id}`);
+    sections.push(`**Session:** ${contract.sessionId}`);
+    sections.push(`**Iteration:** ${iteration}/${contract.constraints.maxIterations}`);
+    sections.push("");
+    sections.push("## Contract Terms\n");
+    sections.push("You are bound by this review contract. Your response MUST include:\n");
+    for (const deliverable of contract.deliverables) {
+        const marker = deliverable.required ? "**[REQUIRED]**" : "[optional]";
+        sections.push(`- ${marker} **${deliverable.name}**: ${deliverable.description}`);
+    }
+    sections.push("");
+    sections.push("## Acceptance Criteria\n");
+    sections.push("Your review will be validated against:\n");
+    for (const criterion of contract.acceptanceCriteria) {
+        sections.push(`- ${criterion.criterion}`);
+    }
+    sections.push("");
+    if (previousValidation && previousValidation.iterationFeedback) {
+        sections.push("## ⚠️ Iteration Feedback\n");
+        sections.push(`**Previous review did not meet contract requirements.**\n`);
+        sections.push(previousValidation.iterationFeedback);
+        sections.push("");
+        const missingDeliverables = previousValidation.deliverableResults.filter((d, i) => contract.deliverables[i]?.required && !d.present);
+        if (missingDeliverables.length > 0) {
+            sections.push("**Missing deliverables:**");
+            for (const d of missingDeliverables) {
+                sections.push(`- ❌ ${d.deliverable}: ${d.evidence}`);
+            }
+            sections.push("");
+        }
+    }
+    sections.push("---\n");
+    sections.push("## Session Context for Review\n");
+    if (context.decisions.length > 0) {
+        sections.push("### Key Decisions Made\n");
+        context.decisions.forEach((d, i) => {
+            sections.push(`**Decision ${i + 1}:** ${d.content}`);
+            sections.push(`- *Timestamp:* ${d.timestamp}`);
+            sections.push("");
+        });
+    }
+    if (context.patterns.length > 0) {
+        sections.push("### Patterns Applied\n");
+        context.patterns.forEach((p, i) => {
+            sections.push(`${i + 1}. ${p.content}`);
+        });
+        sections.push("");
+    }
+    if (context.hypotheses.length > 0) {
+        sections.push("### Working Hypotheses\n");
+        context.hypotheses.forEach((h, i) => {
+            sections.push(`${i + 1}. ${h.content}`);
+        });
+        sections.push("");
+    }
+    if (context.blockers.length > 0) {
+        sections.push("### Open Blockers\n");
+        context.blockers.forEach((b, i) => {
+            sections.push(`${i + 1}. ${b.content}`);
+        });
+        sections.push("");
+    }
+    if (context.constraints.length > 0) {
+        sections.push("### Active Constraints\n");
+        context.constraints.forEach((c, i) => {
+            sections.push(`${i + 1}. ${c.content} (scope: ${c.scope})`);
+        });
+        sections.push("");
+    }
+    if (contract.scope.focusAreas.length > 0) {
+        sections.push("### Focus Areas\n");
+        sections.push("Pay particular attention to:\n");
+        contract.scope.focusAreas.forEach((area) => {
+            sections.push(`- **${area}**`);
+        });
+        sections.push("");
+    }
+    sections.push("---\n");
+    sections.push("## Required Response Format\n");
+    sections.push("Structure your response EXACTLY as follows:\n");
+    sections.push("```");
+    sections.push("### Overall Assessment");
+    sections.push("**[Approved/Concerns/Rejected].** [Your verdict and reasoning]");
+    sections.push("");
+    sections.push("### Architectural Coherence");
+    sections.push("[Your analysis of how decisions work together]");
+    sections.push("");
+    sections.push("### Key Strengths");
+    sections.push("- [Bullet point 1]");
+    sections.push("- [Bullet point 2]");
+    sections.push("");
+    sections.push("### Concerns");
+    sections.push("- [Bullet point 1]");
+    sections.push("- [Bullet point 2]");
+    sections.push("");
+    sections.push("### Recommendations");
+    sections.push("- [Actionable suggestion 1]");
+    sections.push("- [Actionable suggestion 2]");
+    sections.push("");
+    sections.push("### Confidence");
+    sections.push("[High/Medium/Low] - [Your reasoning for this confidence level]");
+    sections.push("```");
+    return sections.join("\n");
+}
+export const peerReviewContractTool = {
+    name: "peer_review_contract",
+    description: `Create a formal review contract using the Contractor Model pattern.
+
+Transforms peer review into an accountable, verifiable process with:
+- **Formalized Contract**: Explicit deliverables and acceptance criteria
+- **Negotiation Phase**: Identify feasibility issues before execution
+- **Quality Validation**: Self-validate until criteria met
+- **Subcontracting**: Optional specialist reviews for complex sessions
+
+Use this for high-stakes sessions where review quality matters.
+
+Workflow:
+1. peer_review_contract() → contract + negotiation analysis
+2. If feasible: consult_llm with contract-aware prompt
+3. validate_review_response() → check against acceptance criteria
+4. If validation fails: iterate with feedback
+5. capture_consultation_response() → persist validated finding`,
+    inputSchema: {
+        type: "object",
+        properties: {
+            focusAreas: {
+                type: "array",
+                items: { type: "string" },
+                description: 'Focus areas for review (e.g., ["security", "performance"])',
+            },
+            maxIterations: {
+                type: "number",
+                default: 3,
+                description: "Maximum validation iterations (default: 3)",
+            },
+            minConfidence: {
+                type: "number",
+                default: 0.7,
+                description: "Minimum confidence threshold 0-1 (default: 0.7)",
+            },
+            enableSubcontracting: {
+                type: "boolean",
+                default: false,
+                description: "Enable specialist subcontracts for complex sessions",
+            },
+            projectName: {
+                type: "string",
+                description: "Project name for Memory Bank persistence",
+            },
+        },
+        required: [],
+    },
+};
+export async function peerReviewContractHandler(args) {
+    const startTime = Date.now();
+    try {
+        const input = args;
+        const context = await extractFullSessionContext();
+        const contract = createReviewContract(context.sessionId, context, {
+            focusAreas: input.focusAreas,
+            maxIterations: input.maxIterations,
+            minConfidence: input.minConfidence,
+            enableSubcontracting: input.enableSubcontracting,
+        });
+        const negotiation = analyzeContractFeasibility(contract, context);
+        contract.status = negotiation.feasible
+            ? ReviewContractStatus.APPROVED
+            : ReviewContractStatus.NEGOTIATING;
+        contract.auditLog.push({
+            timestamp: new Date().toISOString(),
+            event: "negotiation_complete",
+            details: {
+                feasible: negotiation.feasible,
+                issueCount: negotiation.issues.length,
+            },
+        });
+        const prompt = buildContractAwarePrompt(contract, context);
+        const subcontracts = decomposeToSubcontracts(contract, context);
+        const duration = Date.now() - startTime;
+        const estimatedTokens = estimateTokens(prompt);
+        const result = {
+            success: true,
+            contract,
+            negotiation,
+            prompt,
+            subcontracts: subcontracts.length > 0 ? subcontracts : undefined,
+            consultLlmCall: {
+                prompt,
+                model: "o3",
+                description: `Contract review: ${contract.id}`,
+            },
+            validation: {
+                tool: "validate_review_response",
+                description: "Call after receiving LLM response to validate against contract",
+            },
+            metadata: {
+                estimatedTokens,
+                duration,
+                contractId: contract.id,
+            },
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: false,
+                        error: { code: "CONTRACT_ERROR", message: errorMessage },
+                    }),
+                },
+            ],
+        };
+    }
+}
+//# sourceMappingURL=peerReviewContract.js.map