Initialize Jawbreaker hackathon scaffold

.gitignore

@@ -0,0 +1,16 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.venv/
+venv/
+.env
+.env.*
+models/
+*.gguf
+*.safetensors
+*.pt
+*.pth
+dist/
+build/
+.DS_Store
+

AGENT_TRACE.md

@@ -0,0 +1,18 @@
+# Agent Trace
+
+This project is being built with OpenAI Codex as the coding agent.
+
+## 2026-06-05
+
+- Read hackathon rules, kickoff notes, sponsor details, and peer review feedback.
+- Selected `Jawbreaker` as the product name.
+- Chose Backyard AI as the main track.
+- Established model bakeoff plan before committing to a default model.
+- Created initial project scaffold for a Gradio Space and public GitHub repo.
+
+Open questions:
+
+- Which model wins the latency/quality bakeoff?
+- Whether MiniCPM4-8B is strong enough to become central for OpenBMB eligibility.
+- Whether fine-tuning is worth the time after MVP stability.
+

FIELD_NOTES.md

@@ -0,0 +1,17 @@
+# Field Notes
+
+## 2026-06-05
+
+Kickoff confirmed the submission shape:
+
+- Gradio Space under the hackathon organization.
+- Demo video and social post proof belong in the Space README.
+- Public GitHub repo with Codex-attributed commits matters for the OpenAI Codex Track.
+- Sponsor prizes can depend on model or infrastructure choices.
+
+Jawbreaker is scoped for Backyard AI: one real person, one narrow safety task, one clear answer.
+
+Current risk: a generic scam detector will not stand out. The product must show a specific person being helped and a clear small-model fit.
+
+Current differentiator: Scam DNA, a visual breakdown of scam structure rather than a plain label.
+

README.md

@@ -0,0 +1,77 @@
+---
+title: Jawbreaker
+sdk: gradio
+sdk_version: 6.16.0
+app_file: app.py
+license: mit
+short_description: Local-first scam defense for someone you love.
+tags:
+  - gradio
+  - build-small-hackathon
+  - backyard-ai
+  - local-first
+  - llama-cpp
+---
+
+# Jawbreaker
+
+Scam defense for someone you love.
+
+Jawbreaker helps a real person pause before clicking, replying, or sending money. Paste a suspicious text, email, or DM and Jawbreaker breaks it into plain-English warning signs: what the sender is pretending to be, what pressure tactic is being used, what they want, and the safest next step.
+
+## Hackathon
+
+- Event: Hugging Face Build Small Hackathon
+- Track: Backyard AI
+- App: Gradio Space under `build-small-hackathon`
+- Status: In development
+- Demo video: To be added before submission
+- Social post: To be added before submission
+- Public GitHub repo: To be added after repo creation
+
+## Why This Is Small
+
+Jawbreaker is deliberately narrow. It does not try to be a general assistant or chatbot. It performs one safety task:
+
+1. Read one suspicious message.
+2. Identify scam risk and manipulation tactics.
+3. Give one clear safe action.
+4. Help the user ask someone they trust.
+
+## Model Plan
+
+The final app will use a local small model through `llama.cpp` / `llama-cpp-python`. Candidate models will be chosen by an eval bakeoff:
+
+- Qwen3-4B GGUF Q4_K_M
+- Qwen3-8B GGUF Q4_K_M
+- MiniCPM4-8B GGUF Q4_K_M
+
+Decision criteria:
+
+- valid JSON output
+- low false positives on legitimate messages
+- no dangerous scams labeled safe
+- safe recommended actions
+- short, clear explanations
+- acceptable latency for judges
+
+## Bonus Badges Targeted
+
+- Off the Grid: local model inference, no cloud APIs for scam analysis.
+- Llama Champion: model runs through the llama.cpp runtime.
+- Off-Brand: custom Gradio UI beyond the default look.
+- Well-Tuned: conditional; only if the MVP is stable early enough.
+- Sharing is Caring: Codex/agent trace published in this repo.
+- Field Notes: build report published before submission.
+
+## Sponsor Eligibility Notes
+
+- OpenAI Codex Track: public GitHub repo with Codex-attributed commits linked here.
+- OpenBMB Awards: possible if MiniCPM becomes the central model after bakeoff.
+- Modal Awards: possible if Modal is used for fine-tuning, evals, or deployment support and documented here.
+- NVIDIA Nemotron Quest: only if a NeMoTron model is used; currently not planned.
+
+## Safety Boundary
+
+Jawbreaker is not legal, financial, or cybersecurity advice. It is a local-first safety aid that helps non-experts slow down and verify suspicious messages. The safest action should never ask the user to click the suspicious link or call a number from the suspicious message.
+

