Implementation Guide: Conduct full due diligence review of a document package and produce a risk report

az login
az group create --name rg-legal-dd-agent --location eastus
az network vnet create --resource-group rg-legal-dd-agent --name vnet-dd-agent --address-prefix 10.0.0.0/16 --subnet-name subnet-ai --subnet-prefix 10.0.1.0/24
az cognitiveservices account create --name oai-legal-dd --resource-group rg-legal-dd-agent --kind OpenAI --sku S0 --location eastus --custom-domain oai-legal-dd
az cognitiveservices account deployment create --name oai-legal-dd --resource-group rg-legal-dd-agent --deployment-name gpt-5.4-dd --model-name gpt-5.4 --model-version 2024-08-06 --model-format OpenAI --sku-capacity 80 --sku-name Standard
az cognitiveservices account deployment create --name oai-legal-dd --resource-group rg-legal-dd-agent --deployment-name text-embedding-3-large --model-name text-embedding-3-large --model-version 1 --model-format OpenAI --sku-capacity 120 --sku-name Standard
az cognitiveservices account keys list --name oai-legal-dd --resource-group rg-legal-dd-agent

az cognitiveservices account create --name doc-intel-legal-dd --resource-group rg-legal-dd-agent --kind FormRecognizer --sku S0 --location eastus
az cognitiveservices account keys list --name doc-intel-legal-dd --resource-group rg-legal-dd-agent

az keyvault create --name kv-legal-dd --resource-group rg-legal-dd-agent --location eastus --enable-rbac-authorization true
az keyvault secret set --vault-name kv-legal-dd --name AzureOpenAIKey --value <YOUR-OPENAI-KEY>
az keyvault secret set --vault-name kv-legal-dd --name DocIntelKey --value <YOUR-DOC-INTEL-KEY>
az keyvault secret set --vault-name kv-legal-dd --name PineconeApiKey --value <YOUR-PINECONE-KEY>
az keyvault secret set --vault-name kv-legal-dd --name iManageClientSecret --value <YOUR-IMANAGE-SECRET>
az webapp identity assign --resource-group rg-legal-dd-agent --name app-dd-agent
az keyvault set-policy --name kv-legal-dd --object-id <MANAGED-IDENTITY-OID> --secret-permissions get list

pip install pinecone-client
python3 -c "
import pinecone
from pinecone import Pinecone, ServerlessSpec

pc = Pinecone(api_key='YOUR_PINECONE_API_KEY')
pc.create_index(
    name='legal-dd-corpus',
    dimension=3072,
    metric='cosine',
    spec=ServerlessSpec(
        cloud='aws',
        region='us-east-1'
    )
)
print('Index created successfully')
print(pc.describe_index('legal-dd-corpus'))
"

curl -X POST https://cloudimanage.com/auth/oauth2/token \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d 'grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET&scope=imanage.document.read imanage.document.write'

curl -X GET 'https://cloudimanage.com/work/api/v2/customers/YOUR_CUSTOMER_ID/documents?limit=5' \
  -H 'Authorization: Bearer YOUR_ACCESS_TOKEN'

curl -X POST https://app.clio.com/oauth/token \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d 'grant_type=authorization_code&code=AUTH_CODE&redirect_uri=https://dd-reports.firmname.com/clio-callback&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET'

curl -X GET 'https://app.clio.com/api/v4/matters?fields=id,display_number,description,client' \
  -H 'Authorization: Bearer YOUR_ACCESS_TOKEN'

az appservice plan create --name plan-dd-agent --resource-group rg-legal-dd-agent --sku B2 --is-linux
az webapp create --resource-group rg-legal-dd-agent --plan plan-dd-agent --name app-dd-agent --runtime 'PYTHON:3.11'
az webapp config appsettings set --resource-group rg-legal-dd-agent --name app-dd-agent --settings \
  AZURE_OPENAI_ENDPOINT=https://oai-legal-dd.openai.azure.com/ \
  AZURE_OPENAI_DEPLOYMENT=gpt-5.4-dd \
  AZURE_OPENAI_EMBEDDING_DEPLOYMENT=text-embedding-3-large \
  DOC_INTEL_ENDPOINT=https://doc-intel-legal-dd.cognitiveservices.azure.com/ \
  PINECONE_INDEX=legal-dd-corpus \
  PINECONE_ENVIRONMENT=us-east-1 \
  KEY_VAULT_URI=https://kv-legal-dd.vault.azure.net/ \
  CLIO_CLIENT_ID=YOUR_CLIO_CLIENT_ID \
  IMANAGE_CUSTOMER_ID=YOUR_IMANAGE_CUSTOMER_ID \
  FLASK_ENV=production

git clone https://github.com/your-msp/legal-dd-agent.git
cd legal-dd-agent
az webapp deploy --resource-group rg-legal-dd-agent --name app-dd-agent --src-path . --type zip

az webapp config hostname add --resource-group rg-legal-dd-agent --webapp-name app-dd-agent --hostname dd-reports.firmname.com
az webapp config ssl bind --resource-group rg-legal-dd-agent --name app-dd-agent --certificate-thumbprint YOUR_CERT_THUMBPRINT --ssl-type SNI

Connect-MgGraph -Scopes 'User.ReadWrite.All','Organization.Read.All'
$E3Sku = Get-MgSubscribedSku | Where-Object { $_.SkuPartNumber -eq 'SPE_E3' }
$CopilotSku = Get-MgSubscribedSku | Where-Object { $_.SkuPartNumber -eq 'Microsoft_365_Copilot' }
$users = Get-MgUser -Filter "department eq 'Legal'" -All
foreach ($user in $users) {
    Set-MgUserLicense -UserId $user.Id -AddLicenses @(@{SkuId=$E3Sku.SkuId},@{SkuId=$CopilotSku.SkuId}) -RemoveLicenses @()
    Write-Host "Licensed: $($user.DisplayName)"
}

curl -X POST https://dd-reports.firmname.com/api/v1/review \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "matter_id": "TEST-DD-001",
    "clio_matter_id": "12345",
    "imanage_folder_id": "FOLDER_ID",
    "review_type": "full_due_diligence",
    "risk_categories": ["change_of_control", "ip_assignment", "indemnification", "termination", "non_compete", "data_privacy", "governing_law"],
    "report_format": "pdf_and_json",
    "notify_teams_channel": true
  }'

