Fix live gaps: auditor copy, direct Ask answers, Ask metadata UI, audit tax detection

- Landing/Auth/Overview copy -> evidence-backed finance auditor positioning
(index.html title+meta, AuthScreen, Overview hero eyebrow/body/footer).
- New extractors.py: deterministic regex extraction of common finance fields
(total, due date, terms, tax, invoice no, late fee, overdue, uptime). Ask now
returns a crisp grounded answer ("The total amount due is $2,413.98.") and falls
back to focused-span extraction; values are verbatim, citations unchanged.
- Ask metadata panel (question type, evidence, confidence, retrieved/cited,
latency) rendered below each answer.
- Audit: detect structured fields via the same extractors and fuzzy clauses via
keyword scan instead of the retrieval gate -- fixes "No tax / VAT found" on
"Tax (8.25%) $183.98" and a parallel false-negative on the contract liability
clause. Audit is now fully deterministic.

Backwards compatible (Ask, audit, evaluate, auth, scoping unchanged in shape).
Verified: 59 backend tests pass, frontend builds, evaluate 7/7.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

backend/app/answering.py

@@ -13,7 +13,7 @@ import logging
 import time
 from typing import List, Optional, Set, Tuple
 
-from . import config, embeddings, llm, reranking
+from . import config, embeddings, extractors, llm, reranking
 from .models import Chunk
 from .retrieval import ScoredChunk, hybrid_rank, rank_chunks, tokenize
 from .schemas import Citation
@@ -286,7 +286,11 @@ def answer_question(question: str, chunks: List[Chunk], mode: str = "fast"):
         # No key / call failed -> transparently fall back to the fast engine.
         logger.info("Thinking unavailable; using fast (extractive) for: %s", question)
 
