QWED Legal guards for contract verification

from qwed_legal import trace_to_dict

# Any guard result exposes .verification_trace
serialized = trace_to_dict(result.verification_trace)  # JSON-safe list of dicts
# each entry carries an explicit "is_proven" flag

from qwed_legal import DeadlineGuard
from qwed_legal.diagnostics import (
    LegalDiagnosticStatus,
    compute_proof_ref,
    resolve_proof_ref,
)

claim_inputs = {
    "signing_date": "2026-01-15",
    "term": "30 business days",
    "claimed_deadline": "2026-02-27",
}
result = DeadlineGuard().verify(**claim_inputs)

diag = result.to_diagnostic(claim_inputs=claim_inputs)
assert diag.status is LegalDiagnosticStatus.VERIFIED
assert diag.proof_ref.startswith("sha256:")

# The same evidence recomputes to the same hash.
evidence = {
    "claim_inputs": diag.developer_fields["claim_inputs"],
    "trace":        diag.developer_fields["verification_trace"],
    "result":       diag.developer_fields["result"],
}
assert compute_proof_ref(evidence) == diag.proof_ref
assert resolve_proof_ref(diag.proof_ref, evidence) is True

from qwed_legal import DeadlineGuard

guard = DeadlineGuard(country="US", state="CA")

result = guard.verify(
    signing_date="2026-01-15",
    term="30 business days",
    claimed_deadline="2026-02-14"
)

print(result.verified)           # False
print(result.computed_deadline)  # 2026-02-27
print(result.difference_days)    # 13

from qwed_legal import DeadlineGuard

guard = DeadlineGuard()

# Ambiguous term — no numeric quantity
result = guard.verify(
    signing_date="2026-01-01",
    term="within a reasonable period",
    claimed_deadline="2026-01-31",
)

print(result.verified)          # False
print(result.is_computable)     # False
print(result.computed_deadline) # None
print(result.difference_days)   # None
print(result.message)
# ⚠️ UNVERIFIABLE: Term 'within a reasonable period' does not contain a
# provable time quantity and unit. Cannot compute a deterministic deadline...

from qwed_legal import DeadlineGuard

guard = DeadlineGuard()

result = guard.verify(
    signing_date="03/04/2026",
    term="30 days",
    claimed_deadline="2026-04-03",
)

# Before: "03/04/2026" was read as March 4, and the claim verified.
# After:
print(result.verified)       # False
print(result.is_computable)  # False
print(result.signing_date)   # None
print(result.message)
# ⚠️ UNVERIFIABLE: signing_date is order-ambiguous (reads differently
# month-first vs day-first). Supply an ISO year-leading date (YYYY-MM-DD)
# or an unambiguous written date.

# Fix: supply the intended date in ISO form.
result = guard.verify(
    signing_date="2026-03-04",
    term="30 days",
    claimed_deadline="2026-04-03",
)
print(result.verified)       # True

result = guard.verify(
    signing_date="2026-01-01",
    term="30 days before signing",
    claimed_deadline="2026-01-31",
)

print(result.verified)           # False
print(result.computed_deadline)  # None
print(result.message)
# ⚠️ UNVERIFIABLE: Term '30 days before signing' uses directional wording
# (e.g. 'before', 'prior to', 'ahead of') that measures the period backward
# or against a reference the signing-date computation does not apply. Supply
# a term measured forward from the signing date (e.g. '30 days',
# '30 days from signing'), or provide the anchor event's date.

result = guard.verify(
    signing_date="2026-01-01",
    term="30 days after receipt of notice",
    claimed_deadline="2026-01-31",
)

print(result.verified)           # False
print(result.computed_deadline)  # None
print(result.message)
# ⚠️ UNVERIFIABLE: Term '30 days after receipt of notice' is anchored to an
# event ('receipt'), not to the signing date. The real deadline is unknowable
# from these inputs — supply the anchor event's date.

# Contract: "Payment is due 30 days after closing." Closing occurred on 2026-03-02.
result = guard.verify(
    signing_date="2026-03-02",   # confirmed closing date
    term="30 days",              # rewritten from "30 days after closing"
    claimed_deadline="2026-04-01",
)
print(result.verified)  # True