SUBMISSION.md

@@ -0,0 +1,35 @@
+# Submission Checklist
+
+## Required
+
+- [ ] Gradio Space created under `build-small-hackathon`
+- [ ] Space made public before June 15, 2026
+- [ ] Demo video linked in Space README
+- [ ] Social post linked in Space README
+- [ ] Public GitHub repo linked in Space README
+- [ ] Repo includes Codex-attributed commits
+
+## Backyard AI Evidence
+
+- [ ] Real user identified
+- [ ] Real suspicious message collected with private details removed
+- [ ] User quote or reaction collected
+- [ ] Demo script shows the real-user story
+
+## Technical Evidence
+
+- [ ] Model name and parameter count documented
+- [ ] Eval set included
+- [ ] Bakeoff results documented
+- [ ] Local inference path documented
+- [ ] No cloud API path documented
+
+## Bonus Badges
+
+- [ ] Off the Grid
+- [ ] Llama Champion
+- [ ] Off-Brand
+- [ ] Well-Tuned
+- [ ] Sharing is Caring
+- [ ] Field Notes
+

app.py

@@ -0,0 +1,104 @@
+import gradio as gr
+
+from jawbreaker.render import render_analysis_html, render_memory_html
+from jawbreaker.schema import ScamAnalysis
+
+
+EXAMPLES = [
+    "USPS: Your package is held due to an unpaid fee. Verify now: http://usps-track-secure.example",
+    "Hi Grandma, I lost my phone. This is my new number. Can you send $800 for rent today? Please don't tell Mom.",
+    "Chase fraud alert: Did you attempt a $249.00 purchase at TARGET? Reply YES or NO.",
+]
+
+
+def analyze_message(message: str, memory: list[dict] | None) -> tuple[str, str, list[dict]]:
+    memory = memory or []
+    analysis = ScamAnalysis.from_heuristics(message, memory)
+    return render_analysis_html(message, analysis), render_memory_html(analysis, memory), memory
+
+
+def remember_current(message: str, memory: list[dict] | None) -> tuple[str, list[dict]]:
+    memory = memory or []
+    analysis = ScamAnalysis.from_heuristics(message, memory)
+    if not message.strip():
+        return "Paste a message first.", memory
+
+    memory.append(
+        {
+            "summary": analysis.summary,
+            "scam_type": analysis.scam_type,
+            "risk_level": analysis.risk_level,
+            "fingerprint": analysis.scam_dna,
+            "text": message[:240],
+        }
+    )
+    return "Saved this scam pattern for this session.", memory
+
+
+def build_app() -> gr.Blocks:
+    css = open("style.css", "r", encoding="utf-8").read()
+    theme = gr.themes.Soft(
+        primary_hue="red",
+        secondary_hue="slate",
+        neutral_hue="zinc",
+        radius_size="sm",
+    )
+
+    with gr.Blocks(title="Jawbreaker", theme=theme, css=css) as demo:
+        memory_state = gr.State([])
+
+        gr.HTML(
+            """
+            <section class="hero">
+              <div>
+                <p class="eyebrow">Backyard AI</p>
+                <h1>Jawbreaker</h1>
+                <p class="subtitle">Scam defense for someone you love.</p>
+              </div>
+              <div class="hero-badge">Local-first small-model app</div>
+            </section>
+            """
+        )
+
+        with gr.Row(elem_classes=["main-grid"]):
+            with gr.Column(scale=5, elem_classes=["scan-panel"]):
+                message = gr.Textbox(
+                    label="Suspicious message",
+                    placeholder="Paste a suspicious text, email, or DM here.",
+                    lines=10,
+                    max_lines=16,
+                )
+                with gr.Row():
+                    analyze = gr.Button("Analyze", variant="primary")
+                    remember = gr.Button("Remember this pattern")
+                gr.Examples(examples=EXAMPLES, inputs=message, label="Try a sample")
+
+            with gr.Column(scale=7):
+                result = gr.HTML(
+                    """
+                    <div class="empty-state">
+                      <h2>Paste a message to scan it.</h2>
+                      <p>Jawbreaker will show the risk, the Scam DNA, and the safest next step.</p>
+                    </div>
+                    """
+                )
+                memory = gr.HTML("<div class='memory-card muted'>No scam memory saved yet.</div>")
+                save_status = gr.Textbox(label="Session memory", interactive=False)
+
+        analyze.click(
+            fn=analyze_message,
+            inputs=[message, memory_state],
+            outputs=[result, memory, memory_state],
+        )
+        remember.click(
+            fn=remember_current,
+            inputs=[message, memory_state],
+            outputs=[save_status, memory_state],
+        )
+
+    return demo
+
+
+if __name__ == "__main__":
+    build_app().launch()
+