curl https://dd-reports.firmname.com/api/v1/review/TEST-DD-001/status

curl https://dd-reports.firmname.com/api/v1/review/TEST-DD-001/report -o test-dd-report.pdf

# document_ingestion.py
import os
import io
import hashlib
from typing import List, Dict, Any
from azure.identity import DefaultAzureCredential
from azure.keyvault.secrets import SecretClient
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential
from openai import AzureOpenAI
from pinecone import Pinecone
import requests
import tiktoken

# Configuration
KEY_VAULT_URI = os.environ['KEY_VAULT_URI']
credential = DefaultAzureCredential()
kv_client = SecretClient(vault_url=KEY_VAULT_URI, credential=credential)

AZURE_OPENAI_ENDPOINT = os.environ['AZURE_OPENAI_ENDPOINT']
AZURE_OPENAI_KEY = kv_client.get_secret('AzureOpenAIKey').value
DOC_INTEL_ENDPOINT = os.environ['DOC_INTEL_ENDPOINT']
DOC_INTEL_KEY = kv_client.get_secret('DocIntelKey').value
PINECONE_API_KEY = kv_client.get_secret('PineconeApiKey').value
PINECONE_INDEX = os.environ['PINECONE_INDEX']

# Initialize clients
oai_client = AzureOpenAI(
    api_key=AZURE_OPENAI_KEY,
    api_version='2024-06-01',
    azure_endpoint=AZURE_OPENAI_ENDPOINT
)
doc_intel_client = DocumentAnalysisClient(
    endpoint=DOC_INTEL_ENDPOINT,
    credential=AzureKeyCredential(DOC_INTEL_KEY)
)
pc = Pinecone(api_key=PINECONE_API_KEY)
index = pc.Index(PINECONE_INDEX)
encoding = tiktoken.encoding_for_model('gpt-5.4')

def fetch_documents_from_imanage(access_token: str, customer_id: str, folder_id: str) -> List[Dict]:
    """Retrieve all documents from an iManage folder."""
    headers = {'Authorization': f'Bearer {access_token}'}
    url = f'https://cloudimanage.com/work/api/v2/customers/{customer_id}/folders/{folder_id}/documents'
    response = requests.get(url, headers=headers)
    response.raise_for_status()
    documents = response.json()['data']
    result = []
    for doc in documents:
        doc_url = f'https://cloudimanage.com/work/api/v2/customers/{customer_id}/documents/{doc["id"]}/download'
        doc_response = requests.get(doc_url, headers=headers)
        result.append({
            'id': doc['id'],
            'name': doc['name'],
            'extension': doc.get('extension', 'pdf'),
            'content': doc_response.content,
            'metadata': {
                'author': doc.get('author', 'Unknown'),
                'create_date': doc.get('create_date', ''),
                'document_class': doc.get('class', 'General')
            }
        })
    return result

def ocr_document(content: bytes, filename: str) -> str:
    """Extract text from a document using Azure AI Document Intelligence."""
    poller = doc_intel_client.begin_analyze_document(
        'prebuilt-layout',
        document=io.BytesIO(content)
    )
    result = poller.result()
    full_text = ''
    for page in result.pages:
        for line in page.lines:
            full_text += line.content + '\n'
    # Also extract tables
    for table in result.tables:
        full_text += '\n[TABLE]\n'
        for cell in sorted(table.cells, key=lambda c: (c.row_index, c.column_index)):
            full_text += f'Row {cell.row_index}, Col {cell.column_index}: {cell.content}\n'
        full_text += '[/TABLE]\n'
    return full_text

def semantic_chunk(text: str, max_tokens: int = 1500, overlap_tokens: int = 200) -> List[str]:
    """Split text into semantically meaningful chunks with overlap."""
    paragraphs = text.split('\n\n')
    chunks = []
    current_chunk = ''
    current_tokens = 0
    for para in paragraphs:
        para_tokens = len(encoding.encode(para))
        if current_tokens + para_tokens > max_tokens and current_chunk:
            chunks.append(current_chunk.strip())
            # Overlap: keep last portion
            overlap_text = current_chunk.split('\n\n')[-2:] if len(current_chunk.split('\n\n')) > 2 else []
            current_chunk = '\n\n'.join(overlap_text) + '\n\n' + para
            current_tokens = len(encoding.encode(current_chunk))
        else:
            current_chunk += '\n\n' + para
            current_tokens += para_tokens
    if current_chunk.strip():
        chunks.append(current_chunk.strip())
    return chunks

def generate_embeddings(texts: List[str]) -> List[List[float]]:
    """Generate embeddings using text-embedding-3-large."""
    response = oai_client.embeddings.create(
        input=texts,
        model='text-embedding-3-large'
    )
    return [item.embedding for item in response.data]

def ingest_document_package(matter_id: str, imanage_token: str, customer_id: str, folder_id: str) -> Dict[str, Any]:
    """Full ingestion pipeline for a DD document package."""
    documents = fetch_documents_from_imanage(imanage_token, customer_id, folder_id)
    stats = {'total_documents': len(documents), 'total_chunks': 0, 'total_pages_ocr': 0}
    
    for doc in documents:
        # OCR and text extraction
        text = ocr_document(doc['content'], doc['name'])
        stats['total_pages_ocr'] += text.count('\n') // 50  # Rough page estimate
        
        # Chunk the document
        chunks = semantic_chunk(text)
        stats['total_chunks'] += len(chunks)
        
        # Generate embeddings in batches of 20
        for i in range(0, len(chunks), 20):
            batch = chunks[i:i+20]
            embeddings = generate_embeddings(batch)
            
            # Upsert to Pinecone
            vectors = []
            for j, (chunk, embedding) in enumerate(zip(batch, embeddings)):
                chunk_id = hashlib.sha256(f'{doc["id"]}_{i+j}'.encode()).hexdigest()[:32]
                vectors.append({
                    'id': chunk_id,
                    'values': embedding,
                    'metadata': {
                        'matter_id': matter_id,
                        'document_id': doc['id'],
                        'document_name': doc['name'],
                        'chunk_index': i + j,
                        'text': chunk[:8000],  # Pinecone metadata limit
                        'author': doc['metadata']['author'],
                        'create_date': doc['metadata']['create_date'],
                        'document_class': doc['metadata']['document_class']
                    }
                })
            index.upsert(vectors=vectors, namespace=f'matter-{matter_id}')
    
    return stats

