fix(v4.3.1): app.py — Run 4 delta fixes (A-E)

app.py

@@ -294,6 +294,56 @@ DESC_MAP.update({
 
 RISK_WEIGHTS = {"CRITICAL": 40, "HIGH": 20, "MEDIUM": 10, "LOW": 3}
 
+# FIX v4.3.1: Content-based severity refinement
+# Default RISK_MAP assigns severity by label alone. This function downgrades severity
+# when the clause text contains mitigating language (caps, carve-outs, time limits).
+_SEVERITY_MITIGATORS = {
+    "IP Ownership Assignment": {
+        # Downgrade from CRITICAL to HIGH if pre-existing IP is carved out
+        "HIGH": re.compile(r'pre[\-\s]existing|background\s+ip|prior\s+(?:ip|intellectual)', re.IGNORECASE),
+        # Downgrade to MEDIUM if both carve-out AND license-back exist
+        "MEDIUM": re.compile(r'(?:pre[\-\s]existing|background\s+ip).*(?:license|retain)', re.IGNORECASE | re.DOTALL),
+    },
+    "Limitation of liability": {
+        # Downgrade from CRITICAL to HIGH if there's any cap
+        "HIGH": re.compile(r'shall\s+not\s+exceed|aggregate.{0,20}(?:not\s+exceed|limited\s+to)|cap(?:ped)?\s+at', re.IGNORECASE),
+        # Downgrade to MEDIUM if there's a reasonable cap AND exceptions for gross negligence
+        "MEDIUM": re.compile(r'(?:shall\s+not\s+exceed|limited\s+to).{0,80}(?:gross\s+negligence|willful|fraud)', re.IGNORECASE | re.DOTALL),
+    },
+    "Termination for Convenience": {
+        # Downgrade from CRITICAL to HIGH if there's a notice period
+        "HIGH": re.compile(r'(?:\d+)\s+(?:day|month|week)s?.{0,20}(?:prior|advance|written)\s+notice', re.IGNORECASE),
+        # Downgrade to MEDIUM if mutual termination right
+        "MEDIUM": re.compile(r'either\s+party\s+may\s+terminat', re.IGNORECASE),
+    },
+    "Non-Compete": {
+        # Downgrade from HIGH to MEDIUM if time-limited
+        "MEDIUM": re.compile(r'(?:period\s+of|for)\s+(?:\d+|one|two|three|six|twelve)\s+(?:\(\d+\)\s+)?(?:month|year)', re.IGNORECASE),
+    },
+    "Arbitration": {
+        # Downgrade from CRITICAL to HIGH if opt-out is available
+        "HIGH": re.compile(r'opt[\-\s]?out|may\s+elect|small\s+claims', re.IGNORECASE),
+    },
+}
+
+
+def _refine_severity(label, text, default_risk):
+    """FIX v4.3.1: Refine severity based on clause content, not just label."""
+    mitigators = _SEVERITY_MITIGATORS.get(label)
+    if not mitigators:
+        return default_risk
+
+    # Check from lowest severity up — return the lowest matching level
+    for level in ["MEDIUM", "HIGH"]:
+        pattern = mitigators.get(level)
+        if pattern and pattern.search(text):
+            # Only downgrade, never upgrade
+            level_order = {"CRITICAL": 4, "HIGH": 3, "MEDIUM": 2, "LOW": 1}
+            if level_order.get(level, 0) < level_order.get(default_risk, 0):
+                return level
+
+    return default_risk
+
 RISK_STYLES = {
     "CRITICAL": ("#dc2626", "#fef2f2", "⚠️"),
     "HIGH":     ("#ea580c", "#fff7ed", "⚡"),
@@ -617,16 +667,29 @@ _LABEL_GUARDRAILS = {
         r'uncapped|unlimited.{0,10}liabilit|no.{0,10}(limit|cap).{0,10}liabilit',
         re.IGNORECASE
     ),
-    # FIX v4.3: ROFR fires on "right, title, and interest" in IP clauses — require ROFR-specific phrases
     "ROFR/ROFO/ROFN": re.compile(
         r'right\s+of\s+first\s+(?:refusal|offer|negotiation)|ROFR|ROFO|ROFN',
         re.IGNORECASE
     ),
-    # FIX v4.3: Renewal Term fires on "twelve (12) months" in liability caps — require renewal-specific phrases
     "Renewal Term": re.compile(
         r'renew(?:al)?|successive\s+term|auto(?:matic(?:ally)?)?\s*[\-\s]?renew|non[\-\s]?renewal',
         re.IGNORECASE
     ),
+    # FIX v4.3.1: Revenue/Profit Sharing fires on IP assignment "rights for value" language
+    "Revenue/Profit Sharing": re.compile(
+        r'revenue\s+shar|profit\s+shar|revenue\s+split|percentage\s+of\s+revenue|royalt(?:y|ies)|gross\s+profit',
+        re.IGNORECASE
+    ),
+    # FIX v4.3.1: Minimum Commitment fires on fee schedules — require explicit minimum language
+    "Minimum Commitment": re.compile(
+        r'minimum\s+(?:purchase|order|spend|volume|commitment)|take[\-\s]or[\-\s]pay|minimum\s+annual',
+        re.IGNORECASE
+    ),
+    # FIX v4.3.1: Non-Disparagement fires on arbitration/class-waiver language
+    "Non-Disparagement": re.compile(
+        r'disparag|defam|false\s+statement|negative\s+statement|social\s+media|reputat',
+        re.IGNORECASE
+    ),
 }
 
 # FIX v4.3: Exclusion patterns — even if guardrail passes, exclude if contra-indicators present
@@ -639,12 +702,24 @@ _LABEL_EXCLUSIONS = {
         r'limitation\s+of\s+liabilit|shall\s+not\s+be\s+liable|indemnif|hold\s+harmless|defend\s+and',
         re.IGNORECASE
     ),
+    # FIX v4.3.1: Revenue/Profit Sharing must NOT fire on IP assignment or license grant clauses
+    "Revenue/Profit Sharing": re.compile(
+        r'assigns?\s+to|irrevocab(?:ly|le)\s+assign|work[\-\s](?:made\s+)?for[\-\s]hire|license\s+to\s+access|license\s+grant|non[\-\s]exclusive\s+license',
+        re.IGNORECASE
+    ),
+    # FIX v4.3.1: Non-Disparagement must NOT fire on arbitration/dispute sections
+    "Non-Disparagement": re.compile(
+        r'arbitrat|(?<!\w)aaa(?!\w)|(?<!\w)jams(?!\w)|class\s+action|collective\s+(?:proceeding|action)|waives?\s+any\s+right\s+to\s+participate|binding\s+arbitration',
+        re.IGNORECASE
+    ),
 }
 
-# FIX v4.3: Minimum confidence thresholds per label (overrides the per-class _CUAD_THRESHOLDS)
+# FIX v4.3: Minimum confidence thresholds per label
 _LABEL_MIN_CONFIDENCE = {
     "ROFR/ROFO/ROFN": 0.65,
     "Renewal Term": 0.70,
+    "Revenue/Profit Sharing": 0.65,  # FIX v4.3.1
+    "Minimum Commitment": 0.65,      # FIX v4.3.1
 }
 
 def _apply_guardrails(label, text, confidence):
@@ -712,6 +787,7 @@ def classify_cuad(clause_text):
             label, conf = _apply_guardrails(label, clause_text, conf)
             if not (label == "Other" and conf < 0.3):
                 risk = RISK_MAP.get(label, "LOW")
+                risk = _refine_severity(label, clause_text, risk)
                 results.append({
                     "label": label,
                     "confidence": round(conf, 3),
@@ -735,6 +811,7 @@ def classify_cuad(clause_text):
                         # Only add if different from primary
                         if not results or results[0]["label"] != label2:
                             risk2 = RISK_MAP.get(label2, "LOW")
+                            risk2 = _refine_severity(label2, clause_text, risk2)
                             results.append({
                                 "label": label2,
                                 "confidence": round(conf2, 3),
@@ -821,6 +898,7 @@ def classify_cuad_batch(clauses, batch_size=8):
                     label, conf = _apply_guardrails(label, original_text, conf)
                     if not (label == "Other" and conf < 0.3):
                         risk = RISK_MAP.get(label, "LOW")
+                        risk = _refine_severity(label, original_text, risk)
                         results.append({
                             "label": label,
                             "confidence": round(conf, 3),
@@ -842,6 +920,7 @@ def classify_cuad_batch(clauses, batch_size=8):
                         if not (label2 == "Other" and conf2 < 0.3):
                             if not results or results[0]["label"] != label2:
                                 risk2 = RISK_MAP.get(label2, "LOW")
+                                risk2 = _refine_severity(label2, original_text, risk2)
                                 results.append({
                                     "label": label2,
                                     "confidence": round(conf2, 3),