eval/run_eval.py

@@ -0,0 +1,25 @@
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from jawbreaker.schema import ScamAnalysis
+
+
+def main() -> None:
+    path = Path(__file__).with_name("scam_eval.jsonl")
+    rows = [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip()]
+    correct = 0
+
+    for row in rows:
+        analysis = ScamAnalysis.from_heuristics(row["input"])
+        ok = analysis.risk_level == row["expected_risk_level"]
+        correct += int(ok)
+        print(f"{row['id']}: expected={row['expected_risk_level']} actual={analysis.risk_level} ok={ok}")
+
+    print(f"risk_level_accuracy={correct}/{len(rows)}")
+
+
+if __name__ == "__main__":
+    main()

eval/scam_eval.jsonl

@@ -0,0 +1,7 @@
+{"id":"package_phish_001","input":"USPS: Your package is held due to an unpaid fee. Verify now: http://usps-track-secure.example","expected_risk_level":"dangerous","expected_scam_type":"credential_theft","expected_tactics":["urgency","suspicious link","fake authority"]}
+{"id":"family_impersonation_001","input":"Hi Grandma, I lost my phone. This is my new number. Can you send $800 for rent today? Please don't tell Mom.","expected_risk_level":"dangerous","expected_scam_type":"family_impersonation","expected_tactics":["impersonation","urgency","secrecy","payment pressure"]}
+{"id":"bank_safe_001","input":"Chase fraud alert: Did you attempt a $249.00 purchase at TARGET? Reply YES or NO.","expected_risk_level":"needs_check","expected_scam_type":"possible_legitimate_alert","expected_tactics":["verification needed"]}
+{"id":"gift_card_001","input":"This is your manager. I need you to buy three gift cards immediately and send me the codes. I am in a meeting.","expected_risk_level":"dangerous","expected_scam_type":"payment_request","expected_tactics":["fake authority","urgency","payment pressure"]}
+{"id":"safe_friend_001","input":"Running ten minutes late. See you at the restaurant soon.","expected_risk_level":"safe","expected_scam_type":"none","expected_tactics":[]}
+{"id":"password_reset_001","input":"Your email password expires today. Login now to keep access: https://mail-security-reset.example","expected_risk_level":"dangerous","expected_scam_type":"credential_theft","expected_tactics":["urgency","suspicious link","credential request"]}
+

jawbreaker/__init__.py

@@ -0,0 +1,2 @@
+"""Jawbreaker scam analysis app."""
+

jawbreaker/prompt.py

@@ -0,0 +1,13 @@
+SYSTEM_PROMPT = """
+You are Jawbreaker, a local-first scam defense assistant for non-experts.
+
+Analyze one suspicious message. Return only valid JSON. Use short, plain English.
+
+Safety rules:
+- Never advise clicking a suspicious link.
+- Never advise calling a phone number from the suspicious message.
+- If uncertain, choose "needs_check" and recommend verification through a trusted route.
+- Avoid jargon.
+- Give one safest next step.
+"""
+