# dd_risk_agent.py
import json
import logging
from typing import List, Dict, Any, Optional
from dataclasses import dataclass, field, asdict
from enum import Enum
from openai import AzureOpenAI
from pinecone import Pinecone
import datetime

logger = logging.getLogger(__name__)

class RiskSeverity(str, Enum):
    CRITICAL = 'critical'
    HIGH = 'high'
    MEDIUM = 'medium'
    LOW = 'low'
    INFO = 'informational'

class ReviewStatus(str, Enum):
    PENDING = 'pending'
    IN_PROGRESS = 'in_progress'
    AWAITING_HUMAN_REVIEW = 'awaiting_human_review'
    COMPLETED = 'completed'
    FAILED = 'failed'

@dataclass
class RiskFinding:
    finding_id: str
    category: str
    severity: RiskSeverity
    title: str
    description: str
    affected_documents: List[str]
    relevant_clauses: List[str]
    recommendation: str
    confidence_score: float
    requires_human_review: bool = False
    human_approved: Optional[bool] = None

@dataclass
class DDReviewState:
    matter_id: str
    status: ReviewStatus = ReviewStatus.PENDING
    documents_classified: List[Dict] = field(default_factory=list)
    clause_extractions: List[Dict] = field(default_factory=list)
    cross_doc_findings: List[Dict] = field(default_factory=list)
    risk_findings: List[RiskFinding] = field(default_factory=list)
    human_checkpoints: List[Dict] = field(default_factory=list)
    processing_log: List[str] = field(default_factory=list)

RISK_CATEGORIES = [
    'change_of_control',
    'ip_assignment_and_ownership',
    'indemnification_and_liability',
    'termination_and_expiration',
    'non_compete_and_non_solicit',
    'data_privacy_and_security',
    'governing_law_and_jurisdiction',
    'consent_and_notice_requirements',
    'material_adverse_change',
    'representations_and_warranties',
    'payment_and_financial_terms',
    'insurance_requirements',
    'environmental_compliance',
    'employment_and_labor'
]

SYSTEM_PROMPT = """You are a senior legal due diligence analyst AI agent. Your role is to systematically review documents in a transaction and identify risks, anomalies, missing provisions, and inconsistencies.

You have access to the following tools:
1. classify_document - Classify a document by type and relevance
2. extract_clauses - Extract specific clause types from a document
3. search_related_clauses - Search across all documents for related or contradictory clauses
4. assess_risk - Evaluate a specific finding and assign risk severity
5. request_human_review - Flag a finding for attorney review (use for CRITICAL findings)

IMPORTANT RULES:
- Always cite specific document names and clause text in findings
- Never fabricate clause text - only reference text you have actually retrieved
- Assign confidence scores honestly (0.0-1.0)
- Flag ANY finding rated CRITICAL for human review
- Consider cross-border implications for international transactions
- Check for consistency of defined terms across all documents
- Identify missing standard provisions (e.g., no governing law clause)
- Note any unusual or non-market terms

Risk severity guidelines:
- CRITICAL: Deal-breaker issues requiring immediate attorney attention (e.g., undisclosed litigation, missing IP assignments, change of control triggers that would terminate key contracts)
- HIGH: Significant issues that may affect deal terms or valuation (e.g., broad indemnification obligations, restrictive non-competes, unfavorable termination provisions)
- MEDIUM: Notable issues requiring negotiation or disclosure (e.g., non-standard payment terms, ambiguous definitions, consent requirements for assignment)
- LOW: Minor issues or standard deviations from market norms (e.g., slightly non-standard notice periods, minor formatting inconsistencies)
- INFORMATIONAL: Observations for awareness (e.g., contracts nearing expiration, standard renewal provisions)"""

TOOLS = [
    {
        'type': 'function',
        'function': {
            'name': 'classify_document',
            'description': 'Classify a document by type (contract, corporate filing, financial statement, IP record, etc.) and assess its relevance to the transaction.',
            'parameters': {
                'type': 'object',
                'properties': {
                    'document_name': {'type': 'string'},
                    'document_text_preview': {'type': 'string', 'description': 'First 2000 characters of the document'},
                    'classification': {'type': 'string', 'enum': ['contract', 'amendment', 'corporate_filing', 'financial_statement', 'ip_record', 'real_estate', 'employment_agreement', 'regulatory_filing', 'litigation_record', 'insurance_policy', 'other']},
                    'relevance_score': {'type': 'number', 'minimum': 0, 'maximum': 1},
                    'key_parties': {'type': 'array', 'items': {'type': 'string'}},
                    'effective_date': {'type': 'string'},
                    'expiration_date': {'type': 'string'}
                },
                'required': ['document_name', 'classification', 'relevance_score']
            }
        }
    },
    {
        'type': 'function',
        'function': {
            'name': 'extract_clauses',
            'description': 'Extract specific clause types from a document chunk. Call this for each risk category you need to analyze.',
            'parameters': {
                'type': 'object',
                'properties': {
                    'document_name': {'type': 'string'},
                    'clause_category': {'type': 'string', 'enum': RISK_CATEGORIES},
                    'extracted_text': {'type': 'string', 'description': 'The exact clause text found'},
                    'clause_summary': {'type': 'string'},
                    'is_standard': {'type': 'boolean', 'description': 'Whether this is a market-standard provision'},
                    'notable_deviations': {'type': 'string'}
                },
                'required': ['document_name', 'clause_category', 'extracted_text', 'clause_summary', 'is_standard']
            }
        }
    },
    {
        'type': 'function',
        'function': {
            'name': 'search_related_clauses',
            'description': 'Search the full document corpus for clauses related to a specific topic or that might contradict a given clause.',
            'parameters': {
                'type': 'object',
                'properties': {
                    'query': {'type': 'string', 'description': 'Semantic search query for related clauses'},
                    'category_filter': {'type': 'string'},
                    'top_k': {'type': 'integer', 'default': 10}
                },
                'required': ['query']
            }
        }
    },
    {
        'type': 'function',
        'function': {
            'name': 'assess_risk',
            'description': 'Record a risk finding with severity assessment and recommendation.',
            'parameters': {
                'type': 'object',
                'properties': {
                    'category': {'type': 'string', 'enum': RISK_CATEGORIES},
                    'severity': {'type': 'string', 'enum': ['critical', 'high', 'medium', 'low', 'informational']},
                    'title': {'type': 'string'},
                    'description': {'type': 'string'},
                    'affected_documents': {'type': 'array', 'items': {'type': 'string'}},
                    'relevant_clause_text': {'type': 'array', 'items': {'type': 'string'}},
                    'recommendation': {'type': 'string'},
                    'confidence_score': {'type': 'number', 'minimum': 0, 'maximum': 1}
                },
                'required': ['category', 'severity', 'title', 'description', 'affected_documents', 'recommendation', 'confidence_score']
            }
        }
    },
    {
        'type': 'function',
        'function': {
            'name': 'request_human_review',
            'description': 'Flag a critical finding for mandatory attorney review before including in the final report.',
            'parameters': {
                'type': 'object',
                'properties': {
                    'finding_title': {'type': 'string'},
                    'reason': {'type': 'string'},
                    'urgency': {'type': 'string', 'enum': ['immediate', 'before_report', 'informational']}
                },
                'required': ['finding_title', 'reason', 'urgency']
            }
        }
    }
]

