@o-lang/legal-extractor 1.0.0

package/README.md

@@ -0,0 +1,85 @@
+# @o-lang/legal-extractor
+
+O-Lang resolver for structured legal document extraction.
+
+**Extract-only** — never provides legal advice, never predicts outcomes,
+never opines on validity or enforceability.
+
+## Installation
+
+npm install @o-lang/legal-extractor
+
+## Usage in .ol workflow
+
+Workflow "Legal Document Review" with document_ref, jurisdiction, doc_type, document_text
+
+Allow resolvers:
+- legal-extractor
+- llm-groq
+
+Step 1: Ask legal-extractor "{document_ref}" "{jurisdiction}" "{doc_type}" "{document_text}"
+Save as extracted
+
+Step 2: Ask llm-groq "Summarise the key findings from this {doc_type} under {jurisdiction} law.
+Reference: {document_ref}. Extracted data: {extracted.summary}.
+NEVER provide legal advice, speculate on outcomes, or make liability claims."
+Save as response
+
+Return response
+
+## What it extracts
+
+| Field        | Description                                      |
+|--------------|--------------------------------------------------|
+| summary      | Concise factual summary of the document          |
+| parties      | Named parties identified in the document         |
+| clauses      | Key clause types with excerpt                    |
+| dates        | All dates found in the document                  |
+| obligations  | Sentences containing obligation language         |
+| risks        | Risk flags with severity: high / medium / low    |
+| jurisdiction | Resolved jurisdiction label                      |
+| doc_type     | Resolved document type label                     |
+| word_count   | Total word count                                 |
+
+## Supported jurisdictions
+
+ng, gh, uk, us, za, ke, ug, tz, et, rw, eu, au, ca, in, general
+
+## Supported document types
+
+nda, contract, agreement, mou, loi, sla, employment, lease, tenancy,
+shareholder, partnership, joint venture, terms, privacy, dpa, ip,
+loan, service, consultancy, distribution, franchise, supply, settlement
+
+## Clause types detected (24 total)
+
+Confidentiality, Intellectual Property, Non-Compete, Non-Solicitation,
+Indemnification, Limitation of Liability, Governing Law, Dispute Resolution,
+Termination, Force Majeure, Automatic Renewal, Payment Terms,
+Liquidated Damages, Warranty, Warranty Disclaimer, Data Protection,
+Entire Agreement, Severability, Assignment, Exclusivity, Notice,
+Confidential Information, Permitted Disclosure
+
+## Risk severity levels
+
+- **high** — Non-compete, unlimited liability, IP assignment, liquidated damages
+- **medium** — Indemnification, liability cap, auto-renewal, data protection
+- **low** — Arbitration, governing law, force majeure, confidentiality
+
+## O-Lang kernel compliance
+
+- resolverName: legal-extractor
+- deterministic: true
+- sideEffects: false
+- requiresNetwork: false
+- extract_only: true
+
+## Legal notice
+
+This resolver performs automated text extraction only. It does not
+provide legal advice. Always consult a qualified legal professional
+for advice on specific legal documents.
+
+## License
+
+MIT — [Your Organisation Name]

package/capability.js