result = guard.verify(
    signing_date="2026-01-01",
    term="30 days",
    claimed_deadline="2026-01-31 17:00",
)
print(result.verified)  # True: same calendar date as the computed deadline

from qwed_legal import DeadlineGuard

guard = DeadlineGuard(country="US")

result = guard.verify(
    signing_date="2026-01-01",
    term="within a reasonable period",
    claimed_deadline="2026-01-31",
)

print(result.verified)           # False
print(result.is_computable)      # False
print(result.computed_deadline)  # None
print(result.difference_days)    # None
print(result.message)
# ⚠️ UNVERIFIABLE: Term 'within a reasonable period' does not contain a
# provable time quantity and unit. Cannot compute a deterministic deadline.
# Ambiguous legal language (e.g., 'reasonable period', 'promptly') requires
# human legal interpretation.

guard = DeadlineGuard(country="US")

business_days = guard.calculate_business_days_between(
    start_date="2026-01-15",
    end_date="2026-02-14"
)

print(business_days)  # Number of business days excluding weekends and holidays

from qwed_legal import LiabilityGuard

guard = LiabilityGuard()

result = guard.verify_cap(
    contract_value=5_000_000,
    cap_percentage=200,
    claimed_cap=15_000_000
)

print(result.verified)      # False
print(result.computed_cap)  # 10,000,000
print(result.difference)    # 5,000,000

import math
from qwed_legal import LiabilityGuard

guard = LiabilityGuard()

result = guard.verify_cap(
    contract_value=math.inf,
    cap_percentage=200,
    claimed_cap=15_000_000,
)

print(result.verified)      # False
print(result.computed_cap)  # None
print(result.difference)    # None
print(result.message)       # "⚠️ UNVERIFIABLE: ..."

if not result.verified:
    # Fail-closed gate: reject this input / route to human review.
    # ValueError (catchable per-request), not SystemExit (kills the host).
    # Never reach computed_cap / difference here (they are None).
    raise ValueError(result.message)

# Tiered liability
result = guard.verify_tiered_liability(
    tiers=[
        {"base": 1_000_000, "percentage": 100},
        {"base": 500_000, "percentage": 50},
    ],
    claimed_total=1_250_000  # ✅ Correct: 1M + 250K
)

# Indemnity limit (3x annual fee)
result = guard.verify_indemnity_limit(
    annual_fee=100_000,
    multiplier=3,
    claimed_limit=300_000  # ✅ Correct
)

from qwed_legal import ClauseGuard

guard = ClauseGuard()

result = guard.check_consistency([
    "Seller may terminate with 30 days notice",
    "Neither party may terminate before 90 days",
    "Seller may terminate immediately upon breach"
])

print(result.consistent)  # False
print(result.conflicts)
# [(0, 1, "Termination notice (30 days) conflicts with minimum term (90 days)")]

result = guard.check_consistency([])

if not result.consistent:
    # Fail-closed gate: reject this input / route to human review.
    # ValueError (catchable per-request), not SystemExit (kills the host).
    raise ValueError(result.message)

from z3 import Bool, Implies, Not
from qwed_legal import ClauseGuard

guard = ClauseGuard()

can_terminate_early = Bool("can_terminate_early")
min_term_satisfied = Bool("min_term_satisfied")

result = guard.verify_using_z3([
    Implies(can_terminate_early, Not(min_term_satisfied)),
    can_terminate_early,
    min_term_satisfied,
])

print(result.consistent)  # False - constraints are unsatisfiable
print(result.message)     # "CONTRADICTION: Provided Z3 constraints are unsatisfiable..."

from qwed_legal import CitationGuard

guard = CitationGuard()

# Valid format
result = guard.verify("Brown v. Board of Education, 347 U.S. 483 (1954)")
print(result.format_valid)  # True
print(result.status)        # "unverifiable_authority" - format ok, authority unknown
print(result.verified)      # False - authority is never proven by format
print(result.parsed_components)
# {'volume': 347, 'reporter': 'U.S.', 'page': '483'}