class DDRiskAgent:
    def __init__(self, oai_client: AzureOpenAI, pinecone_index, deployment_name: str = 'gpt-5.4-dd', embedding_deployment: str = 'text-embedding-3-large'):
        self.oai_client = oai_client
        self.index = pinecone_index
        self.deployment = deployment_name
        self.embedding_deployment = embedding_deployment
    
    def _vector_search(self, query: str, matter_id: str, top_k: int = 10, category_filter: str = None) -> List[Dict]:
        """Search the document corpus for relevant chunks."""
        embedding = self.oai_client.embeddings.create(
            input=[query], model=self.embedding_deployment
        ).data[0].embedding
        
        filter_dict = {'matter_id': matter_id}
        if category_filter:
            filter_dict['document_class'] = category_filter
        
        results = self.index.query(
            vector=embedding,
            top_k=top_k,
            include_metadata=True,
            namespace=f'matter-{matter_id}',
            filter=filter_dict
        )
        return [{'score': m.score, 'text': m.metadata.get('text', ''), 'document_name': m.metadata.get('document_name', ''), 'chunk_index': m.metadata.get('chunk_index', 0)} for m in results.matches]
    
    def _execute_tool(self, tool_name: str, arguments: Dict, state: DDReviewState) -> str:
        """Execute a tool call and update state."""
        if tool_name == 'classify_document':
            state.documents_classified.append(arguments)
            return json.dumps({'status': 'classified', 'document': arguments.get('document_name'), 'type': arguments.get('classification')})
        
        elif tool_name == 'extract_clauses':
            state.clause_extractions.append(arguments)
            return json.dumps({'status': 'extracted', 'document': arguments.get('document_name'), 'category': arguments.get('clause_category')})
        
        elif tool_name == 'search_related_clauses':
            results = self._vector_search(
                query=arguments.get('query', ''),
                matter_id=state.matter_id,
                top_k=arguments.get('top_k', 10),
                category_filter=arguments.get('category_filter')
            )
            state.cross_doc_findings.append({'query': arguments.get('query'), 'results_count': len(results)})
            return json.dumps({'results': results})
        
        elif tool_name == 'assess_risk':
            finding = RiskFinding(
                finding_id=f'RF-{len(state.risk_findings)+1:04d}',
                category=arguments.get('category', 'other'),
                severity=RiskSeverity(arguments.get('severity', 'medium')),
                title=arguments.get('title', ''),
                description=arguments.get('description', ''),
                affected_documents=arguments.get('affected_documents', []),
                relevant_clauses=arguments.get('relevant_clause_text', []),
                recommendation=arguments.get('recommendation', ''),
                confidence_score=arguments.get('confidence_score', 0.5),
                requires_human_review=(arguments.get('severity') == 'critical')
            )
            state.risk_findings.append(finding)
            return json.dumps({'status': 'recorded', 'finding_id': finding.finding_id, 'severity': finding.severity.value})
        
        elif tool_name == 'request_human_review':
            checkpoint = {
                'finding_title': arguments.get('finding_title'),
                'reason': arguments.get('reason'),
                'urgency': arguments.get('urgency'),
                'timestamp': datetime.datetime.utcnow().isoformat(),
                'resolved': False
            }
            state.human_checkpoints.append(checkpoint)
            return json.dumps({'status': 'flagged_for_review', 'checkpoint': checkpoint})
        
        return json.dumps({'error': f'Unknown tool: {tool_name}'})
    
    def run_analysis(self, matter_id: str, document_summaries: List[Dict], risk_categories: List[str] = None) -> DDReviewState:
        """Run the full DD analysis agent loop."""
        state = DDReviewState(matter_id=matter_id, status=ReviewStatus.IN_PROGRESS)
        categories = risk_categories or RISK_CATEGORIES
        
        # Build initial context with document summaries
        doc_context = 'DOCUMENTS IN THIS DUE DILIGENCE PACKAGE:\n'
        for doc in document_summaries:
            doc_context += f"- {doc['name']} (first 2000 chars): {doc['preview'][:2000]}\n\n"
        
        user_prompt = f"""Conduct a comprehensive due diligence review of the following document package for matter {matter_id}.

{doc_context}

Analyze these risk categories: {', '.join(categories)}

Procedure:
1. First, classify each document by type and relevance
2. For each relevant document, extract key clauses in each risk category
3. Use search_related_clauses to find cross-document inconsistencies and contradictions
4. Assess each finding with appropriate severity
5. Flag any CRITICAL findings for human review
6. Ensure you check for: missing standard provisions, non-standard terms, cross-document term definition consistency, and assignment/change-of-control implications

Be thorough and systematic. Process every document."""
        
        messages = [
            {'role': 'system', 'content': SYSTEM_PROMPT},
            {'role': 'user', 'content': user_prompt}
        ]
        
        max_iterations = 50  # Safety limit
        iteration = 0
        
        while iteration < max_iterations:
            iteration += 1
            state.processing_log.append(f'Iteration {iteration}')
            
            response = self.oai_client.chat.completions.create(
                model=self.deployment,
                messages=messages,
                tools=TOOLS,
                tool_choice='auto',
                temperature=0.1,
                max_tokens=4096
            )
            
            choice = response.choices[0]
            messages.append(choice.message)
            
            if choice.finish_reason == 'stop':
                state.processing_log.append('Agent completed analysis')
                break
            
            if choice.finish_reason == 'tool_calls':
                for tool_call in choice.message.tool_calls:
                    fn_name = tool_call.function.name
                    fn_args = json.loads(tool_call.function.arguments)
                    state.processing_log.append(f'Tool call: {fn_name}')
                    
                    result = self._execute_tool(fn_name, fn_args, state)
                    messages.append({
                        'role': 'tool',
                        'tool_call_id': tool_call.id,
                        'content': result
                    })
        
        # Determine final status
        if any(cp for cp in state.human_checkpoints if not cp['resolved']):
            state.status = ReviewStatus.AWAITING_HUMAN_REVIEW
        else:
            state.status = ReviewStatus.COMPLETED
        
        return state