jawbreaker/render.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from html import escape
+
+from jawbreaker.schema import ScamAnalysis
+
+
+def render_analysis_html(message: str, analysis: ScamAnalysis) -> str:
+    if not message.strip():
+        return """
+        <div class="empty-state">
+          <h2>Paste a message to scan it.</h2>
+          <p>Jawbreaker will show the risk, the Scam DNA, and the safest next step.</p>
+        </div>
+        """
+
+    tactic_html = "".join(f"<span class='tactic'>{escape(tactic)}</span>" for tactic in analysis.tactics)
+    dna_html = "".join(
+        f"""
+        <div class="dna-item">
+          <div class="dna-label">{escape(label)}</div>
+          <div class="dna-value">{escape(value)}</div>
+        </div>
+        """
+        for label, value in analysis.scam_dna.items()
+    )
+    memory_html = f"<p><strong>Memory:</strong> {escape(analysis.similar_memory)}</p>" if analysis.similar_memory else ""
+
+    return f"""
+    <section class="verdict-card risk-{escape(analysis.risk_level)}">
+      <span class="risk-pill">{escape(analysis.risk_level.replace("_", " "))}</span>
+      <p class="summary">{escape(analysis.summary)}</p>
+      <div class="action-card">
+        <strong>Safest next step</strong>
+        <p>{escape(analysis.safest_action)}</p>
+      </div>
+      <h3>Scam DNA</h3>
+      <div class="dna-grid">{dna_html}</div>
+      <h3>Warning signs</h3>
+      <div class="tactics">{tactic_html or "<span class='tactic'>none found</span>"}</div>
+      {memory_html}
+      <h3>Ask someone you trust</h3>
+      <p>{escape(analysis.trusted_person_message)}</p>
+    </section>
+    """
+
+
+def render_memory_html(analysis: ScamAnalysis, memory: list[dict]) -> str:
+    if not memory:
+        return "<div class='memory-card muted'>No scam memory saved yet.</div>"
+
+    items = "".join(
+        f"<li><strong>{escape(item.get('risk_level', ''))}</strong>: {escape(item.get('summary', ''))}</li>"
+        for item in memory[-5:]
+    )
+    return f"""
+    <div class="memory-card">
+      <strong>Session scam memory</strong>
+      <ul>{items}</ul>
+    </div>
+    """
+