# Invalid format (fake reporter)
result = guard.verify("Smith v. Jones, 999 FAKE 123 (2020)")
print(result.format_valid)  # False
print(result.status)        # "format_invalid"
print(result.issues)        # ["Unknown reporter"]

result = guard.verify_batch([
    "Brown v. Board, 347 U.S. 483 (1954)",
    "Fake v. Case, 999 X.Y.Z. 123",
])

print(result.total)    # 2
print(result.valid)    # 1
print(result.invalid)  # 1

result = guard.check_statute_citation("42 U.S.C. § 1983")
print(result.format_valid)  # True (format only — not proof the statute exists or applies)
print(result.parsed_components)
# {'title': 42, 'code': 'U.S.C.', 'section': '1983'}

guard.check_statute_citation("12 U.S.C. § 2605")  # format_valid=True
guard.check_statute_citation("12 U.S.C. 2605")    # format_valid=True

from qwed_legal import JurisdictionGuard

guard = JurisdictionGuard()

result = guard.verify_choice_of_law(
    parties_countries=["US", "UK"],
    governing_law="Delaware",
    forum="London",
    contract_type="services",
)

print(result.verified)   # False - mismatch detected
print(result.conflicts)  # ["Governing law 'Delaware' (US state) but forum 'London' is non-US..."]

from qwed_legal import JurisdictionGuard

guard = JurisdictionGuard()

# Goods: CISG warning
result = guard.verify_choice_of_law(
    parties_countries=["US", "DE"],
    governing_law="Delaware",
    contract_type="sale-of-goods",
)
print(result.warnings)
# [..., "International sale of goods may be subject to CISG unless expressly excluded.", ...]

# Declared services: no CISG warning
result = guard.verify_choice_of_law(
    parties_countries=["US", "DE"],
    governing_law="Delaware",
    contract_type="services",
)

# Missing classification: partial-coverage warning, not verified
result = guard.verify_choice_of_law(
    parties_countries=["US", "DE"],
    governing_law="Delaware",
)
print(result.verified)  # False
# "Contract classification absent or unrecognized (None): CISG
#  convention-applicability was not evaluated, so cross-border coverage
#  is partial for this contract."

import { JurisdictionVerifier } from '@qwed-ai/legal';

const jurisdiction = new JurisdictionVerifier();

try {
  // Pass undefined for forum to set only the contract type
  const result = await jurisdiction.verifyChoiceOfLaw(
      ['US', 'DE'],
      'Delaware',
      undefined,
      'sale-of-goods'
  );

  console.log(result.contractType);           // "sale-of-goods"
  console.log(result.contractClassification); // "goods"
  console.log(result.warnings);               // [..., "International sale of goods may be subject to CISG unless expressly excluded.", ...]
} catch (err) {
  console.error('Choice-of-law verification failed:', err);
}

result = guard.verify_forum_selection(
    forum="Delaware",
    contract_value=50_000,
    parties_countries=["US", "DE"]
)

print(result.verified)   # True
print(result.warnings)   # ["Contract value $50,000 may not meet diversity jurisdiction threshold..."]

result = guard.check_convention_applicability(
    parties_countries=["US", "DE"],
    convention="CISG"
)
print(result.verified)  # True - both are CISG members

from qwed_legal import StatuteOfLimitationsGuard

guard = StatuteOfLimitationsGuard()

result = guard.verify(
    claim_type="breach_of_contract",
    jurisdiction="California",
    incident_date="2020-01-15",
    filing_date="2026-06-01"
)

print(result.verified)          # False - claim not supplied, so verified is False by contract
print(result.expiration_date)   # 2024-01-15
print(result.days_remaining)    # -867 (negative = expired)

# On 0.5.0+, result.status == "COMPUTED_ONLY" here
# (period computed, no claim to verify against). On 0.4.0 and earlier
# there is no status field — gate on verified instead.

result = guard.verify(
    claim_type="breach_of_contract",
    jurisdiction="California",
    incident_date="2020-06-01",
    filing_date="2019-01-15",  # before the incident
)

print(result.status)     # "UNVERIFIABLE"
print(result.verified)   # False
print(result.message)    # "⚠️ UNVERIFIABLE: Filing timestamp ... precedes incident timestamp ..."