# report_generator.py
import json
import datetime
from typing import List, Dict, Any
from dataclasses import asdict
from openai import AzureOpenAI
from reportlab.lib.pagesizes import letter
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
from reportlab.lib.colors import HexColor
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak
from reportlab.lib.units import inch
from io import BytesIO

class DDReportGenerator:
    def __init__(self, oai_client: AzureOpenAI, deployment: str = 'gpt-5.4-dd'):
        self.oai_client = oai_client
        self.deployment = deployment
    
    def _generate_executive_summary(self, state) -> str:
        """Use LLM to generate a natural-language executive summary."""
        findings_summary = json.dumps([{
            'id': f.finding_id, 'severity': f.severity.value,
            'title': f.title, 'category': f.category
        } for f in state.risk_findings], indent=2)
        
        prompt = f"""Based on the following due diligence findings, write a concise executive summary (3-4 paragraphs) suitable for a senior partner reviewing this DD report.

Matter ID: {state.matter_id}
Total documents reviewed: {len(state.documents_classified)}
Total findings: {len(state.risk_findings)}
Critical findings: {sum(1 for f in state.risk_findings if f.severity.value == 'critical')}
High findings: {sum(1 for f in state.risk_findings if f.severity.value == 'high')}

Findings overview:
{findings_summary}

Write in professional legal tone. Highlight deal-breaker issues first. Note areas that require further investigation. Do NOT provide legal advice — present findings for attorney evaluation."""
        
        response = self.oai_client.chat.completions.create(
            model=self.deployment,
            messages=[{'role': 'user', 'content': prompt}],
            temperature=0.3, max_tokens=2000
        )
        return response.choices[0].message.content
    
    def generate_json_report(self, state) -> Dict[str, Any]:
        """Generate structured JSON report."""
        exec_summary = self._generate_executive_summary(state)
        severity_order = {'critical': 0, 'high': 1, 'medium': 2, 'low': 3, 'informational': 4}
        sorted_findings = sorted(state.risk_findings, key=lambda f: severity_order.get(f.severity.value, 5))
        
        report = {
            'report_metadata': {
                'matter_id': state.matter_id,
                'generated_at': datetime.datetime.utcnow().isoformat(),
                'report_version': '1.0',
                'agent_version': 'dd-agent-v1.0',
                'status': state.status.value,
                'disclaimer': 'This report was generated by an AI due diligence agent and must be reviewed by a licensed attorney before reliance. AI-generated findings may contain errors or omissions. This report does not constitute legal advice.'
            },
            'executive_summary': exec_summary,
            'statistics': {
                'total_documents': len(state.documents_classified),
                'total_findings': len(state.risk_findings),
                'by_severity': {
                    'critical': sum(1 for f in state.risk_findings if f.severity.value == 'critical'),
                    'high': sum(1 for f in state.risk_findings if f.severity.value == 'high'),
                    'medium': sum(1 for f in state.risk_findings if f.severity.value == 'medium'),
                    'low': sum(1 for f in state.risk_findings if f.severity.value == 'low'),
                    'informational': sum(1 for f in state.risk_findings if f.severity.value == 'informational')
                },
                'human_review_required': len([cp for cp in state.human_checkpoints if not cp['resolved']])
            },
            'document_inventory': state.documents_classified,
            'findings': [asdict(f) for f in sorted_findings],
            'human_review_checkpoints': state.human_checkpoints,
            'processing_log_summary': {
                'total_iterations': len(state.processing_log),
                'tool_calls': len([l for l in state.processing_log if 'Tool call' in l])
            }
        }
        return report
    
    def generate_pdf_report(self, state, output_path: str = None) -> bytes:
        """Generate formatted PDF report."""
        buffer = BytesIO()
        doc = SimpleDocTemplate(buffer, pagesize=letter, topMargin=0.75*inch, bottomMargin=0.75*inch)
        styles = getSampleStyleSheet()
        
        # Custom styles
        title_style = ParagraphStyle('DDTitle', parent=styles['Title'], fontSize=18, textColor=HexColor('#1a237e'))
        heading_style = ParagraphStyle('DDHeading', parent=styles['Heading2'], textColor=HexColor('#1a237e'), spaceAfter=12)
        severity_colors = {'critical': '#d32f2f', 'high': '#f57c00', 'medium': '#fbc02d', 'low': '#388e3c', 'informational': '#1976d2'}
        
        story = []
        
        # Title page
        story.append(Paragraph('DUE DILIGENCE RISK REPORT', title_style))
        story.append(Spacer(1, 12))
        story.append(Paragraph(f'Matter: {state.matter_id}', styles['Normal']))
        story.append(Paragraph(f'Generated: {datetime.datetime.utcnow().strftime("%B %d, %Y at %H:%M UTC")}', styles['Normal']))
        story.append(Paragraph('CONFIDENTIAL — ATTORNEY WORK PRODUCT', ParagraphStyle('Confidential', parent=styles['Normal'], textColor=HexColor('#d32f2f'), fontSize=12, spaceAfter=24)))
        story.append(Paragraph('DISCLAIMER: This report was generated by an AI system and must be reviewed and validated by a licensed attorney before any reliance. Findings may contain errors or omissions. This does not constitute legal advice.', ParagraphStyle('Disclaimer', parent=styles['Normal'], backColor=HexColor('#fff3e0'), fontSize=9, spaceAfter=24)))
        
        # Executive Summary
        exec_summary = self._generate_executive_summary(state)
        story.append(Paragraph('EXECUTIVE SUMMARY', heading_style))
        for para in exec_summary.split('\n\n'):
            story.append(Paragraph(para, styles['Normal']))
            story.append(Spacer(1, 6))
        
        # Statistics table
        story.append(PageBreak())
        story.append(Paragraph('FINDINGS SUMMARY', heading_style))
        stats_data = [['Severity', 'Count']]
        for sev in ['critical', 'high', 'medium', 'low', 'informational']:
            count = sum(1 for f in state.risk_findings if f.severity.value == sev)
            stats_data.append([sev.upper(), str(count)])
        stats_table = Table(stats_data, colWidths=[3*inch, 2*inch])
        stats_table.setStyle(TableStyle([
            ('BACKGROUND', (0, 0), (-1, 0), HexColor('#1a237e')),
            ('TEXTCOLOR', (0, 0), (-1, 0), HexColor('#ffffff')),
            ('GRID', (0, 0), (-1, -1), 0.5, HexColor('#cccccc')),
            ('FONTSIZE', (0, 0), (-1, -1), 10),
            ('PADDING', (0, 0), (-1, -1), 8)
        ]))
        story.append(stats_table)
        story.append(Spacer(1, 24))
        
        # Detailed findings
        story.append(Paragraph('DETAILED FINDINGS', heading_style))
        severity_order = {'critical': 0, 'high': 1, 'medium': 2, 'low': 3, 'informational': 4}
        for finding in sorted(state.risk_findings, key=lambda f: severity_order.get(f.severity.value, 5)):
            color = severity_colors.get(finding.severity.value, '#000000')
            story.append(Paragraph(f'<font color="{color}"><b>[{finding.severity.value.upper()}]</b></font> {finding.finding_id}: {finding.title}', styles['Heading3']))
            story.append(Paragraph(f'<b>Category:</b> {finding.category.replace("_", " ").title()}', styles['Normal']))
            story.append(Paragraph(f'<b>Description:</b> {finding.description}', styles['Normal']))
            story.append(Paragraph(f'<b>Affected Documents:</b> {", ".join(finding.affected_documents)}', styles['Normal']))
            story.append(Paragraph(f'<b>Recommendation:</b> {finding.recommendation}', styles['Normal']))
            story.append(Paragraph(f'<b>Confidence:</b> {finding.confidence_score:.0%}', styles['Normal']))
            if finding.requires_human_review:
                story.append(Paragraph('<font color="#d32f2f"><b>⚠ REQUIRES ATTORNEY REVIEW BEFORE FINALIZATION</b></font>', styles['Normal']))
            story.append(Spacer(1, 16))
        
        doc.build(story)
        pdf_bytes = buffer.getvalue()
        
        if output_path:
            with open(output_path, 'wb') as f:
                f.write(pdf_bytes)
        
        return pdf_bytes