jawbreaker/schema.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+RISK_LEVELS = {"dangerous", "suspicious", "needs_check", "safe"}
+
+
+@dataclass
+class ScamAnalysis:
+    risk_level: str
+    scam_type: str
+    summary: str
+    tactics: list[str] = field(default_factory=list)
+    safest_action: str = ""
+    trusted_person_message: str = ""
+    scam_dna: dict[str, str] = field(default_factory=dict)
+    similar_memory: str = ""
+
+    def __post_init__(self) -> None:
+        if self.risk_level not in RISK_LEVELS:
+            raise ValueError(f"Invalid risk level: {self.risk_level}")
+
+    @classmethod
+    def from_heuristics(cls, message: str, memory: list[dict] | None = None) -> "ScamAnalysis":
+        text = message.lower()
+        memory = memory or []
+
+        risk_level = "safe"
+        scam_type = "none"
+        tactics: list[str] = []
+
+        if any(token in text for token in ["verify", "password", "login", "account locked", "account is locked"]):
+            risk_level = "dangerous"
+            scam_type = "credential_theft"
+            tactics.extend(["credential request", "fake authority"])
+
+        if any(token in text for token in ["urgent", "immediately", "today", "24 hours", "act now", "held"]):
+            if risk_level == "safe":
+                risk_level = "suspicious"
+            tactics.append("urgency")
+
+        if any(token in text for token in ["gift card", "zelle", "crypto", "wire", "$800", "send money"]):
+            risk_level = "dangerous"
+            scam_type = "payment_request"
+            tactics.append("payment pressure")
+
+        if any(token in text for token in ["grandma", "new number", "don't tell", "dont tell"]):
+            risk_level = "dangerous"
+            scam_type = "family_impersonation"
+            tactics.extend(["impersonation", "secrecy"])
+
+        if "http://" in text or "https://" in text:
+            if risk_level == "safe":
+                risk_level = "suspicious"
+            tactics.append("suspicious link")
+
+        if "reply yes or no" in text and "fraud alert" in text:
+            risk_level = "needs_check"
+            scam_type = "possible_legitimate_alert"
+            tactics = ["verification needed"]
+
+        tactics = sorted(set(tactics))
+        summary = _summary_for(risk_level, scam_type)
+        similar_memory = _find_similar_memory(text, memory)
+
+        return cls(
+            risk_level=risk_level,
+            scam_type=scam_type,
+            summary=summary,
+            tactics=tactics,
+            safest_action=_safe_action_for(risk_level, scam_type),
+            trusted_person_message=_trusted_message_for(risk_level, scam_type),
+            scam_dna={
+                "Impersonates": _guess_impersonation(text),
+                "Pressure": _guess_pressure(tactics),
+                "Ask": _guess_ask(text, scam_type),
+                "Risk": scam_type.replace("_", " "),
+            },
+            similar_memory=similar_memory,
+        )
+
+
+def _summary_for(risk_level: str, scam_type: str) -> str:
+    if risk_level == "dangerous":
+        return f"This looks dangerous: likely {scam_type.replace('_', ' ')}."
+    if risk_level == "suspicious":
+        return "This has warning signs and should be checked before you act."
+    if risk_level == "needs_check":
+        return "This might be legitimate, but you should verify it using a trusted route."
+    return "No strong scam pattern was found in this short scan."
+
+
+def _safe_action_for(risk_level: str, scam_type: str) -> str:
+    if risk_level == "dangerous":
+        return "Do not click links, do not reply, and do not send money. Contact the company or person using a number or app you already trust."
+    if risk_level == "suspicious":
+        return "Pause before acting. Open the official website or app yourself instead of using links from this message."
+    if risk_level == "needs_check":
+        return "Verify directly through the official app, official website, or a known phone number."
+    return "If this came from someone you know and it asks for nothing sensitive, it is probably safe. Still avoid unexpected links."
+
+
+def _trusted_message_for(risk_level: str, scam_type: str) -> str:
+    if risk_level == "safe":
+        return "Can you sanity-check this message for me? Jawbreaker did not find a strong scam pattern, but I want to be careful."
+    return f"Can you check this for me? Jawbreaker says it may be {scam_type.replace('_', ' ')} and recommends that I do not click or reply yet."
+
+
+def _guess_impersonation(text: str) -> str:
+    if "usps" in text:
+        return "USPS or package carrier"
+    if "chase" in text or "bank" in text:
+        return "Bank or financial institution"
+    if "grandma" in text or "new number" in text:
+        return "Family member"
+    return "Unknown sender"
+
+
+def _guess_pressure(tactics: list[str]) -> str:
+    if "urgency" in tactics:
+        return "Act now"
+    if "secrecy" in tactics:
+        return "Keep it secret"
+    if "payment pressure" in tactics:
+        return "Send money"
+    return "Not obvious"
+
+
+def _guess_ask(text: str, scam_type: str) -> str:
+    if scam_type == "credential_theft":
+        return "Verify account or login"
+    if scam_type == "payment_request":
+        return "Send money"
+    if scam_type == "family_impersonation":
+        return "Trust a new number"
+    if "http://" in text or "https://" in text:
+        return "Open a link"
+    return "No direct ask found"
+
+
+def _find_similar_memory(text: str, memory: list[dict]) -> str:
+    tokens = set(text.split())
+    best_score = 0.0
+    best = ""
+    for item in memory:
+        old_tokens = set(str(item.get("text", "")).lower().split())
+        if not old_tokens:
+            continue
+        score = len(tokens & old_tokens) / max(len(tokens | old_tokens), 1)
+        if score > best_score:
+            best_score = score
+            best = str(item.get("summary", "a previous saved scam"))
+    if best_score >= 0.18:
+        return f"This resembles a saved pattern: {best}"
+    return ""
+

requirements.txt

@@ -0,0 +1,3 @@
+gradio==6.16.0
+pytest==8.4.2
+

style.css

