{
  name: 'legal/clause-extract',
  description: 'Extract and classify clauses from legal documents',
  inputSchema: {
    type: 'object',
    properties: {
      document: { type: 'string', description: 'Contract text or file path' },
      clauseTypes: {
        type: 'array',
        items: {
          type: 'string',
          enum: [
            'indemnification', 'limitation_of_liability', 'termination',
            'confidentiality', 'ip_assignment', 'governing_law', 'arbitration',
            'force_majeure', 'warranty', 'payment_terms', 'non_compete'
          ]
        }
      },
      jurisdiction: { type: 'string', default: 'US' },
      includePositions: { type: 'boolean', default: true }
    },
    required: ['document']
  }
}

{
  name: 'legal/risk-assess',
  description: 'Assess contractual risks with severity scoring',
  inputSchema: {
    type: 'object',
    properties: {
      document: { type: 'string' },
      partyRole: { type: 'string', enum: ['buyer', 'seller', 'licensor', 'licensee', 'employer', 'employee'] },
      riskCategories: {
        type: 'array',
        items: { type: 'string', enum: ['financial', 'operational', 'legal', 'reputational', 'compliance'] }
      },
      industryContext: { type: 'string' },
      threshold: { type: 'string', enum: ['low', 'medium', 'high', 'critical'] }
    },
    required: ['document', 'partyRole']
  }
}

{
  name: 'legal/contract-compare',
  description: 'Compare two contracts with detailed diff and semantic alignment',
  inputSchema: {
    type: 'object',
    properties: {
      baseDocument: { type: 'string', description: 'Reference contract' },
      compareDocument: { type: 'string', description: 'Contract to compare' },
      comparisonMode: {
        type: 'string',
        enum: ['structural', 'semantic', 'full'],
        default: 'full'
      },
      highlightChanges: { type: 'boolean', default: true },
      generateRedline: { type: 'boolean', default: false }
    },
    required: ['baseDocument', 'compareDocument']
  }
}

{
  name: 'legal/obligation-track',
  description: 'Extract obligations, deadlines, and dependencies using DAG analysis',
  inputSchema: {
    type: 'object',
    properties: {
      document: { type: 'string' },
      party: { type: 'string', description: 'Party name to filter obligations' },
      timeframe: { type: 'string', description: 'ISO duration or date range' },
      obligationTypes: {
        type: 'array',
        items: { type: 'string', enum: ['payment', 'delivery', 'notification', 'approval', 'compliance'] }
      },
      includeDependencies: { type: 'boolean', default: true }
    },
    required: ['document']
  }
}

{
  name: 'legal/playbook-match',
  description: 'Compare contract clauses against negotiation playbook',
  inputSchema: {
    type: 'object',
    properties: {
      document: { type: 'string' },
      playbook: { type: 'string', description: 'Playbook identifier or custom JSON' },
      strictness: { type: 'string', enum: ['strict', 'moderate', 'flexible'] },
      suggestAlternatives: { type: 'boolean', default: true },
      prioritizeClauses: { type: 'array', items: { type: 'string' } }
    },
    required: ['document', 'playbook']
  }
}

+------------------+     +----------------------+     +------------------+
|  Document Input  |---->|   Legal Plugin       |---->|  Clause Index    |
|  (PDF/DOCX/TXT)  |     |  (Privacy-First)     |     | (HNSW + Hyper)   |
+------------------+     +----------------------+     +------------------+
                                   |
                         +---------+---------+
                         |         |         |
                    +----+---+ +---+----+ +--+-----+
                    |Attention| | DAG   | |Hyper-  |
                    |Compare  | |Oblig. | |bolic   |
                    +---------+ +-------+ +--------+

Contract Types (Hyperbolic Embedding)
|
+-- Commercial
|   +-- Sales Agreement
|   +-- Service Agreement
|   +-- License Agreement
|   +-- Distribution Agreement
|
+-- Employment
|   +-- Employment Contract
|   +-- NDA
|   +-- Non-Compete
|
+-- Corporate
|   +-- Shareholder Agreement
|   +-- M&A Agreement
|   +-- Joint Venture

// legal/clause-extract input validation
const ClauseExtractSchema = z.object({
  document: z.string().max(10_000_000), // 10MB max document size
  clauseTypes: z.array(z.enum([
    'indemnification', 'limitation_of_liability', 'termination',
    'confidentiality', 'ip_assignment', 'governing_law', 'arbitration',
    'force_majeure', 'warranty', 'payment_terms', 'non_compete'
  ])).optional(),
  jurisdiction: z.string().max(50).default('US'),
  includePositions: z.boolean().default(true)
}).refine(doc => !containsExecutableContent(doc.document), {
  message: 'Document contains potentially malicious content'
});