if not result.verified:
    # Fail-closed gate: reject this input / route to human review.
    # ValueError (catchable per-request), not SystemExit (kills the host).
    raise ValueError(result.message)

result = guard.verify(
    claim_type="breach_of_contract",
    jurisdiction="California",
    incident_date="03/04/2022",
    filing_date="2026-01-15",
)

# Before: read as March 4, 2022, and returned COMPUTED_ONLY.
# After:
print(result.status)         # "UNVERIFIABLE"
print(result.incident_date)  # None
print(result.message)
# ⚠️ UNVERIFIABLE: incident_date is order-ambiguous (reads differently
# month-first vs day-first). Supply an ISO year-leading date (YYYY-MM-DD)
# or an unambiguous written date.

result = guard.verify(
    claim_type="breach_of_contract",
    jurisdiction="Mars",
    incident_date="2020-01-15",
    filing_date="2026-06-01"
)

print(result.verified)              # False
print(result.jurisdiction_matched)  # False
print(result.limitation_period_years)  # None
print(result.message)
# ⚠️ UNVERIFIABLE: Jurisdiction 'Mars' is not in the supported jurisdiction list.
# Cannot determine applicable statute of limitations. Supported: AUSTRALIA, CALIFORNIA, ...

result = guard.verify(
    claim_type="breach_of_contract",
    jurisdiction="Atlantis",
    incident_date="2023-01-15",
    filing_date="2026-06-01",
)

print(result.verified)              # False
print(result.jurisdiction_matched)  # False
print(result.claim_type_matched)    # False
print(result.limitation_period_years)  # None
print(result.expiration_date)       # None
print(result.message)
# ⚠️ UNVERIFIABLE: Jurisdiction 'Atlantis' is not in the supported
# jurisdiction list. Cannot determine applicable statute of limitations.
# Supported: AUSTRALIA, CALIFORNIA, CANADA, DELAWARE, FLORIDA, FRANCE,
# GERMANY, ILLINOIS, INDIA, NEW YORK, TEXAS, UK.

result = guard.verify(
    claim_type="cybersquatting",
    jurisdiction="California",
    incident_date="2023-01-15",
    filing_date="2026-06-01",
)

print(result.jurisdiction_matched)  # True
print(result.claim_type_matched)    # False
# Message lists the supported claim types for California.

years = guard.get_limitation_period("fraud", "Germany")
print(years)  # 10.0

unknown = guard.get_limitation_period("fraud", "Atlantis")
print(unknown)  # None

unsupported_claim = guard.get_limitation_period("cybersquatting", "California")
print(unsupported_claim)  # None

comparison = guard.compare_jurisdictions(
    "breach_of_contract",
    ["California", "New York", "Delaware", "Atlantis"]
)
# {'California': 4.0, 'New York': 6.0, 'Delaware': 3.0, 'Atlantis': None}

from qwed_legal import IRACGuard

guard = IRACGuard()

llm_output = """
Issue: Whether the defendant breached the employment contract.
Rule: Under California Labor Code § 2922, employment is presumed at-will.
Application: The defendant terminated employment without the 30-day notice 
required by the contract, which modified the at-will presumption.
Conclusion: The defendant breached the employment contract.
"""

result = guard.verify_structure(llm_output)

print(result["structure_valid"])  # True - all four IRAC sections present and coherent
print(result["status"])           # "unverifiable_reasoning"
print(result["verified"])         # False - reasoning correctness is never proven
print(result["components"])       # {'issue': '...', 'rule': '...', 'application': '...', 'conclusion': '...'}

result = guard.verify_structure("The defendant should pay damages.")

print(result["verified"])         # False
print(result["status"])           # "structure_invalid"
print(result["structure_valid"])  # False
print(result["error"])
# "STRUCTURE INVALID: Missing IRAC section(s): issue, rule, application,
#  conclusion. Legal analysis must contain Issue, Rule, Application, and Conclusion."
print(result["missing"])          # ['issue', 'rule', 'application', 'conclusion']

from qwed_legal import FairnessGuard

# Requires an LLM client for counterfactual generation
guard = FairnessGuard(llm_client=my_llm)