@@ -0,0 +1,194 @@
+.gradio-container {
+  max-width: 1180px !important;
+  margin: 0 auto !important;
+}
+
+.hero {
+  display: flex;
+  align-items: end;
+  justify-content: space-between;
+  gap: 24px;
+  padding: 28px 4px 18px;
+  border-bottom: 1px solid #e4e4e7;
+  margin-bottom: 18px;
+}
+
+.eyebrow {
+  margin: 0 0 8px;
+  color: #9f1239;
+  font-size: 13px;
+  font-weight: 700;
+  text-transform: uppercase;
+}
+
+.hero h1 {
+  margin: 0;
+  font-size: 48px;
+  line-height: 1;
+  letter-spacing: 0;
+}
+
+.subtitle {
+  margin: 10px 0 0;
+  color: #3f3f46;
+  font-size: 20px;
+}
+
+.hero-badge {
+  border: 1px solid #fecdd3;
+  background: #fff1f2;
+  color: #9f1239;
+  padding: 10px 12px;
+  border-radius: 8px;
+  font-weight: 700;
+  white-space: nowrap;
+}
+
+.main-grid {
+  align-items: stretch;
+}
+
+.scan-panel textarea {
+  font-size: 18px !important;
+  line-height: 1.45 !important;
+}
+
+.verdict-card,
+.empty-state,
+.memory-card {
+  border: 1px solid #e4e4e7;
+  border-radius: 8px;
+  padding: 18px;
+  background: #ffffff;
+}
+
+.empty-state {
+  min-height: 220px;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+}
+
+.empty-state h2,
+.verdict-card h2 {
+  margin-top: 0;
+}
+
+.risk-dangerous {
+  border-color: #fecaca;
+  background: #fff1f2;
+}
+
+.risk-suspicious {
+  border-color: #fed7aa;
+  background: #fff7ed;
+}
+
+.risk-needs_check {
+  border-color: #fde68a;
+  background: #fffbeb;
+}
+
+.risk-safe {
+  border-color: #bbf7d0;
+  background: #f0fdf4;
+}
+
+.risk-pill {
+  display: inline-block;
+  margin-bottom: 14px;
+  padding: 8px 10px;
+  border-radius: 8px;
+  background: #18181b;
+  color: #ffffff;
+  font-size: 13px;
+  font-weight: 800;
+  text-transform: uppercase;
+}
+
+.summary {
+  font-size: 20px;
+  line-height: 1.35;
+  margin: 0 0 18px;
+}
+
+.action-card {
+  margin: 16px 0;
+  border-left: 5px solid #18181b;
+  background: #fafafa;
+  padding: 14px;
+  border-radius: 6px;
+}
+
+.dna-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 10px;
+  margin-top: 16px;
+}
+
+.dna-item {
+  border: 1px solid #e4e4e7;
+  background: rgba(255, 255, 255, 0.7);
+  border-radius: 8px;
+  padding: 12px;
+}
+
+.dna-label {
+  color: #71717a;
+  font-size: 12px;
+  font-weight: 700;
+  text-transform: uppercase;
+}
+
+.dna-value {
+  margin-top: 6px;
+  color: #18181b;
+  font-size: 16px;
+  font-weight: 700;
+}
+
+.tactics {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin-top: 12px;
+}
+
+.tactic {
+  border: 1px solid #d4d4d8;
+  border-radius: 999px;
+  padding: 7px 10px;
+  background: #ffffff;
+  color: #27272a;
+  font-size: 13px;
+  font-weight: 700;
+}
+
+.memory-card {
+  margin-top: 14px;
+}
+
+.muted {
+  color: #71717a;
+}
+
+@media (max-width: 760px) {
+  .hero {
+    align-items: start;
+    flex-direction: column;
+  }
+
+  .hero h1 {
+    font-size: 40px;
+  }
+
+  .hero-badge {
+    white-space: normal;
+  }
+
+  .dna-grid {
+    grid-template-columns: 1fr;
+  }
+}
+

tests/test_schema.py

@@ -0,0 +1,21 @@
+from jawbreaker.schema import ScamAnalysis
+
+
+def test_family_impersonation_is_dangerous() -> None:
+    analysis = ScamAnalysis.from_heuristics(
+        "Hi Grandma, I lost my phone. This is my new number. Can you send $800 today?"
+    )
+
+    assert analysis.risk_level == "dangerous"
+    assert analysis.scam_type == "family_impersonation"
+    assert "Trust a new number" == analysis.scam_dna["Ask"]
+
+
+def test_legitimate_fraud_alert_needs_check_not_dangerous() -> None:
+    analysis = ScamAnalysis.from_heuristics(
+        "Chase fraud alert: Did you attempt a $249.00 purchase at TARGET? Reply YES or NO."
+    )
+
+    assert analysis.risk_level == "needs_check"
+    assert analysis.scam_type == "possible_legitimate_alert"
+