// legal/risk-assess input validation
const RiskAssessSchema = z.object({
  document: z.string().max(10_000_000),
  partyRole: z.enum(['buyer', 'seller', 'licensor', 'licensee', 'employer', 'employee']),
  riskCategories: z.array(z.enum(['financial', 'operational', 'legal', 'reputational', 'compliance'])).optional(),
  industryContext: z.string().max(200).optional(),
  threshold: z.enum(['low', 'medium', 'high', 'critical']).optional()
});

// legal/contract-compare input validation
const ContractCompareSchema = z.object({
  baseDocument: z.string().max(10_000_000),
  compareDocument: z.string().max(10_000_000),
  comparisonMode: z.enum(['structural', 'semantic', 'full']).default('full'),
  highlightChanges: z.boolean().default(true),
  generateRedline: z.boolean().default(false)
});

// Path traversal prevention for file inputs
function validateFilePath(path: string): boolean {
  const normalized = path.normalize(path);
  const resolved = path.resolve(normalized);
  return resolved.startsWith(ALLOWED_DOCUMENT_ROOT) &&
         !normalized.includes('..') &&
         !normalized.includes('\0');
}

// Each legal matter MUST have isolated processing
interface MatterIsolation {
  matterId: string;           // Unique matter identifier
  wasmInstance: WebAssembly.Instance; // Dedicated WASM instance
  memoryRegion: ArrayBuffer;  // Isolated memory
  documentHashes: string[];   // Track which documents processed
  accessLog: AuditEntry[];    // Matter-specific audit trail
}

// CRITICAL: Prevent cross-matter contamination
async function processDocument(matterId: string, document: string): Promise<AnalysisResult> {
  const isolation = await getMatterIsolation(matterId);

  // Verify no cross-matter access
  if (isolation.matterId !== matterId) {
    throw new SecurityError('Cross-matter access violation');
  }

  // Process in isolated instance
  return isolation.wasmInstance.exports.analyze(document);
}

// Required role-based access control for legal tools
const LegalRoles = {
  PARTNER: ['clause-extract', 'risk-assess', 'contract-compare', 'obligation-track', 'playbook-match'],
  ASSOCIATE: ['clause-extract', 'risk-assess', 'contract-compare', 'obligation-track'],
  PARALEGAL: ['clause-extract', 'obligation-track'],
  CONTRACT_MANAGER: ['obligation-track', 'playbook-match'],
  CLIENT: [] // No direct tool access - results only via attorney
};

// Ethical wall enforcement
interface EthicalWall {
  matterId: string;
  blockedUsers: string[];     // Users who cannot access this matter
  reason: string;             // Conflict reason (encrypted)
  createdBy: string;          // Partner who created wall
  createdAt: string;
}

interface LegalAuditLog {
  timestamp: string;          // ISO 8601
  userId: string;             // Authenticated user ID
  userRole: string;           // Role at time of access
  matterId: string;           // Matter accessed
  toolName: string;           // MCP tool invoked
  documentHash: string;       // Hash of document processed (not content)
  operationType: 'analyze' | 'compare' | 'export';
  resultSummary: string;      // High-level result (no privileged content)
  billingCode?: string;       // Optional billing reference
}

// Audit logs MUST be:
// - Encrypted at rest (AES-256)
// - Accessible only to ethics/compliance
// - Retained per jurisdiction requirements (typically 7+ years)
// - Not contain actual document content

// Document handling security
interface SecureDocumentHandler {
  // Sanitize document before processing
  sanitize(document: string): string;  // Remove macros, scripts

  // Validate document format
  validateFormat(document: string): ValidationResult;

  // Extract text safely (no code execution)
  extractText(document: Buffer, format: 'pdf' | 'docx'): string;

  // Verify document integrity
  verifyIntegrity(document: Buffer, expectedHash: string): boolean;
}

// Prevent malicious document attacks
function sanitizeDocument(content: string): string {
  // Remove potential script injections
  // Remove embedded objects that could execute
  // Validate character encoding
  // Strip metadata that could leak information
}

{
  "dependencies": {
    "micro-hnsw-wasm": "^0.2.0",
    "ruvector-hyperbolic-hnsw-wasm": "^0.1.0",
    "ruvector-attention-wasm": "^0.1.0",
    "ruvector-dag-wasm": "^0.1.0",
    "pdf-parse": "^1.1.1",
    "mammoth": "^1.6.0"
  }
}