result = guard.verify_decision_fairness(
    original_prompt="Should John Smith receive parole given his rehabilitation record?",
    original_decision="Parole recommended based on positive rehabilitation.",
    protected_attribute_swap={"John": "Jane", "his": "her"},
)

print(result["verified"])  # Always False — fairness is never "proven"
print(result["status"])    # "UNVERIFIABLE_FAIRNESS"
print(result.get("risk"))  # "HEURISTIC_BIAS_SIGNAL" when outcomes differ

from qwed_legal import ContradictionGuard, Clause

guard = ContradictionGuard()

clauses = [
    Clause(id="1", text="Liability capped at 10000", category="LIABILITY", value=10000),
    Clause(id="2", text="Penalty shall be 50000", category="LIABILITY", value=50000),
]

result = guard.verify_consistency(clauses)

print(result["verified"])  # False
print(result["message"])   # "❌ LOGIC CONTRADICTION: Clauses are mutually exclusive..."

from qwed_legal import ProvenanceGuard

guard = ProvenanceGuard(
    require_disclosure=True,
    require_human_review=False,
    allowed_models=["gpt-4", "claude-3-opus"]
)

content = "This AI-generated document reviews the contract terms..."
provenance = {
    "content_hash": "a1b2c3...",  # SHA-256 of content
    "model_id": "gpt-4",
    "generation_timestamp": "2026-03-24T12:00:00+00:00",
}

result = guard.verify_provenance(content, provenance)

print(result["verified"])        # True or False
print(result["assurance"])       # "SELF_DECLARED" — every result carries this
print(result["checks_passed"])   # ["metadata_completeness", "hash_integrity", ...]
print(result["checks_failed"])   # []
print(result["risk"])            # "" if verified, e.g. "CONTENT_TAMPERED" if not

result = guard.verify_provenance(content, {
    "content_hash": None,
    "model_id": 0,
    "generation_timestamp": "  ",
})
print(result["verified"])       # False
print(result["checks_failed"])  # ["metadata_completeness", "hash_integrity_skipped", "timestamp_valid_skipped", "model_allowed_skipped"]
print(result["risk"])           # "INCOMPLETE_PROVENANCE"

from qwed_legal import ProvenanceGuard

guard = ProvenanceGuard()

record = guard.generate_provenance(
    content="This AI-generated contract summary...",
    model_id="gpt-4",
    disclosure_text="This document was generated by AI.",
    human_reviewed=True,
    reviewer_id="lawyer-42"
)

print(record.content_hash)           # SHA-256 hash
print(record.generation_timestamp)   # ISO-8601 UTC timestamp
print(record.human_reviewed)         # True

from qwed_legal import SACProcessor

sac = SACProcessor(llm_client=my_llm)

# Your existing chunks
chunks = naive_split(contract_text)

# Augment with document fingerprint
augmented = sac.generate_sac_chunks(
    document_text=contract_text,
    chunks=chunks,
    document_id="NDA-2026-001"
)

# Each chunk now includes global context
print(augmented[0])
# DOCUMENT CONTEXT [NDA-2026-001] (deterministic hash: 3f9c…) [AI-GENERATED SUMMARY — UNTRUSTED CONTENT]: NDA between Acme Corp and Beta Inc...
# CHUNK CONTENT [1/10]: Original chunk text here...

from qwed_legal import LegalGuard

# Optional: provide llm_client for FairnessGuard
guard = LegalGuard(
    llm_client=my_llm,
    provenance_config={
        "require_disclosure": True,
        "require_human_review": False,
        "allowed_models": ["gpt-4", "claude-3-opus"],
    }
)

# All 10 guards available
guard.verify_deadline(...)
guard.verify_liability_cap(...)
guard.check_clause_consistency(...)          # ClauseGuard (text heuristics)
guard.verify_citation(...)
guard.verify_jurisdiction(...)
guard.verify_statute_of_limitations(...)
guard.verify_irac_structure(...)             # v0.3.0
guard.verify_fairness(...)                   # v0.3.0 (requires llm_client)
guard.verify_contradiction(...)              # v0.3.0 (Z3 SMT Solver)
guard.verify_provenance(content, provenance) # NEW in v0.4.0