# review_portal.py
from flask import Flask, request, jsonify, render_template_string
from functools import wraps
import jwt
import datetime
import json
from typing import Dict
import requests

app = Flask(__name__)
app.config['SECRET_KEY'] = 'loaded-from-key-vault-at-startup'

# In-memory store (replace with Azure Cosmos DB or PostgreSQL in production)
review_queue: Dict[str, dict] = {}

REVIEW_PAGE_TEMPLATE = """
<!DOCTYPE html>
<html>
<head><title>DD Review Portal - {{ matter_id }}</title>
<style>
  body { font-family: 'Segoe UI', sans-serif; max-width: 900px; margin: 0 auto; padding: 20px; }
  .finding { border: 1px solid #ddd; border-radius: 8px; padding: 16px; margin: 12px 0; }
  .critical { border-left: 4px solid #d32f2f; }
  .high { border-left: 4px solid #f57c00; }
  .badge { display: inline-block; padding: 2px 8px; border-radius: 4px; color: white; font-size: 12px; }
  .badge-critical { background: #d32f2f; }
  .badge-high { background: #f57c00; }
  .btn { padding: 8px 16px; border: none; border-radius: 4px; cursor: pointer; margin: 4px; }
  .btn-approve { background: #388e3c; color: white; }
  .btn-modify { background: #1976d2; color: white; }
  .btn-reject { background: #d32f2f; color: white; }
  textarea { width: 100%; min-height: 60px; margin: 8px 0; }
  .disclaimer { background: #fff3e0; padding: 12px; border-radius: 4px; margin-bottom: 20px; }
</style></head>
<body>
  <h1>Due Diligence Review Portal</h1>
  <p>Matter: <strong>{{ matter_id }}</strong></p>
  <div class='disclaimer'>Items below have been flagged by the AI agent as requiring attorney review per ABA Model Rule 5.3. Please review each finding, verify accuracy against source documents, and approve, modify, or reject.</div>
  {% for finding in findings %}
  <div class='finding {{ finding.severity }}'>
    <span class='badge badge-{{ finding.severity }}'>{{ finding.severity | upper }}</span>
    <h3>{{ finding.finding_id }}: {{ finding.title }}</h3>
    <p><strong>Category:</strong> {{ finding.category }}</p>
    <p><strong>Description:</strong> {{ finding.description }}</p>
    <p><strong>Affected Documents:</strong> {{ finding.affected_documents | join(', ') }}</p>
    <p><strong>AI Recommendation:</strong> {{ finding.recommendation }}</p>
    <p><strong>AI Confidence:</strong> {{ (finding.confidence_score * 100) | int }}%</p>
    <form method='POST' action='/api/v1/review/{{ matter_id }}/findings/{{ finding.finding_id }}'>
      <textarea name='attorney_notes' placeholder='Attorney notes (required for modifications)'></textarea>
      <select name='modified_severity'>
        <option value=''>Keep current severity</option>
        <option value='critical'>Critical</option>
        <option value='high'>High</option>
        <option value='medium'>Medium</option>
        <option value='low'>Low</option>
        <option value='informational'>Informational</option>
      </select>
      <br>
      <button type='submit' name='action' value='approve' class='btn btn-approve'>✓ Approve Finding</button>
      <button type='submit' name='action' value='modify' class='btn btn-modify'>✎ Modify & Approve</button>
      <button type='submit' name='action' value='reject' class='btn btn-reject'>✗ Reject Finding</button>
    </form>
  </div>
  {% endfor %}
  <form method='POST' action='/api/v1/review/{{ matter_id }}/finalize'>
    <button type='submit' class='btn btn-approve' style='font-size:16px; padding:12px 24px; margin-top:24px;'>Generate Final Report</button>
  </form>
</body></html>
"""