@@ -0,0 +1,395 @@
+// capability.js
+//
+// O-Lang Legal Extractor Resolver — capability.js v1.0.0
+//
+// Deterministic, zero-dependency structured extraction from legal documents.
+// Identifies parties, clauses, dates, obligations, and risk flags.
+//
+// EXTRACT-ONLY. This resolver:
+//   ✓ Extracts and classifies what IS in the document
+//   ✗ Never provides legal advice
+//   ✗ Never predicts legal outcomes
+//   ✗ Never opines on validity or enforceability
+
+'use strict';
+
+// ── Jurisdiction map ──────────────────────────────────────────────────────────
+const JURISDICTIONS = {
+  'ng': 'Nigeria', 'nigeria': 'Nigeria',
+  'gh': 'Ghana',   'ghana': 'Ghana',
+  'uk': 'United Kingdom', 'england': 'United Kingdom', 'gb': 'United Kingdom',
+  'us': 'United States',  'usa': 'United States',
+  'za': 'South Africa',   'south africa': 'South Africa',
+  'ke': 'Kenya',
+  'ug': 'Uganda',
+  'tz': 'Tanzania',
+  'et': 'Ethiopia',
+  'rw': 'Rwanda',
+  'eu': 'European Union',
+  'au': 'Australia',
+  'ca': 'Canada',
+  'in': 'India',
+  'general': 'General / Unspecified',
+};
+
+// ── Document type map ─────────────────────────────────────────────────────────
+const DOC_TYPES = {
+  'nda': 'Non-Disclosure Agreement',
+  'non-disclosure': 'Non-Disclosure Agreement',
+  'confidentiality': 'Confidentiality Agreement',
+  'contract': 'Contract',
+  'agreement': 'Agreement',
+  'mou': 'Memorandum of Understanding',
+  'memorandum': 'Memorandum of Understanding',
+  'loi': 'Letter of Intent',
+  'letter of intent': 'Letter of Intent',
+  'sla': 'Service Level Agreement',
+  'service level': 'Service Level Agreement',
+  'employment': 'Employment Agreement',
+  'offer letter': 'Employment Offer Letter',
+  'lease': 'Lease Agreement',
+  'tenancy': 'Tenancy Agreement',
+  'rental': 'Rental Agreement',
+  'shareholder': 'Shareholder Agreement',
+  'partnership': 'Partnership Agreement',
+  'joint venture': 'Joint Venture Agreement',
+  'terms': 'Terms and Conditions',
+  'terms of service': 'Terms of Service',
+  'privacy': 'Privacy Policy',
+  'data processing': 'Data Processing Agreement',
+  'dpa': 'Data Processing Agreement',
+  'ip': 'Intellectual Property Agreement',
+  'assignment': 'Assignment Agreement',
+  'loan': 'Loan Agreement',
+  'facility': 'Facility Agreement',
+  'service': 'Service Agreement',
+  'consultancy': 'Consultancy Agreement',
+  'distribution': 'Distribution Agreement',
+  'reseller': 'Reseller Agreement',
+  'franchise': 'Franchise Agreement',
+  'supply': 'Supply Agreement',
+  'purchase': 'Purchase Agreement',
+  'sale': 'Sale Agreement',
+  'settlement': 'Settlement Agreement',
+  'general': 'General Legal Document',
+};
+
+// ── Clause type patterns ──────────────────────────────────────────────────────
+const CLAUSE_PATTERNS = [
+  { type: 'Confidentiality',        pattern: /confidential(ity)?|non[- ]disclosure|trade\s+secret/gi },
+  { type: 'Intellectual Property',  pattern: /intellectual\s+property|ip\s+ownership|copyright|trademark|patent|assign(s|ed)?\s+(all\s+)?rights/gi },
+  { type: 'Non-Compete',            pattern: /non[- ]compete|restraint\s+of\s+trade|not\s+to\s+compete/gi },
+  { type: 'Non-Solicitation',       pattern: /non[- ]solicit(ation)?|not\s+to\s+solicit/gi },
+  { type: 'Indemnification',        pattern: /indemnif(y|ies|ied|ication)|hold\s+harmless/gi },
+  { type: 'Limitation of Liability',pattern: /limitation\s+of\s+liability|limit(ed)?\s+liability|liability\s+cap|not\s+.*\s+liable/gi },
+  { type: 'Governing Law',          pattern: /governing\s+law|choice\s+of\s+law|shall\s+be\s+governed\s+by/gi },
+  { type: 'Dispute Resolution',     pattern: /arbitration|mediation|dispute\s+resolution|escalation\s+procedure/gi },
+  { type: 'Termination',            pattern: /terminat(e|ion|ing)|cancell(ation|ing)|rescission/gi },
+  { type: 'Force Majeure',          pattern: /force\s+majeure|act\s+of\s+god|circumstances\s+beyond/gi },
+  { type: 'Automatic Renewal',      pattern: /automatic(ally)?\s+renew(s|al|ed)?|evergreen\s+clause|renew\s+unless\s+notice/gi },
+  { type: 'Payment Terms',          pattern: /payment\s+terms?|invoice|due\s+date|net\s+\d+|late\s+payment|interest\s+on\s+.*\s+overdue/gi },
+  { type: 'Liquidated Damages',     pattern: /liquidated\s+damages|penalty\s+clause|agreed\s+damages/gi },
+  { type: 'Warranty',               pattern: /warrant(y|ies|s)|representation\s+and\s+warrant/gi },
+  { type: 'Warranty Disclaimer',    pattern: /disclaim(s|er)?.*warrant(y|ies)|no\s+warrant(y|ies)|as\s+is/gi },
+  { type: 'Data Protection',        pattern: /personal\s+data|data\s+protection|gdpr|ndpa|popia|data\s+subject|processing\s+of\s+.*\s+data/gi },
+  { type: 'Entire Agreement',       pattern: /entire\s+agreement|whole\s+agreement|supersedes\s+all\s+prior/gi },
+  { type: 'Severability',           pattern: /severab(le|ility)|if\s+any\s+provision\s+.*\s+invalid/gi },
+  { type: 'Assignment',             pattern: /assign(ment|ments|able|ability)|transfer\s+(this|the)\s+agreement/gi },
+  { type: 'Exclusivity',            pattern: /exclusiv(e|ity)|sole\s+(right|supplier|distributor)/gi },
+  { type: 'Notice',                 pattern: /notice\s+(period|requirement|shall\s+be\s+given)|written\s+notice/gi },
+  { type: 'Confidential Information',pattern: /confidential\s+information\s+(means|includes|shall\s+mean)/gi },
+  { type: 'Permitted Disclosure',   pattern: /permitted\s+disclosure|may\s+disclose|permitted\s+to\s+disclose/gi },
+];
+
+// ── Risk flag patterns ────────────────────────────────────────────────────────
+const RISK_PATTERNS = [
+  { pattern: /unlimited\s+liability/gi,                                    label: 'Unlimited liability exposure identified',                severity: 'high'   },
+  { pattern: /liquidated\s+damages|penalty\s+clause/gi,                   label: 'Liquidated damages or penalty clause present',          severity: 'high'   },
+  { pattern: /non[- ]compete|restraint\s+of\s+trade/gi,                   label: 'Non-compete or restraint of trade clause present',      severity: 'high'   },
+  { pattern: /intellectual\s+property.*assign|assign.*intellectual\s+property|assigns?\s+all\s+rights/gi, label: 'Broad IP assignment clause present', severity: 'high' },
+  { pattern: /indemnif(y|ies|ied|ication)/gi,                             label: 'Indemnification clause present',                        severity: 'medium' },
+  { pattern: /limitation\s+of\s+liability|liability\s+cap/gi,             label: 'Limitation of liability clause present',                severity: 'medium' },
+  { pattern: /automatic(ally)?\s+renew|evergreen/gi,                      label: 'Automatic renewal clause — notice required to exit',    severity: 'medium' },
+  { pattern: /terminat(e|ion)\s+(for\s+cause|without\s+cause|at\s+will)/gi, label: 'Unilateral termination rights present',              severity: 'medium' },
+  { pattern: /exclusiv(e|ity)/gi,                                         label: 'Exclusivity obligation present',                        severity: 'medium' },
+  { pattern: /warrant(y|ies|s)\s+(disclaim|waiv|exclud)|as[- ]is/gi,      label: 'Warranty disclaimer — no guarantees given',            severity: 'medium' },
+  { pattern: /personal\s+data|data\s+protection|gdpr|ndpa|popia/gi,       label: 'Data protection obligations present',                   severity: 'medium' },
+  { pattern: /arbitration/gi,                                              label: 'Disputes referred to arbitration (not courts)',         severity: 'low'    },
+  { pattern: /governing\s+law|shall\s+be\s+governed\s+by/gi,              label: 'Governing law clause present',                         severity: 'low'    },
+  { pattern: /force\s+majeure/gi,                                         label: 'Force majeure clause present',                          severity: 'low'    },
+  { pattern: /confidential(ity)?/gi,                                      label: 'Confidentiality obligations present',                   severity: 'low'    },
+];
+
+// ── Obligation keywords ───────────────────────────────────────────────────────
+const OBLIGATION_KEYWORDS = [
+  'shall', 'must', 'is required to', 'agrees to', 'undertakes to',
+  'is obligated to', 'is liable for', 'covenants to',
+  'warrants that', 'represents that', 'will be responsible for',
+  'is bound to', 'hereby agrees', 'commits to',
+];
+
+// ── Date patterns ─────────────────────────────────────────────────────────────
+const DATE_PATTERNS = [
+  /\b(\d{1,2}(?:st|nd|rd|th)?\s+(?:January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{4})\b/gi,
+  /\b((?:January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{1,2}(?:st|nd|rd|th)?,?\s+\d{4})\b/gi,
+  /\b(\d{4}-\d{2}-\d{2})\b/g,
+  /\b(\d{1,2}\/\d{1,2}\/\d{2,4})\b/g,
+  /\b(\d{1,2}-\d{1,2}-\d{2,4})\b/g,
+];
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function resolveJurisdiction(raw) {
+  if (!raw) return 'General / Unspecified';
+  const key = raw.trim().toLowerCase();
+  return JURISDICTIONS[key] || raw.trim();
+}
+
+function resolveDocType(raw) {
+  if (!raw) return 'General Legal Document';
+  const key = raw.trim().toLowerCase();
+  return DOC_TYPES[key] || raw.trim();
+}
+
+function extractParties(text) {
+  const parties = new Set();
+
+  // "between X and Y" — most common in contracts
+  const betweenMatch = text.match(
+    /between\s+([A-Z][A-Za-z\s,\.()&''"–\-]{2,80?})\s+and\s+([A-Z][A-Za-z\s,\.()&''"–\-]{2,80?})(?:\s*[\(,\.\;])/i
+  );
+  if (betweenMatch) {
+    parties.add(betweenMatch[1].replace(/\s+/g, ' ').trim());
+    parties.add(betweenMatch[2].replace(/\s+/g, ' ').trim());
+  }
+
+  // "X (hereinafter "Y")" or "X (the "Y")"
+  const hereinafterMatches = [
+    ...text.matchAll(
+      /([A-Z][A-Za-z\s,\.()&''"–\-]{3,80?})\s*\((?:hereinafter(?:\s+referred\s+to\s+as)?|the)\s*[""]([A-Z][A-Za-z\s]+)[""]\)/gi
+    )
+  ];
+  for (const m of hereinafterMatches) {
+    parties.add(`${m[1].replace(/\s+/g, ' ').trim()} ("${m[2].trim()}")`);
+  }
+
+  // "Party A" / "Party B" named styles
+  const partyLabels = [...text.matchAll(/\b(Party\s+[A-Z\d])\b/g)];
+  for (const m of partyLabels) parties.add(m[1]);
+
+  // Role-based: "the Employer", "the Employee", "the Disclosing Party" etc.
+  const roleMatches = [...text.matchAll(
+    /\bthe\s+(Employer|Employee|Disclosing\s+Party|Receiving\s+Party|Licensor|Licensee|Buyer|Seller|Supplier|Contractor|Client|Consultant|Lender|Borrower|Landlord|Tenant|Franchisor|Franchisee)\b/g
+  )];
+  for (const m of roleMatches) parties.add(`the ${m[1]}`);
+
+  return [...parties].filter(p => p.length > 2).slice(0, 10);
+}
+
+function extractDates(text) {
+  const found = new Set();
+  for (const pattern of DATE_PATTERNS) {
+    const matches = [...text.matchAll(pattern)];
+    for (const m of matches) {
+      found.add(m[1] || m[0]);
+    }
+  }
+  return [...found].slice(0, 20);
+}
+
+function extractClauses(text) {
+  const found = [];
+  for (const { type, pattern } of CLAUSE_PATTERNS) {
+    if (pattern.test(text)) {
+      // Find the sentence containing the match
+      pattern.lastIndex = 0;
+      const match = pattern.exec(text);
+      if (match) {
+        const start = Math.max(0, match.index - 80);
+        const end   = Math.min(text.length, match.index + 160);
+        const excerpt = text.slice(start, end)
+          .replace(/\s+/g, ' ')
+          .trim()
+          .replace(/^[^A-Z]/, '')
+          .slice(0, 200);
+        found.push({ type, excerpt: excerpt + (excerpt.length === 200 ? '…' : '') });
+      }
+    }
+    pattern.lastIndex = 0;
+  }
+  // Deduplicate by type
+  const seen = new Set();
+  return found.filter(c => {
+    if (seen.has(c.type)) return false;
+    seen.add(c.type);
+    return true;
+  });
+}
+
+function extractObligations(text) {
+  const sentences = text
+    .replace(/\r\n/g, '\n')
+    .split(/(?<=[.!?])\s+(?=[A-Z])/)
+    .map(s => s.replace(/\s+/g, ' ').trim())
+    .filter(s => s.length > 20 && s.length < 400);
+
+  return sentences
+    .filter(s => OBLIGATION_KEYWORDS.some(kw => s.toLowerCase().includes(kw)))
+    .slice(0, 15);
+}
+
+function extractRisks(text) {
+  const found = [];
+  for (const { pattern, label, severity } of RISK_PATTERNS) {
+    if (pattern.test(text)) {
+      found.push({ flag: label, severity });
+    }
+    pattern.lastIndex = 0;
+  }
+  // Sort: high → medium → low
+  const order = { high: 0, medium: 1, low: 2 };
+  return found.sort((a, b) => order[a.severity] - order[b.severity]);
+}
+
+function buildSummary(params) {
+  const {
+    document_ref, docTypeLabel, jurisdictionLabel,
+    wordCount, parties, clauses, dates, obligations, risks,
+  } = params;
+
+  const highRisks  = risks.filter(r => r.severity === 'high').length;
+  const medRisks   = risks.filter(r => r.severity === 'medium').length;
+  const clauseList = clauses.slice(0, 5).map(c => c.type).join(', ');
+  const partyList  = parties.slice(0, 3).join(', ');
+
+  let summary = `Document reference ${document_ref} is a ${docTypeLabel}`;
+  if (jurisdictionLabel !== 'General / Unspecified') {
+    summary += ` governed under ${jurisdictionLabel} law`;
+  }
+  summary += `. The document contains ${wordCount.toLocaleString()} words`;
+  if (parties.length > 0) summary += ` and identifies the following parties: ${partyList}`;
+  summary += '.';
+  if (clauses.length > 0) summary += ` Key clause types identified include: ${clauseList}.`;
+  if (dates.length > 0) summary += ` ${dates.length} date reference${dates.length > 1 ? 's' : ''} found.`;
+  if (obligations.length > 0) summary += ` ${obligations.length} obligation statement${obligations.length > 1 ? 's' : ''} extracted.`;
+  if (highRisks > 0) summary += ` ${highRisks} high-severity risk flag${highRisks > 1 ? 's' : ''} identified.`;
+  if (medRisks > 0)  summary += ` ${medRisks} medium-severity risk flag${medRisks > 1 ? 's' : ''} identified.`;
+  summary += ' This is a factual extraction only. No legal advice is provided.';
+
+  return summary;
+}
+
+// ── Parse action string ───────────────────────────────────────────────────────
+// Action format: legal-extractor "doc_ref" "jurisdiction" "doc_type" "document_text"
+function parseActionArgs(action) {
+  const args = [];
+  const regex = /"((?:[^"\\]|\\.)*)"/g;
+  let match;
+  while ((match = regex.exec(action)) !== null) {
+    args.push(match[1].replace(/\\"/g, '"'));
+  }
+  return args;
+}
+
+// ── Main resolver ─────────────────────────────────────────────────────────────
+async function resolve(action, context = {}, options = {}) {
+  console.log('\n⚖️  LEGAL-EXTRACTOR RESOLVER CALLED');
+  console.log('  action preview:', typeof action === 'string' ? action.substring(0, 120) : '[non-string]');
+
+  try {
+    // ── 1. Parse arguments from action string ────────────────────────────
+    let document_ref, jurisdiction, doc_type, document_text;
+
+    if (typeof action === 'string') {
+      const args = parseActionArgs(action);
+      // Strip "legal-extractor" or "Action legal-extractor" prefix
+      const offset = args.length >= 4 ? 0 : 0;
+      document_ref   = args[offset]     || context.document_ref   || 'REF-UNKNOWN';
+      jurisdiction   = args[offset + 1] || context.jurisdiction   || 'general';
+      doc_type       = args[offset + 2] || context.doc_type       || 'general';
+      document_text  = args[offset + 3] || context.document_text  || '';
+    } else {
+      document_ref   = context.document_ref   || 'REF-UNKNOWN';
+      jurisdiction   = context.jurisdiction   || 'general';
+      doc_type       = context.doc_type       || 'general';
+      document_text  = context.document_text  || '';
+    }
+
+    // ── 2. Validate ───────────────────────────────────────────────────────
+    if (!document_text || document_text.trim().length < 10) {
+      console.warn('[legal-extractor] ⚠️  document_text is empty or too short');
+      return {
+        summary:      'No document text provided for extraction.',
+        parties:      [],
+        clauses:      [],
+        dates:        [],
+        obligations:  [],
+        risks:        [],
+        jurisdiction: resolveJurisdiction(jurisdiction),
+        doc_type:     resolveDocType(doc_type),
+        word_count:   0,
+        error:        'document_text required',
+      };
+    }
+
+    const text           = document_text.trim();
+    const wordCount      = text.split(/\s+/).length;
+    const jurisdictionLabel = resolveJurisdiction(jurisdiction);
+    const docTypeLabel      = resolveDocType(doc_type);
+
+    console.log(`[legal-extractor] Processing: ref=${document_ref} | type=${docTypeLabel} | jurisdiction=${jurisdictionLabel} | words=${wordCount}`);
+
+    // ── 3. Extract ────────────────────────────────────────────────────────
+    const parties     = extractParties(text);
+    const dates       = extractDates(text);
+    const clauses     = extractClauses(text);
+    const obligations = extractObligations(text);
+    const risks       = extractRisks(text);
+
+    // ── 4. Build summary ──────────────────────────────────────────────────
+    const summary = buildSummary({
+      document_ref, docTypeLabel, jurisdictionLabel,
+      wordCount, parties, clauses, dates, obligations, risks,
+    });
+
+    console.log(`[legal-extractor] ✅ Extracted: ${parties.length} parties, ${clauses.length} clauses, ${dates.length} dates, ${obligations.length} obligations, ${risks.length} risk flags`);
+
+    return {
+      summary,
+      parties,
+      clauses,
+      dates,
+      obligations,
+      risks,
+      jurisdiction: jurisdictionLabel,
+      doc_type:     docTypeLabel,
+      word_count:   wordCount,
+      document_ref,
+      extracted_at: new Date().toISOString(),
+    };
+
+  } catch (err) {
+    console.error('[legal-extractor] 💥 Error:', err.message);
+    return {
+      summary:      `Extraction failed: ${err.message}`,
+      parties:      [],
+      clauses:      [],
+      dates:        [],
+      obligations:  [],
+      risks:        [],
+      jurisdiction: 'Unknown',
+      doc_type:     'Unknown',
+      word_count:   0,
+      error:        err.message,
+    };
+  }
+}
+
+// ── Exports ───────────────────────────────────────────────────────────────────
+module.exports = resolve;
+module.exports.extractParties     = extractParties;
+module.exports.extractDates       = extractDates;
+module.exports.extractClauses     = extractClauses;
+module.exports.extractObligations = extractObligations;
+module.exports.extractRisks       = extractRisks;
+module.exports.buildSummary       = buildSummary;

package/index.js

@@ -0,0 +1,35 @@
+// index.js
+// O-Lang resolver — kernel-compliant export
+// Follows the same pattern as all @o-lang/* resolvers
+
+const resolve      = require('./capability');
+const resolverMeta = require('./resolver');
+
+// Attach kernel metadata to the resolver function
+resolve.resolverName  = resolverMeta.resolverName;   // 'legal-extractor'
+resolve.version       = resolverMeta.version;
+resolve.specVersion   = resolverMeta.specVersion;
+resolve.inputs        = resolverMeta.inputs;
+resolve.outputs       = resolverMeta.outputs;
+resolve.exampleAction = resolverMeta.exampleAction;
+resolve.properties    = resolverMeta.properties;
+resolve.prohibited_outputs = resolverMeta.prohibited_outputs;
+resolve.documentationUrl   = resolverMeta.documentationUrl;
+
+// Registry / HTTP server manifest
+resolve.manifest = () => ({
+  name:     resolverMeta.resolverName,
+  version:  resolverMeta.version,
+  protocol: 'local',
+  resolvers: [
+    {
+      name:          'legal-extractor',
+      input:         ['document_ref', 'jurisdiction', 'doc_type', 'document_text'],
+      output:        ['summary', 'parties', 'clauses', 'dates', 'obligations', 'risks'],
+      deterministic: true,
+      extract_only:  true,
+    }
+  ]
+});
+
+module.exports = resolve;

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@o-lang/legal-extractor",
+  "version": "1.0.0",
+  "description": "O-Lang resolver for structured legal document extraction. Extract-only — never provides legal advice.",
+  "main": "index.js",
+  "keywords": [
+    "o-lang",
+    "resolver",
+    "legal",
+    "contract",
+    "nda",
+    "extract",
+    "governance"
+  ],
+  "author": "[Your Organisation Name]",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/O-Lang-Central/resolver-legal-extractor"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {}
+}

package/resolver.js

@@ -0,0 +1,52 @@
+// resolver.js
+// O-Lang resolver metadata — read by the kernel and registry
+
+module.exports = {
+  resolverName: 'legal-extractor',
+  version:      '1.0.0',
+  specVersion:  'O-Lang/1.1',
+
+  inputs: [
+    { name: 'document_ref',  type: 'string', required: true,  description: 'Unique reference ID for the document' },
+    { name: 'jurisdiction',  type: 'string', required: false, description: 'Legal jurisdiction (e.g. ng, gh, uk, us)' },
+    { name: 'doc_type',      type: 'string', required: false, description: 'Document type (e.g. nda, contract, employment)' },
+    { name: 'document_text', type: 'string', required: true,  description: 'Full text content of the legal document' },
+  ],
+
+  outputs: [
+    { name: 'summary',      type: 'string', description: 'Concise factual summary of the document' },
+    { name: 'parties',      type: 'array',  description: 'Named parties identified in the document' },
+    { name: 'clauses',      type: 'array',  description: 'Key clauses identified by type' },
+    { name: 'dates',        type: 'array',  description: 'All dates found in the document' },
+    { name: 'obligations',  type: 'array',  description: 'Sentences containing obligation language' },
+    { name: 'risks',        type: 'array',  description: 'Risk flags with severity levels' },
+    { name: 'jurisdiction', type: 'string', description: 'Resolved jurisdiction label' },
+    { name: 'doc_type',     type: 'string', description: 'Resolved document type label' },
+    { name: 'word_count',   type: 'number', description: 'Total word count of the document' },
+  ],
+
+  exampleAction: 'legal-extractor "REF-001" "ng" "nda" "This Non-Disclosure Agreement is entered into between Acme Ltd and Beta Corp..."',
+
+  properties: {
+    deterministic:        true,
+    sideEffects:          false,
+    requiresNetwork:      false,
+    handlesTemplatedPrompts: true,
+    skipSchemaValidation: true,
+    extractOnly:          true,   // kernel hint: this resolver never takes actions
+  },
+
+  // Declared prohibited outputs — the kernel can use these for output validation
+  prohibited_outputs: [
+    'legal advice',
+    'you should sign',
+    'you should not sign',
+    'this contract is valid',
+    'this contract is invalid',
+    'you will win',
+    'you will lose',
+    'liability',
+  ],
+
+  documentationUrl: 'https://olang.cloud/registry/legal-extractor',
+};