-    answer = _focused_answer(question, [s.chunk for s in relevant])
+    # Prefer a crisp, grounded direct answer for common finance questions
+    # ("The total amount due is $2,413.98."), extracted verbatim from the retrieved
+    # chunks; fall back to the focused span when no pattern matches.
+    direct = extractors.extract_direct_answer(question, [s.chunk.text for s in relevant])
+    answer = direct or _focused_answer(question, [s.chunk for s in relevant])
     metadata = _build_metadata(
         question_type=question_type,
         evidence_status="supported",

backend/app/audit.py

@@ -1,26 +1,26 @@
 """Evidence-backed document audit.
 
 Runs a finance-specific checklist over a document and reports, per check, either
-the cited value the document supports or that the field is missing. It reuses the
-SAME retrieval + abstention gate as ``/ask`` (``answer_question``) to FIND
-candidate evidence, then applies a field-specific discriminator before calling a
-check "supported": the cited excerpt must actually contain one of the field's
-keywords (e.g. a "tax"/"vat" token for the tax check, a "due date"/"payment due"
-phrase for the due-date check). Without that second gate, the generic /ask
-coverage rule (any two query words overlapping anywhere) would mark a field
-"present" off incidental words like "Sales"/"Charged" — a false positive that
-would wrongly lower the audit's risk level. So a check passes only when the
-document genuinely supports the field, and the audit never invents a value.
-
-This is intentionally simple and deterministic: no new model, no LLM required.
+the cited value the document supports or that the field is missing. Two grounded
+detection strategies (neither invents a value):
+
+  * Structured fields (totals, due dates, terms, tax, invoice numbers, late fees,
+    overdue days) are detected by deterministic regex extractors over the document
+    chunks — precise, and finds a value even where the generic /ask retrieval gate
+    would abstain (e.g. a lone "Tax (8.25%) $183.98" line, the live bug this fixes).
+  * Fuzzy clauses (termination, liability, renewal, governing law, parties) have no
+    clean regex, so they are detected by scanning the chunks for the clause's
+    discriminator keywords and citing the surrounding text.
+
+Both paths are deterministic (no model, no retrieval gate). A check that finds
+nothing is an *unsupported* finding; a missing critical field drives the risk.
 """
 import logging
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import List, Optional, Tuple
 
-from .answering import _focused_span, answer_question
+from . import extractors
 from .models import Chunk
-from .retrieval import tokenize
 from .schemas import AuditMetrics, AuditResponse, Citation, Finding
 
 logger = logging.getLogger(__name__)
@@ -30,63 +30,47 @@ logger = logging.getLogger(__name__)
 class _Check:
     type: str  # finding type key (stable id for the UI)
     label: str  # human-readable field name (used in claims/summary)
-    query: str  # question used to retrieve candidate evidence via answer_question
+    query: str  # short description of what the check looks for
     severity: str  # severity to assign WHEN THE FIELD IS MISSING (low/medium/high)
-    keywords: Tuple[str, ...]  # ≥1 must appear in the cited excerpt to count as present
+    extractor: Optional[str] = None  # regex extractor key (structured fields)
+    keywords: Tuple[str, ...] = field(default_factory=tuple)  # discriminators (fuzzy clauses)
 
 
-# Checklists per audit type. `keywords` are the field's discriminators: distinctive
-# (often multi-word) phrases that genuinely indicate the field is present, so an
-# incidental overlap of generic query words can't pass the check. Matching is
-# case-insensitive substring on the cited excerpt.
+# Checklists per audit type. Structured fields set `extractor`; fuzzy clauses set
+# `keywords` (distinctive phrases whose presence indicates the clause).
 _CHECKLISTS = {
     "invoice": [
-        _Check("total_amount", "total amount due", "What is the total amount due?", "high",
-               ("total", "amount due", "balance due", "grand total", "amount payable")),
-        _Check("due_date", "due date", "What is the payment due date?", "high",
-               ("due date", "payment due", "due by", "due on", "pay by", "payable by")),
-        _Check("payment_terms", "payment terms", "What are the payment terms, e.g. net 30?", "medium",
-               ("net ", "payment term", "terms net", "due within", "payable within")),
-        _Check("invoice_number", "invoice number", "What is the invoice number?", "low",
-               ("invoice number", "invoice no", "invoice #", "inv-", "invoice id")),
-        _Check("late_fee", "late fee", "What is the late fee or penalty for overdue payment?", "low",
-               ("late fee", "late payment", "late charge", "overdue", "penalty", "per month", "per annum")),
-        _Check("tax", "tax / VAT", "What sales tax or VAT percentage is charged?", "low",
-               ("tax", "vat", "gst")),
+        _Check("total_amount", "total amount due", "total amount due", "high", extractor="total_amount"),
+        _Check("due_date", "due date", "payment due date", "high", extractor="due_date"),
+        _Check("payment_terms", "payment terms", "payment terms", "medium", extractor="payment_terms"),
+        _Check("invoice_number", "invoice number", "invoice number", "low", extractor="invoice_number"),
+        _Check("late_fee", "late fee", "late fee for overdue payment", "low", extractor="late_fee"),
+        _Check("tax", "tax / VAT", "sales tax or VAT", "low", extractor="tax"),
     ],
     "contract": [
-        _Check("payment_terms", "payment terms", "What are the payment terms?", "high",
-               ("net ", "payment term", "payable within", "due within", "paid within")),
-        _Check("termination", "termination clause", "What is the termination clause or notice period?", "medium",
-               ("terminat", "notice period", "days' notice", "days notice", "may cancel", "for cause")),
-        _Check("liability", "liability clause", "What is the liability, penalty, or indemnification clause?", "medium",
-               ("liabilit", "indemnif", "indemnit", "damages", "limitation of")),
-        _Check("renewal", "renewal terms", "Is there an automatic renewal or renewal term?", "medium",
-               ("renew", "auto-renew", "automatic renewal", "renewal term")),
-        _Check("governing_law", "governing law", "What is the governing law or jurisdiction?", "low",
-               ("governing law", "jurisdiction", "governed by", "laws of", "venue")),
-        _Check("late_fee", "late fee", "What interest or late fee applies to overdue amounts?", "low",
-               ("late fee", "late charge", "overdue", "per annum", "per month", "interest on")),
+        _Check("payment_terms", "payment terms", "payment terms", "high", extractor="payment_terms"),
+        _Check("termination", "termination clause", "termination clause or notice period", "medium",
+               keywords=("terminat", "notice period", "days' notice", "days notice", "may cancel", "for cause")),
+        _Check("liability", "liability clause", "liability or indemnification clause", "medium",
+               keywords=("liabilit", "indemnif", "indemnit", "limitation of")),
+        _Check("renewal", "renewal terms", "automatic renewal or renewal term", "medium",
+               keywords=("renew", "auto-renew", "automatic renewal", "renewal term")),
+        _Check("governing_law", "governing law", "governing law or jurisdiction", "low",
+               keywords=("governing law", "jurisdiction", "governed by", "laws of", "venue")),
+        _Check("late_fee", "late fee", "interest or late fee on overdue amounts", "low", extractor="late_fee"),
     ],
     "payment_note": [
-        _Check("amount", "payment amount", "What is the payment amount or outstanding balance?", "high",
-               ("amount", "balance", "outstanding", "total due", "owing")),
-        _Check("due_date", "due date", "What is the payment due date?", "high",
-               ("due date", "payment due", "due by", "due on", "pay by")),
-        _Check("overdue", "overdue status", "Is the payment overdue, and by how many days?", "medium",
-               ("overdue", "past due", "days late", "days overdue", "arrears")),
-        _Check("reference", "reference number", "What is the invoice or reference number?", "low",
-               ("reference", "ref ", "ref:", "ref.", "invoice no", "invoice number", "inv-")),
+        _Check("amount", "outstanding amount", "outstanding balance", "high", extractor="amount"),
+        _Check("due_date", "due date", "payment due date", "high", extractor="due_date"),
+        _Check("overdue", "overdue status", "days overdue", "medium", extractor="overdue"),
+        _Check("reference", "reference number", "invoice or reference number", "low", extractor="reference"),
     ],
     "general": [
-        _Check("total_amount", "amount", "What is the total amount or balance?", "medium",
-               ("total", "amount", "balance", "subtotal")),
-        _Check("date", "key date", "What is the due date or other key date?", "medium",
-               ("date", "deadline", "due")),
-        _Check("payment_terms", "payment terms", "What are the payment terms?", "low",
-               ("net ", "payment term", "terms")),
-        _Check("parties", "parties", "Who are the parties, vendor, or customer involved?", "low",
-               ("vendor", "customer", "client", "bill to", "sold to", "supplier", "between")),
+        _Check("total_amount", "amount", "total amount or balance", "medium", extractor="total_amount"),
+        _Check("date", "key date", "due date or key date", "medium", extractor="date"),
+        _Check("payment_terms", "payment terms", "payment terms", "low", extractor="payment_terms"),
+        _Check("parties", "parties", "parties, vendor, or customer", "low",
+               keywords=("vendor", "customer", "client", "bill to", "sold to", "supplier", "between")),
     ],
 }
 
@@ -95,63 +79,84 @@ def checklist_for(audit_type: str) -> List[_Check]:
     return _CHECKLISTS.get(audit_type) or _CHECKLISTS["general"]
 
 
-def _supporting_citation(
-    keywords: Tuple[str, ...], citations: List[Citation]
-) -> Optional[Citation]:
-    """The first cited excerpt that actually contains one of the field's
-    discriminators, or None — i.e. the field really appears in the evidence."""
-    for c in citations:
-        low = c.excerpt.lower()
-        if any(kw.strip() and kw in low for kw in keywords):
-            return c
+def _excerpt_around(text: str, pos: int, length: int, pad: Tuple[int, int] = (55, 95)) -> str:
+    """A readable, ellipsised window of `text` around [pos, pos+length)."""
+    s, e = max(0, pos - pad[0]), min(len(text), pos + length + pad[1])
+    return ("…" if s > 0 else "") + text[s:e].strip() + ("…" if e < len(text) else "")
+
+
+def _citation(chunk: Chunk, excerpt: str, match_text: str) -> Citation:
+    return Citation(
+        document_id=chunk.document_id,
+        document_name=chunk.document.filename if chunk.document else "unknown",
+        chunk_index=chunk.chunk_index,
+        page=chunk.page,
+        excerpt=excerpt,
+        score=1.0,  # exact match -> full confidence
+        match_text=match_text,
+    )
+
+
+def _citation_for_span(chunk: Chunk, span: str) -> Citation:
+    """Citation around a verbatim regex-matched span within a chunk."""
+    pos = chunk.text.lower().find(span.lower())
+    excerpt = span if pos < 0 else _excerpt_around(chunk.text, pos, len(span), pad=(50, 50))
+    return _citation(chunk, excerpt, span)
+
+
+def _find_clause(keywords: Tuple[str, ...], chunks: List[Chunk]):
+    """First (chunk, position, keyword_len) where a discriminator keyword appears."""
+    for c in chunks:
+        low = c.text.lower()
+        for kw in keywords:
+            k = kw.strip().lower()
+            if k:
+                pos = low.find(k)
+                if pos != -1:
+                    return c, pos, len(k)
     return None
 
 
-def _claim_span(keywords: Tuple[str, ...], excerpt: str, fallback: str) -> str:
-    """A verbatim window of the excerpt centered on the field's discriminator, so
-    the shown value is the field's region (not a dense overlap of generic words).
-    Nothing is generated."""
-    low = excerpt.lower()
-    hit = next((kw for kw in keywords if kw.strip() and kw in low), None)
-    span = _focused_span(set(tokenize(hit)), excerpt, window_words=14) if hit else None
-    if span and span[1].strip():
-        return span[1].strip()
-    return (fallback or excerpt).strip()
+def _supported(type_: str, claim: str, evidence: str, citation: Citation) -> Finding:
+    return Finding(type=type_, severity="low", claim=claim, evidence=evidence, citation=citation)
+
+
+def _missing(chk: _Check) -> Finding:
+    return Finding(
+        type=chk.type,
+        severity=chk.severity,
+        claim=f"No {chk.label} found in the document.",
+        evidence="",
+        citation=None,
+    )
 
 
 def run_audit(audit_type: str, document_name: str, chunks: List[Chunk]) -> AuditResponse:
-    """Run the checklist for ``audit_type`` over ``chunks`` and return the audit.
-
-    For each check we retrieve candidate evidence via ``answer_question`` and then
-    require the cited excerpt to contain the field's discriminator. Only then is
-    the finding SUPPORTED (with the cited value + citation); otherwise the field
-    is flagged unsupported (no citation) and takes the check's severity — a missing
-    critical field drives the risk level.
-    """
+    """Run the checklist for ``audit_type`` over ``chunks`` and return the audit."""
     findings: List[Finding] = []
+    chunk_texts = [c.text for c in chunks]
+
     for chk in checklist_for(audit_type):
-        answer, abstained, _mode, citations, _meta = answer_question(chk.query, chunks, "fast")
-        cite = None if abstained else _supporting_citation(chk.keywords, citations)
-        if cite is not None:
-            findings.append(
-                Finding(
-                    type=chk.type,
-                    severity="low",  # present and cited -> verified, lowest concern
-                    claim=_claim_span(chk.keywords, cite.excerpt, answer),
-                    evidence=cite.excerpt,
-                    citation=cite,
-                )
-            )
+        if chk.extractor:
+            # Structured field: deterministic regex over the document chunks.
+            hit = extractors.find_field(chk.extractor, chunk_texts)
+            if hit is not None:
+                idx, span, _answer = hit
+                cite = _citation_for_span(chunks[idx], span)
+                findings.append(_supported(chk.type, span, cite.excerpt, cite))
+            else:
+                findings.append(_missing(chk))
         else:
-            findings.append(
-                Finding(
-                    type=chk.type,
-                    severity=chk.severity,  # missing field -> risk by importance
-                    claim=f"No {chk.label} found in the document.",
-                    evidence="",
-                    citation=None,
-                )
-            )
+            # Fuzzy clause: scan the chunks for a discriminator keyword and cite
+            # the surrounding text (no retrieval gate, so no false-negative abstain).
+            found = _find_clause(chk.keywords, chunks)
+            if found is not None:
+                chunk, pos, klen = found
+                excerpt = _excerpt_around(chunk.text, pos, klen)
+                cite = _citation(chunk, excerpt, chunk.text[pos : pos + klen])
+                findings.append(_supported(chk.type, excerpt, excerpt, cite))
+            else:
+                findings.append(_missing(chk))
 
     supported = [f for f in findings if f.citation is not None]
     unsupported = [f for f in findings if f.citation is None]

backend/app/extractors.py

@@ -0,0 +1,168 @@
+"""Deterministic, regex-based extraction of common finance fields.
+
+Used in two grounded places (never invents — every value is copied verbatim from
+the supplied text, we only wrap it in a sentence):
+
+  * /ask  — turn a long grounded span into a crisp direct answer
+            ("The total amount due is $2,413.98.") for common finance questions,
+            falling back to the existing focused-span answer when nothing matches.
+  * /audit — detect a field and its verbatim value even when the generic
+             retrieval gate would abstain (e.g. a lone "Tax (8.25%) $183.98"
+             line that shares too few query words to clear the /ask gate).
+
+Each extractor returns (verbatim_span, formatted_answer) or None.
+"""
+import re
+from dataclasses import dataclass
+from typing import Callable, List, Optional, Tuple
+
+Extracted = Tuple[str, str]  # (verbatim matched span, formatted direct answer)
+
+# A currency amount. Requires a leading "$" so a bare percentage or count can't be
+# mistaken for money (e.g. "Tax 8.25%" must NOT read as "$8.25"). Cents optional.
+_MONEY = r"\$\s?[\d,]+(?:\.\d{2})?"
+# A date like "April 2, 2025" / "April 2 2025" or "04/02/2025".
+_DATE = r"[A-Za-z]{3,9}\.?\s+\d{1,2},?\s+\d{2,4}|\d{1,2}[/\-.]\d{1,2}[/\-.]\d{2,4}"
+
+
+def _money(s: str) -> str:
+    s = s.strip()
+    return s if s.startswith("$") else "$" + s.lstrip("$ ")
+
+
+def _search(text: str, pattern: str):
+    return re.search(pattern, text, re.IGNORECASE)
+
+
+def _ex_total(text: str) -> Optional[Extracted]:
+    m = _search(text, rf"(?:total\s+amount\s+(?:due|payable)|balance\s+due|grand\s+total|total\s+(?:due|payable)|amount\s+due)\s*[:\-]?\s*({_MONEY})")
+    if not m:
+        return None
+    return m.group(0).strip(), f"The total amount due is {_money(m.group(1))}."
+
+
+def _ex_amount(text: str) -> Optional[Extracted]:
+    m = _search(text, rf"(?:amount\s+outstanding|outstanding\s+balance|balance\s+outstanding|amount\s+payable|outstanding)\s*[:\-]?\s*({_MONEY})")
+    if m:
+        return m.group(0).strip(), f"The amount outstanding is {_money(m.group(1))}."
+    return _ex_total(text)  # fall back to a stated total / amount due
+
+
+def _ex_tax(text: str) -> Optional[Extracted]:
+    # "Tax (8.25%) $183.98", "Sales Tax $183.98", "VAT $183.98". The % is optional
+    # and the dollar amount is required, so "exclusive of applicable taxes" (no $)
+    # does not register as a tax line.
+    m = _search(text, rf"(?:sales\s+tax|tax|vat|gst)\b\s*(\(\s*[\d.]+\s*%\s*\))?\s*[:\-]?\s*({_MONEY})")
+    if not m:
+        return None
+    pct = (m.group(1) or "").strip()
+    answer = f"The tax is {_money(m.group(2))}" + (f" {pct}." if pct else ".")
+    return m.group(0).strip(), answer
+
+
+def _ex_due_date(text: str) -> Optional[Extracted]:
+    m = _search(text, rf"(?:due\s+date|payment\s+due|due\s+by|pay\s+by|payable\s+by|due\s+on)\s*[:\-]?\s*({_DATE})")
+    if not m:
+        return None
+    return m.group(0).strip(), f"The invoice due date is {m.group(1).strip()}."
+
+
+def _ex_terms(text: str) -> Optional[Extracted]:
+    m = _search(text, r"\bnet\s+\d{1,3}\b")
+    if m:
+        terms = re.sub(r"net", "Net", m.group(0), flags=re.IGNORECASE)
+        return m.group(0).strip(), f"The payment terms are {terms}."
+    m = _search(text, r"(?:payable|due)\s+within\s+[\w()]+\s+days")
+    if m:
+        return m.group(0).strip(), f"The payment terms are {m.group(0).strip()}."
+    return None
+
+
+def _ex_invoice_no(text: str) -> Optional[Extracted]:
+    m = _search(text, r"(?:invoice\s+(?:number|no\.?|#|id)|reference)\s*[:\-]?\s*([A-Z]{2,}[-\d][A-Z0-9\-]*)")
+    if not m:
+        return None
+    return m.group(0).strip(), f"The invoice number is {m.group(1).strip()}."
+
+
+def _ex_late_fee(text: str) -> Optional[Extracted]:
+    m = _search(text, r"(?:late\s+(?:fee|payment|charge)|finance\s+charge|past\s+due)[^.]{0,45}?(\d+(?:\.\d+)?\s*%(?:\s*(?:per\s+month|per\s+annum|monthly|annually))?|\$[\d,]+(?:\.\d{2})?)")
+    if not m:
+        return None
+    return m.group(0).strip(), f"The late fee is {m.group(1).strip()}."
+
+
+def _ex_overdue(text: str) -> Optional[Extracted]:
+    m = _search(text, r"(\d{1,4})\s+days?\s+(?:overdue|past\s+due|late)")
+    if not m:
+        m = _search(text, r"days?\s+overdue\s*[:\-]?\s*(\d{1,4})")
+    if not m:
+        return None
+    return m.group(0).strip(), f"The payment is {m.group(1)} days overdue."
+
+
+def _ex_uptime(text: str) -> Optional[Extracted]:
+    m = _search(text, r"uptime\s+(?:of\s+|commitment\s+(?:of\s+)?|guarantee\s+(?:of\s+)?|is\s+)?(\d{1,3}(?:\.\d+)?\s*%)")
+    if not m:
+        m = _search(text, r"(\d{1,3}(?:\.\d+)?\s*%)\s+(?:monthly\s+)?uptime")
+    if not m:
+        return None
+    return m.group(0).strip(), f"The uptime commitment is {m.group(1).strip()}."
+
+
+@dataclass(frozen=True)
+class _Field:
+    key: str
+    triggers: Tuple[str, ...]  # question substrings that select this extractor
+    fn: Callable[[str], Optional[Extracted]]
+
+
+# Order matters: the first field whose trigger appears in the question wins, so
+# specific intents (total / invoice number / due date) precede broader ones.
+_FIELDS: List[_Field] = [
+    _Field("total_amount", ("total amount", "amount due", "balance due", "grand total", "total due", "how much do", "how much is"), _ex_total),
+    _Field("invoice_number", ("invoice number", "invoice no", "invoice #", "invoice id", "reference number"), _ex_invoice_no),
+    _Field("tax", ("tax", "vat", "gst"), _ex_tax),
+    _Field("due_date", ("due date", "due by", "when is", "when due", "payment due", "what date"), _ex_due_date),
+    _Field("payment_terms", ("payment term", "net terms", "credit terms"), _ex_terms),
+    _Field("late_fee", ("late fee", "late payment", "late charge", "finance charge", "penalty"), _ex_late_fee),
+    _Field("overdue", ("overdue", "days late", "past due", "how late"), _ex_overdue),
+    _Field("uptime", ("uptime", "availability", "service level", "sla"), _ex_uptime),
+]
+
+# Extractor lookup by field key (used by the audit, which knows the field up front).
+_BY_KEY: dict = {
+    "total_amount": _ex_total, "amount": _ex_amount, "due_date": _ex_due_date,
+    "date": _ex_due_date, "payment_terms": _ex_terms, "invoice_number": _ex_invoice_no,
+    "reference": _ex_invoice_no, "late_fee": _ex_late_fee, "tax": _ex_tax,
+    "overdue": _ex_overdue, "uptime": _ex_uptime,
+}
+
+
+def extract_direct_answer(question: str, texts: List[str]) -> Optional[str]:
+    """A crisp grounded answer for a common finance question, or None to let the
+    caller fall back to span extraction. Only the FIRST field whose trigger words
+    appear in the question is tried (across the retrieved texts, in order)."""
+    q = question.lower()
+    for fld in _FIELDS:
+        if any(t in q for t in fld.triggers):
+            for text in texts:
+                res = fld.fn(text)
+                if res:
+                    return res[1]
+            return None  # intent recognized but no value found -> fall back to span
+    return None
+
+
+def find_field(field_key: str, texts: List[str]) -> Optional[Tuple[int, str, str]]:
+    """For the audit: return (text_index, verbatim_span, formatted_answer) for the
+    first text whose extractor matches the field, or None if the field isn't found
+    (or has no extractor)."""
+    fn = _BY_KEY.get(field_key)
+    if fn is None:
+        return None
+    for i, text in enumerate(texts):
+        res = fn(text)
+        if res:
+            return i, res[0], res[1]
+    return None

backend/tests/test_audit.py

@@ -19,7 +19,7 @@ _INVOICE = (
 # date. The audit must NOT mark those fields supported off incidental overlaps.
 _TRAP_INVOICE = (
     b"Invoice INV-99. Sales representative John handled this order. "
-    b"Total Amount Due 5000 dollars. Charged to account 12 on file. "
+    b"Total Amount Due $5,000.00. Charged to account 12 on file. "
     b"Percentage discount none."
 )
 
@@ -121,6 +121,55 @@ def test_audit_on_missing_document_returns_404(client):
     assert res.status_code == 404
 
 
+def test_audit_detects_tax_in_sample_invoice(client):
+    # Regression for the live bug: sample_invoice.txt contains "Tax (8.25%) $183.98"
+    # but the audit reported "No tax found". The regex extractor must detect it.
+    client.post("/demo/seed")
+    inv = next(
+        d for d in client.get("/documents").json() if d["filename"] == "sample_invoice.txt"
+    )
+    body = client.post(
+        "/audit", json={"document_id": inv["id"], "audit_type": "invoice"}
+    ).json()
+    findings = _by_type(body["findings"])
+    tax = findings["tax"]
+    assert tax["citation"] is not None, tax
+    assert "183.98" in tax["claim"]
+    assert "8.25%" in (tax["claim"] + tax["evidence"])
+    # The real invoice also has a total, due date, terms, number, and late fee.
+    for key in ("total_amount", "due_date", "payment_terms", "invoice_number", "late_fee"):
+        assert findings[key]["citation"] is not None, findings[key]
+
+
+def test_ask_returns_direct_total_amount_answer(client):
+    # /ask must give a crisp grounded answer, not a long raw chunk.
+    client.post("/demo/seed")
+    inv = next(
+        d for d in client.get("/documents").json() if d["filename"] == "sample_invoice.txt"
+    )
+    res = client.post(
+        "/ask", json={"document_id": inv["id"], "question": "What is the total amount due?"}
+    ).json()
+    assert res["answer"] == "The total amount due is $2,413.98."
+    assert res["abstained"] is False
+    assert len(res["citations"]) >= 1  # citations unchanged
+
+
+def test_contract_audit_detects_fuzzy_clauses(client):
+    # The fuzzy (retrieval + discriminator) path still finds clause fields.
+    client.post("/demo/seed")
+    contract = next(
+        d for d in client.get("/documents").json()
+        if d["filename"] == "sample_vendor_contract.txt"
+    )
+    body = client.post(
+        "/audit", json={"document_id": contract["id"], "audit_type": "contract"}
+    ).json()
+    findings = _by_type(body["findings"])
+    for key in ("payment_terms", "termination", "liability", "governing_law"):
+        assert findings[key]["citation"] is not None, findings[key]
+
+
 def test_audit_cannot_access_another_users_document(client, second_client):
     # Per-user scoping: a different user must not be able to audit (or even learn
     # of) someone else's private document — it 404s, never 403/leaks.

frontend/index.html

@@ -6,9 +6,9 @@
     <meta name="theme-color" content="#fbfbfd" />
     <meta
       name="description"
-      content="FinanceFlow AI — source-backed AI assistant for business documents."
+      content="FinanceFlow AI — evidence-backed assistant for auditing invoices, contracts, and payment notes."
     />
-    <title>FinanceFlow AI — Source-backed document intelligence</title>
+    <title>FinanceFlow AI — Evidence-backed finance document auditor</title>
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link

frontend/src/components/views/Ask.jsx

@@ -268,6 +268,47 @@ export default function Ask({ documents, demoSignal, llmAvailable, onDemoConsume
               <p className={`answer-body ${result.abstained ? "dim" : ""}`}>
                 {result.answer}
               </p>
+              {result.metadata && (
+                <dl className="ask-meta">
+                  <div className="ask-meta-row">
+                    <dt className="ask-meta-k">Question type</dt>
+                    <dd className="ask-meta-v">
+                      {typeof result.metadata.question_type === "string"
+                        ? result.metadata.question_type.replace(/_/g, " ")
+                        : "—"}
+                    </dd>
+                  </div>
+                  <div className="ask-meta-row">
+                    <dt className="ask-meta-k">Evidence</dt>
+                    <dd className="ask-meta-v">
+                      {result.metadata.evidence_status ?? "—"}
+                    </dd>
+                  </div>
+                  <div className="ask-meta-row">
+                    <dt className="ask-meta-k">Confidence</dt>
+                    <dd className="ask-meta-v">
+                      {typeof result.metadata.confidence === "number"
+                        ? `${Math.round(result.metadata.confidence * 100)}%`
+                        : "—"}
+                    </dd>
+                  </div>
+                  <div className="ask-meta-row">
+                    <dt className="ask-meta-k">Retrieved / cited</dt>
+                    <dd className="ask-meta-v">
+                      {result.metadata.retrieved_chunks ?? "—"} /{" "}
+                      {result.metadata.cited_chunks ?? "—"}
+                    </dd>
+                  </div>
+                  <div className="ask-meta-row">
+                    <dt className="ask-meta-k">Latency</dt>
+                    <dd className="ask-meta-v">
+                      {typeof result.metadata.latency_ms === "number"
+                        ? `${result.metadata.latency_ms} ms`
+                        : "—"}
+                    </dd>
+                  </div>
+                </dl>
+              )}
               {result.requestedMode === "thinking" && result.mode === "fast" && (
                 <p className="seg-note" style={{ margin: "10px 0 0" }}>
                   Thinking was unavailable for this request — answered with Fast.

frontend/src/components/views/AuthScreen.jsx

@@ -132,8 +132,8 @@ export default function AuthScreen({
             Answers you can <span className="clip-light">prove.</span>
           </h1>
           <p className="auth-brand-sub">
-            Source-grounded document Q&amp;A — every answer cites the exact line, and
-            it abstains when the evidence isn’t there.
+            Audit invoices, contracts, and payment notes — every answer cites the
+            exact source, and it abstains when evidence is missing.
           </p>
           <ul className="auth-feat">
             <li>
@@ -159,7 +159,7 @@ export default function AuthScreen({
             </li>
           </ul>
         </div>
-        <p className="auth-brand-foot">Source-backed document intelligence.</p>
+        <p className="auth-brand-foot">Evidence-backed finance document intelligence.</p>
       </aside>
 
       {/* ---- Form panel ---- */}

frontend/src/components/views/Overview.jsx

@@ -98,15 +98,15 @@ export default function Overview({ documents, loading, reload, onTryDemo, seedin
       <section className="hero-stage">
         <div>
           <span className="hero-eyebrow">
-            <IconSpark size={14} /> Source-grounded answers
+            <IconSpark size={14} /> Audit-ready finance answers
           </span>
           <h1 className="hero-h1">
             Answers you can <span className="clip">prove.</span>
           </h1>
           <p className="hero-sub">
-            FinanceFlow reads your invoices, contracts, and payment notes and answers
-            questions <strong>only</strong> from what's in the document — with citations
-            you can verify. When the evidence isn't there, it says so instead of guessing.
+            FinanceFlow audits invoices, contracts, and payment notes for totals, due
+            dates, payment terms, late fees, and unsupported claims — with citations you
+            can verify. When the evidence isn't there, it says so instead of guessing.
           </p>
           <div className="hero-cta">
             <Button variant="primary" size="lg" loading={seeding} onClick={onTryDemo}>
@@ -325,7 +325,7 @@ export default function Overview({ documents, loading, reload, onTryDemo, seedin
           </span>
           FinanceFlow AI
         </span>
-        <span>Source-backed document intelligence.</span>
+        <span>Evidence-backed finance document intelligence.</span>
         <a href="https://github.com/aissugur/financeflow-ai" target="_blank" rel="noreferrer">
           GitHub ↗
         </a>

frontend/src/styles.css

@@ -670,6 +670,35 @@ code {
 .answer-body { font-size: 16px; line-height: 1.65; color: var(--text); max-width: 72ch; }
 .answer-body.dim { color: var(--text-dim); font-size: 15px; }
 
+/* Compact AI-evaluation / audit metadata under the answer body. Quiet by design. */
+.ask-meta {
+  margin: 16px 0 0;
+  padding-top: 14px;
+  border-top: 1px solid var(--border);
+  display: grid;
+  gap: 6px;
+  max-width: 72ch;
+}
+.ask-meta-row {
+  display: grid;
+  grid-template-columns: minmax(0, 9.5em) 1fr;
+  gap: 12px;
+  align-items: baseline;
+}
+.ask-meta-k {
+  font-size: var(--text-xs);
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  color: var(--text-faint);
+  margin: 0;
+}
+.ask-meta-v {
+  font-size: var(--text-sm);
+  color: var(--text-dim);
+  margin: 0;
+  font-variant-numeric: tabular-nums;
+}
+
 @keyframes reveal { from { opacity: 0; transform: translateY(10px); } to { opacity: 1; transform: none; } }
 
 /* ===================== Evidence panel ==================================== */