def require_auth(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        token = request.headers.get('Authorization', '').replace('Bearer ', '')
        if not token:
            token = request.cookies.get('auth_token', '')
        try:
            payload = jwt.decode(token, app.config['SECRET_KEY'], algorithms=['HS256'])
            request.user = payload
        except jwt.InvalidTokenError:
            return jsonify({'error': 'Authentication required'}), 401
        return f(*args, **kwargs)
    return decorated

@app.route('/api/v1/review/<matter_id>', methods=['GET'])
@require_auth
def get_review_page(matter_id):
    if matter_id not in review_queue:
        return jsonify({'error': 'Matter not found'}), 404
    state = review_queue[matter_id]
    flagged = [f for f in state['findings'] if f.get('requires_human_review', False) and not f.get('human_approved')]
    return render_template_string(REVIEW_PAGE_TEMPLATE, matter_id=matter_id, findings=flagged)

@app.route('/api/v1/review/<matter_id>/findings/<finding_id>', methods=['POST'])
@require_auth
def review_finding(matter_id, finding_id):
    action = request.form.get('action')
    notes = request.form.get('attorney_notes', '')
    modified_severity = request.form.get('modified_severity', '')
    state = review_queue.get(matter_id)
    if not state:
        return jsonify({'error': 'Matter not found'}), 404
    for finding in state['findings']:
        if finding['finding_id'] == finding_id:
            finding['human_approved'] = (action in ['approve', 'modify'])
            finding['attorney_notes'] = notes
            finding['reviewed_by'] = request.user.get('email', 'unknown')
            finding['reviewed_at'] = datetime.datetime.utcnow().isoformat()
            if action == 'modify' and modified_severity:
                finding['severity'] = modified_severity
            if action == 'reject':
                finding['rejected'] = True
            break
    return jsonify({'status': 'updated', 'finding_id': finding_id, 'action': action})

@app.route('/api/v1/review/<matter_id>/finalize', methods=['POST'])
@require_auth
def finalize_report(matter_id):
    state = review_queue.get(matter_id)
    if not state:
        return jsonify({'error': 'Matter not found'}), 404
    unreviewed = [f for f in state['findings'] if f.get('requires_human_review') and not f.get('human_approved') and not f.get('rejected')]
    if unreviewed:
        return jsonify({'error': f'{len(unreviewed)} findings still require review', 'unreviewed_ids': [f['finding_id'] for f in unreviewed]}), 400
    # Trigger report generation (calls report_generator)
    state['finalized'] = True
    state['finalized_by'] = request.user.get('email')
    state['finalized_at'] = datetime.datetime.utcnow().isoformat()
    return jsonify({'status': 'finalized', 'message': 'Report generation initiated'})

def send_teams_notification(webhook_url: str, matter_id: str, critical_count: int, total_count: int):
    """Send notification to Teams deal room when review is needed."""
    card = {
        '@type': 'MessageCard',
        'themeColor': 'd32f2f' if critical_count > 0 else 'f57c00',
        'summary': f'DD Review Required: {matter_id}',
        'sections': [{
            'activityTitle': f'Due Diligence Review Required: {matter_id}',
            'facts': [
                {'name': 'Total Findings', 'value': str(total_count)},
                {'name': 'Critical (Needs Review)', 'value': str(critical_count)},
                {'name': 'Generated', 'value': datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M UTC')}
            ],
            'markdown': True
        }],
        'potentialAction': [{
            '@type': 'OpenUri',
            'name': 'Open Review Portal',
            'targets': [{'os': 'default', 'uri': f'https://dd-reports.firmname.com/api/v1/review/{matter_id}'}]
        }]
    }
    requests.post(webhook_url, json=card)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080)

# Clio API integration for time entry logging, matter note posting, and DD
# completion sync

# clio_integration.py
import requests
import datetime
from typing import Dict, Optional

class ClioIntegration:
    BASE_URL = 'https://app.clio.com/api/v4'
    
    def __init__(self, access_token: str, refresh_token: str, client_id: str, client_secret: str):
        self.access_token = access_token
        self.refresh_token = refresh_token
        self.client_id = client_id
        self.client_secret = client_secret
    
    def _headers(self) -> Dict:
        return {'Authorization': f'Bearer {self.access_token}', 'Content-Type': 'application/json'}
    
    def _refresh_token_if_needed(self):
        """Refresh OAuth token if expired."""
        response = requests.post(f'{self.BASE_URL}/../oauth/token', data={
            'grant_type': 'refresh_token',
            'refresh_token': self.refresh_token,
            'client_id': self.client_id,
            'client_secret': self.client_secret
        })
        if response.ok:
            data = response.json()
            self.access_token = data['access_token']
            self.refresh_token = data['refresh_token']
    
    def get_matter(self, matter_id: str) -> Dict:
        """Retrieve matter details for agent context."""
        response = requests.get(
            f'{self.BASE_URL}/matters/{matter_id}',
            headers=self._headers(),
            params={'fields': 'id,display_number,description,client,practice_area,status,custom_field_values'}
        )
        response.raise_for_status()
        return response.json()['data']
    
    def log_time_entry(self, matter_id: str, user_id: str, duration_seconds: int, description: str, activity_description_id: Optional[str] = None) -> Dict:
        """Log a time entry for AI-assisted DD work."""
        entry = {
            'data': {
                'date': datetime.date.today().isoformat(),
                'quantity': duration_seconds,
                'quantity_in_hours': round(duration_seconds / 3600, 2),
                'type': 'TimeEntry',
                'note': f'[AI-Assisted] {description}',
                'matter': {'id': int(matter_id)},
                'user': {'id': int(user_id)}
            }
        }
        if activity_description_id:
            entry['data']['activity_description'] = {'id': int(activity_description_id)}
        
        response = requests.post(f'{self.BASE_URL}/activities', headers=self._headers(), json=entry)
        response.raise_for_status()
        return response.json()['data']
    
    def post_matter_note(self, matter_id: str, subject: str, detail: str) -> Dict:
        """Post a note to the matter with DD report summary."""
        note = {
            'data': {
                'subject': subject,
                'detail': detail,
                'type': 'Note',
                'matter': {'id': int(matter_id)},
                'date': datetime.date.today().isoformat()
            }
        }
        response = requests.post(f'{self.BASE_URL}/notes', headers=self._headers(), json=note)
        response.raise_for_status()
        return response.json()['data']
    
    def sync_dd_completion(self, matter_id: str, report_summary: Dict, processing_time_seconds: int, reviewing_attorney_user_id: str):
        """Complete sync: log time, post note, update matter."""
        # Log AI processing time
        self.log_time_entry(
            matter_id=matter_id,
            user_id=reviewing_attorney_user_id,
            duration_seconds=processing_time_seconds,
            description=f'AI due diligence review - {report_summary["statistics"]["total_documents"]} documents analyzed, {report_summary["statistics"]["total_findings"]} findings identified'
        )
        
        # Post summary note
        findings_text = f"""Due Diligence AI Review Completed
        
Documents Reviewed: {report_summary['statistics']['total_documents']}
Total Findings: {report_summary['statistics']['total_findings']}
Critical: {report_summary['statistics']['by_severity']['critical']}
High: {report_summary['statistics']['by_severity']['high']}
Medium: {report_summary['statistics']['by_severity']['medium']}
Low: {report_summary['statistics']['by_severity']['low']}

Executive Summary:
{report_summary['executive_summary'][:2000]}

Full report saved to iManage matter folder."""
        
        self.post_matter_note(
            matter_id=matter_id,
            subject=f'DD Risk Report - {report_summary["statistics"]["total_findings"]} Findings',
            detail=findings_text
        )

# Versioned prompt library for DD agent analysis stages

# prompts/dd_prompts.yaml
# Version: 1.0.0
# Last Updated: 2025-07-30
# Reviewed By: [MSP Legal AI Lead]

prompt_library:
  document_classification:
    version: '1.0'
    system: |
      You are a legal document classifier specializing in M&A due diligence.
      Classify the document into one of these categories:
      - contract: Any binding agreement between parties
      - amendment: Modification to an existing contract
      - corporate_filing: Articles of incorporation, bylaws, board resolutions, annual reports
      - financial_statement: Balance sheets, income statements, audited financials
      - ip_record: Patents, trademarks, copyrights, IP assignments, license agreements
      - real_estate: Leases, deeds, environmental reports
      - employment_agreement: Offer letters, employment contracts, severance agreements
      - regulatory_filing: Government filings, permits, licenses
      - litigation_record: Court filings, settlement agreements, demand letters
      - insurance_policy: Insurance certificates, policy documents
      - other: Documents that don't fit above categories
      
      Also extract: key parties, effective date, expiration date, governing law.
      If you cannot determine a field with confidence, respond with 'UNDETERMINED' rather than guessing.
    temperature: 0.1
    max_tokens: 1000

  clause_extraction:
    version: '1.0'
    system: |
      You are a senior contract analyst extracting specific clause types from legal documents.
      
      CRITICAL RULES:
      1. Only extract text that is ACTUALLY PRESENT in the provided document chunk
      2. Never generate, infer, or fabricate clause text
      3. If a clause type is not present in this chunk, respond with 'NOT FOUND IN THIS SECTION'
      4. Quote the exact language - do not paraphrase
      5. Note any defined terms that are referenced but defined elsewhere
      6. Identify if the clause is mutual or one-sided
      7. Flag any carve-outs or exceptions within the clause
      
      For each extracted clause, assess:
      - Is this market-standard language? (Yes/No/Partially)
      - What specific deviations from market standard exist?
      - Are there any ambiguities in the language?
      - Does this clause reference or depend on other clauses/documents?
    temperature: 0.0
    max_tokens: 2000

  cross_document_analysis:
    version: '1.0'
    system: |
      You are analyzing clauses across multiple documents in a due diligence package to identify:
      1. CONTRADICTIONS: Clauses in different documents that conflict with each other
      2. INCONSISTENCIES: Different defined terms or standards across documents
      3. GAPS: Standard provisions present in some documents but missing from others
      4. DEPENDENCIES: Clauses that reference or are contingent on provisions in other documents
      5. CUMULATIVE RISK: Individual clauses that are acceptable alone but create risk when combined
      
      For each finding, cite the EXACT document names and clause text.
      Rate the significance: Critical / High / Medium / Low / Informational
      Explain the practical business impact of each finding.
    temperature: 0.1
    max_tokens: 3000

  change_of_control_analysis:
    version: '1.0'
    system: |
      You are analyzing change-of-control provisions across all contracts in a due diligence package.
      
      For each contract, determine:
      1. Is there a change-of-control clause? (Quote exact text)
      2. What triggers the clause? (Merger, acquisition, asset sale, board change, >50% ownership change, other)
      3. What are the consequences? (Termination right, consent required, acceleration, price adjustment, other)
      4. Is consent required for assignment? (Quote exact text)
      5. Is there an anti-assignment clause that could prevent the transaction?
      6. Are there any exceptions or carve-outs for affiliated entities?
      7. What is the notice period required?
      8. Would the contemplated transaction trigger this clause?
      
      Assess aggregate risk: How many key contracts would be affected by the transaction?
      Identify any contracts that could be deal-breakers if consent is not obtained.
    temperature: 0.0
    max_tokens: 3000

  ip_ownership_analysis:
    version: '1.0'
    system: |
      You are analyzing intellectual property ownership and assignment provisions.
      
      For each document, determine:
      1. Are there IP assignment clauses? (work-for-hire, assignment of inventions)
      2. Are assignments present-tense ('hereby assigns') or future ('agrees to assign')?
      3. Are there any retained rights or licenses back to the assignor?
      4. Do employment agreements contain invention assignment clauses?
      5. Are there any third-party IP licenses that may not be transferable?
      6. Are open-source software obligations disclosed?
      7. Is there a complete chain of title from creator to current owner?
      8. Are there any IP-related representations and warranties?
      
      Flag any gaps in the IP ownership chain as HIGH or CRITICAL risk.
      Flag any licenses that contain anti-assignment or change-of-control provisions.
    temperature: 0.0
    max_tokens: 3000

  risk_report_executive_summary:
    version: '1.0'
    system: |
      You are drafting the executive summary section of a legal due diligence risk report.
      
      RULES:
      1. Write in professional, objective legal tone
      2. Lead with the most significant findings (Critical and High severity)
      3. Quantify: number of documents reviewed, number of findings by severity
      4. Identify the top 3-5 risks that could affect deal terms or valuation
      5. Note any areas where further investigation is recommended
      6. Do NOT provide legal advice or opinions on whether to proceed
      7. Do NOT use marketing language or superlatives
      8. Include a statement that this is AI-generated and requires attorney review
      9. Keep to 3-4 concise paragraphs
      10. Use specific document references, not vague generalizations
    temperature: 0.3
    max_tokens: 2000