Screenshot pipeline + fixes found under real render (CORS, batch state stomp, prompt-aware cv_tailor mock)

- scripts/screenshots.py + scripts/Dockerfile.shots: playwright-in-compose
  runner, 7 demo shots against the seeded stack (DinD-safe, output volume)
- docker-compose.yml: api + web services (nginx SPA + /api proxy-less via
  build-arg VITE_API_BASE), shots service with volume output
- apps/api: add CORSMiddleware (SPA origin web:80 could not read api:8000),
  batch scoring now refuses to rewrite applications beyond
  discovered/scored (kanban page load previously reset sent/interviewing
  to scored), prompt-aware cv_tailor mock so demo passes hallucination
  guard, hallucination-guard tests repointed to monkeypatched run_task
- apps/web: Applications kanban batches only unscored applications, red
  flag display falls back to stored rationale
- 159 api tests + 14 web tests green after fixes

apps/api/app/llm.py

@@ -161,6 +161,30 @@ MOCK_OUTPUTS: dict[str, dict[str, Any]] = {
 }
 
 
+def _mock_cv_tailor(prompt: str) -> dict[str, Any]:
+    """Prompt-aware mock tailor: extracts source bullets from the prompt and
+    rephrases them deterministically, so the result always passes the
+    hallucination guard (which requires traceable source overlap)."""
+    import re
+
+    bullets = re.findall(r'"([A-ZÅÄÖ][^"]{20,300})"', prompt)
+    bullets = [b for b in bullets if "{" not in b and ":" not in b][:4]
+    if not bullets:
+        bullets = ["Experienced backend developer focused on reliability"]
+    tailored = []
+    change_log = []
+    for b in bullets[:2]:
+        tailored.append(f"{b} (tailored for this posting)")
+        change_log.append({"action": "rephrased", "detail": f"Emphasized relevance of: {b[:60]}..."})
+    for b in bullets[2:]:
+        tailored.append(b)
+        change_log.append({"action": "kept", "detail": f"Retained as-is: {b[:60]}..."})
+    return {
+        "tailored_cv": {"summary": bullets[0][:160], "bullets": tailored},
+        "change_log": change_log,
+    }
+
+
 def run_task(
     task: str,
     prompt: str,
@@ -178,6 +202,8 @@ def run_task(
     # Mock mode
     time.sleep(0.01)  # simulate latency
     result = MOCK_OUTPUTS.get(task, {"result": "mock"})
+    if task == "cv_tailor":
+        result = _mock_cv_tailor(prompt)
 
     # Validate against schema if provided (basic check)
     # In real gateway this would be jsonschema validation

apps/api/app/main.py

@@ -87,6 +87,18 @@ except ImportError:
 
 app = FastAPI(title="Jobhunt API", version="0.2.0")
 
+# Self-hosted single-user app; SPA origin differs from API origin (e.g. web:80 -> api:8000).
+from fastapi.middleware.cors import CORSMiddleware
+
+_cors_origins = os.environ.get("CORS_ORIGINS", "*").split(",")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[o.strip() for o in _cors_origins if o.strip()],
+    allow_credentials=False,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
 
 @app.on_event("startup")
 def _startup() -> None:
@@ -858,7 +870,13 @@ def postings_fetch(body: PostingsFetchRequest) -> Any:
 # --- v1: Batch Scoring ---
 
 def _batch_score_internal(application_ids: list[str]) -> list[dict[str, Any]]:
-    """Internal: score multiple applications, return results with red_flags."""
+    """Internal: score multiple applications, return results with red_flags.
+
+    Safety rule (post-bug): batch scoring only touches applications in
+    'discovered' or 'scored' state. Anything further down the pipeline
+    (approved/sent/interviewing/...) keeps its state and stored scores;
+    those rows are returned unchanged with skipped=True.
+    """
     results: list[dict[str, Any]] = []
     for app_id in application_ids:
         app_row = repo_app.get_application(app_id)
@@ -868,6 +886,17 @@ def _batch_score_internal(application_ids: list[str]) -> list[dict[str, Any]]:
         if posting is None:
             continue
 
+        if app_row["state"] not in ("discovered", "scored"):
+            existing = app_row.get("score_rationale") or {}
+            results.append({
+                "application_id": app_id,
+                "score": app_row.get("score"),
+                "rationale": existing,
+                "red_flags": existing.get("red_flags", []),
+                "skipped": True,
+            })
+            continue
+
         result = llm.run_task(
             "score",
             f"Score this posting: {posting['title']} at {posting['company']}",
@@ -1035,27 +1064,89 @@ def interview_prep(app_id: str) -> Any:
 
 # --- v1: Concierge / Demo Seed ---
 
+def _seed_demo_counts() -> dict[str, Any]:
+    """Compute counts for the seed-demo response from current DB state."""
+    postings = repo_app.list_postings()
+    apps = repo_app.list_applications()
+    sections = repo_profile.list_sections()
+
+    # Clusters: postings with a non-null cluster_id
+    cluster_postings = [p for p in postings if p.get("cluster_id")]
+    cluster_ids = set(p["cluster_id"] for p in cluster_postings if p["cluster_id"])
+
+    # Deadlines: postings with apply_by in the next 7 days
+    from datetime import date, timedelta
+    today = datetime.now(timezone.utc).date()
+    deadline_window = today + timedelta(days=7)
+    deadline_count = 0
+    for p in postings:
+        apply_by_raw = p.get("apply_by")
+        if not apply_by_raw:
+            continue
+        # _normalize_posting returns apply_by as ISO string
+        if isinstance(apply_by_raw, str):
+            apply_by_date = date.fromisoformat(apply_by_raw)
+        else:
+            apply_by_date = apply_by_raw
+        if today <= apply_by_date <= deadline_window:
+            deadline_count += 1
+
+    # Pending email suggestions
+    from app.imap_watch import list_pending_suggestions
+    suggestions = list_pending_suggestions()
+
+    # Notification log rows
+    from app.notify import list_notification_log
+    notifications = list_notification_log(limit=50)
+
+    # Task runs
+    task_runs = repo_app.list_task_runs()
+
+    # CV artifacts (kind=cv, origin=ai_drafted)
+    cv_count = 0
+    for a in apps:
+        artifacts = repo_app.list_artifacts(a["id"])
+        cv_count += sum(1 for art in artifacts if art["kind"] == "cv" and art["origin"] == "ai_drafted")
+
+    return {
+        "profile": "Demo Demosson",
+        "postings": len(postings),
+        "applications": len(apps),
+        "sections": len(sections),
+        "clusters": len(cluster_ids),
+        "deadlines": deadline_count,
+        "suggestions": len(suggestions),
+        "notifications": len(notifications),
+        "task_runs": len(task_runs),
+        "cv_artifacts": cv_count,
+    }
+
+
 @app.post("/api/concierge/seed-demo", response_model=SeedDemoResponse)
 def seed_demo() -> Any:
-    """Idempotent demo seed: profile + 6 postings + varied application states."""
+    """Idempotent demo seed: profile + postings + varied application states + artifacts + telemetry.
+
+    Populates a complete demo-worthy dataset:
+    - 6 standalone postings with varied application states
+    - 3-posting agency cluster (same role reposted by 3 fictional agencies)
+    - 2 postings with apply_by deadlines in the next 4 days
+    - 1 posting with red_flags in its application score_rationale
+    - Applications: 1 sent (backdated 8 days for nudge), 1 interviewing, 1 approved with cover letter
+    - 2 pending email_suggestion rows
+    - 3 notification_log rows (daily_digest delivered, email_suggestion delivered, webhook failed)
+    - 6 task_run telemetry rows across providers/models
+    - 1 cv-tailor artifact (kind cv, origin ai_drafted) on the interviewing application
+    """
+    from datetime import date, timedelta
+
     # Check if demo profile already exists
     existing = fetch_one(
         "SELECT * FROM profile WHERE full_name = 'Demo Demosson'"
     )
     if existing:
-        # Already seeded -- return current counts
+        return _seed_demo_counts()
-        profile = repo_profile._normalize_profile(existing)
-        postings = repo_app.list_postings()
-        apps = repo_app.list_applications()
-        sections = repo_profile.list_sections()
-        return {
-            "profile": profile["full_name"],
-            "postings": len(postings),
-            "applications": len(apps),
-            "sections": len(sections),
-        }
 
-    # Create demo profile with Swedish characters
+    # -- Create demo profile with Swedish characters --
     repo_profile.get_or_create_profile()
     profile = repo_profile.update_profile({
         "full_name": "Demo Demosson",
@@ -1078,7 +1169,12 @@ def seed_demo() -> Any:
     for s in demo_sections:
         repo_profile.create_section(profile["id"], s)
 
-    # Create 6 demo postings with varied states
+    # -- Track application IDs for later linking --
+    sent_app_id: str | None = None
+    interviewing_app_id: str | None = None
+    approved_app_id: str | None = None
+
+    # -- Create 6 standalone demo postings with varied states --
     demo_postings = [
         {"company": "Skane Tech AB", "title": "Senior Python Developer", "location": "Malmo", "url": "https://example.com/af/1", "state": "scored", "score": 85},
         {"company": "Lund Systems", "title": "Fullstack Engineer", "location": "Lund", "url": "https://example.com/af/2", "state": "discovered", "score": None},
@@ -1100,48 +1196,264 @@ def seed_demo() -> Any:
         )
         app_row = repo_app.create_application(posting["id"])
 
+        if dp["state"] == "sent":
+            sent_app_id = app_row["id"]
+        if dp["state"] == "approved":
+            approved_app_id = app_row["id"]
+
         # Set state and score
         if dp["score"] is not None:
             repo_app.update_application_score(app_row["id"], dp["score"], {"factors": {}})
 
         if dp["state"] != "discovered" and dp["state"] != "scored":
-            # Transition through states
             if dp["state"] in ("approved", "rejected"):
-                # First set to scored if needed
                 if dp["score"] is not None:
                     repo_app.update_application_state(app_row["id"], "scored")
                 repo_app.update_application_state(app_row["id"], dp["state"])
             elif dp["state"] == "sent":
-                # approved -> drafting -> sent
                 if dp["score"] is not None:
                     repo_app.update_application_state(app_row["id"], "scored")
                 repo_app.update_application_state(app_row["id"], "approved")
                 repo_app.update_application_state(app_row["id"], "drafting")
-                # We need confirmed approval for drafting->sent, so directly set state
                 execute(
                     "UPDATE application SET state = 'sent', state_changed_at = now(), last_activity_at = now() WHERE id = %s",
                     (app_row["id"],),
                 )
 
-    # Backdate the 'sent' application ( posting 4) to 8 days ago for nudge demo
+    # -- 3-posting AGENCY CLUSTER (same real role, 3 fictional agencies, near-identical title+description) --
-    from datetime import timedelta
+    cluster_title = "Senior Backend Developer"
-    backdated = datetime.now(timezone.utc) - timedelta(days=8)
+    cluster_desc = (
+        "We are looking for a senior backend developer with strong Python skills. "
+        "You will build and maintain scalable REST APIs, work with PostgreSQL, "
+        "and collaborate in an agile team. Experience with Docker and cloud "
+        "deployment is a plus."
+    )
+    agency_companies = ["Aderanto AB", "Wise IT", "TechTalent Nord"]
+    agency_posting_ids: list[str] = []
+    for i, agency in enumerate(agency_companies):
+        posting = repo_app.create_job_posting(
+            source="arbetsformedlingen",
+            url=f"https://example.com/af/agency/{i+1}",
+            company=agency,
+            title=cluster_title,
+            location="Stockholm",
+            description=cluster_desc,
+            raw={},
+        )
+        agency_posting_ids.append(posting["id"])
+        # Create applications for these too (scored for digest demo)
+        app_row = repo_app.create_application(posting["id"])
+        repo_app.update_application_score(app_row["id"], 75 + i, {"factors": {}})
+
+    # Assign cluster IDs to all postings (the matching package will cluster the 3 agency postings together)
+    for pid in agency_posting_ids:
+        _assign_cluster_id(pid)
+
+    # -- 2 postings with apply_by in the next 4 days (deadlines strip) --
+    today = datetime.now(timezone.utc).date()
+    for j in range(2):
+        deadline = today + timedelta(days=2 + j)
+        posting = repo_app.create_job_posting(
+            source="arbetsformedlingen",
+            url=f"https://example.com/af/deadline/{j+1}",
+            company=f"Deadline Corp {j+1}",
+            title=f"Urgent Developer Role {j+1}",
+            location="Goteborg",
+            description="Urgent hire for a developer with deadline approaching.",
+            raw={},
+        )
+        repo_app.update_posting_apply_by(posting["id"], deadline)
+        app_row = repo_app.create_application(posting["id"])
+        repo_app.update_application_score(app_row["id"], 60 + j * 5, {"factors": {}})
+
+    # -- 1 posting with red_flags on its application score_rationale --
+    red_flag_posting = repo_app.create_job_posting(
+        source="arbetsformedlingen",
+        url="https://example.com/af/redflag/1",
+        company="ShadyCorp AB",
+        title="Junior Developer",
+        location="Remote",
+        description="Entry level developer position with trial period.",
+        raw={},
+    )
+    red_flag_app = repo_app.create_application(red_flag_posting["id"])
+    red_flag_rationale = {
+        "factors": {"salary": "below market rate", "trial_period": "3 months unpaid"},
+        "red_flags": ["requests unpaid trial work", "salary significantly below market rate"],
+        "summary": "Multiple red flags detected during scoring.",
+    }
+    repo_app.update_application_score(red_flag_app["id"], 25, red_flag_rationale)
+
+    # -- Application in 'interviewing' state --
+    interviewing_posting = repo_app.create_job_posting(
+        source="arbetsformedlingen",
+        url="https://example.com/af/interview/1",
+        company="Festina Digital AB",
+        title="Full Stack Developer",
+        location="Malmo",
+        description="Full stack developer with React, Python, and cloud experience.",
+        raw={},
+    )
+    interviewing_app = repo_app.create_application(interviewing_posting["id"])
+    repo_app.update_application_score(interviewing_app["id"], 90, {"factors": {}})
+    repo_app.update_application_state(interviewing_app["id"], "scored")
+    repo_app.update_application_state(interviewing_app["id"], "approved")
+    repo_app.update_application_state(interviewing_app["id"], "drafting")
     execute(
-        "UPDATE application SET last_activity_at = %s WHERE state = 'sent'",
+        "UPDATE application SET state = 'sent', state_changed_at = now(), last_activity_at = now() WHERE id = %s",
-        (backdated,),
+        (interviewing_app["id"],),
+    )
+    repo_app.update_application_state(interviewing_app["id"], "interviewing")
+    interviewing_app_id = interviewing_app["id"]
+
+    # -- Cover letter artifact on the 'approved' application (Swedish text, origin user_drafted) --
+    storage_dir = os.path.join(tempfile.gettempdir(), "jobhunt_artifacts")
+    os.makedirs(storage_dir, exist_ok=True)
+    if approved_app_id:
+        cover_text = (
+            "Basta rekryterare,\n\n"
+            "Jag ansoker om tjansen som Backend Developer hos er. "
+            "Med min erfarenhet av Python, FastAPI och PostgreSQL "
+            "tror jag att jag skulle vara en bra tillgang for ert team.\n\n"
+            "Jag ser fram emot att diskutera rollen vidare.\n\n"
+            "Vanliga halsningar,\n"
+            "Demo Demosson"
+        )
+        cover_bytes = cover_text.encode("utf-8")
+        cl_filename = f"cover_letter_{approved_app_id[:8]}.txt"
+        cl_storage_path = os.path.join(storage_dir, cl_filename)
+        with open(cl_storage_path, "wb") as f:
+            f.write(cover_bytes)
+        repo_app.create_artifact(
+            application_id=approved_app_id,
+            kind="cover_letter",
+            filename=cl_filename,
+            content_bytes=cover_bytes,
+            storage_path=cl_storage_path,
+            origin="user_drafted",
+        )
+
+    # -- CV tailor artifact on the interviewing application (kind cv, origin ai_drafted, real PDF bytes + hash) --
+    if interviewing_app_id and HAS_ARTIFACTS:
+        _render_fn = _render_cv_pdf  # type: ignore[possibly-unbound]
+        cv_profile = {
+            "full_name": profile.get("full_name", ""),
+            "headline": profile.get("headline", ""),
+            "email": profile.get("email", ""),
+            "phone": profile.get("phone", ""),
+            "location": profile.get("location", ""),
+            "summary": "Tailored CV for full stack developer role at Festina Digital.",
+        }
+        cv_sections = [
+            {
+                "kind": "experience",
+                "title": "Backend Developer",
+                "org": "TechSkane AB",
+                "bullets": ["Built REST APIs", "Improved performance by 30%"],
+            },
+            {
+                "kind": "skills",
+                "title": "Technical Skills",
+                "bullets": ["Python", "PostgreSQL", "Docker", "FastAPI", "React"],
+            },
+        ]
+        pdf_bytes = _render_fn(cv_profile, cv_sections)
+        cv_filename = f"cv_tailored_{interviewing_app_id[:8]}.pdf"
+        cv_storage_path = os.path.join(storage_dir, cv_filename)
+        with open(cv_storage_path, "wb") as f:
+            f.write(pdf_bytes)
+        repo_app.create_artifact(
+            application_id=interviewing_app_id,
+            kind="cv",
+            filename=cv_filename,
+            content_bytes=pdf_bytes,
+            storage_path=cv_storage_path,
+            origin="ai_drafted",
+        )
+
+    # -- Backdate the 'sent' application to 8 days ago for nudge demo --
+    backdated = datetime.now(timezone.utc) - timedelta(days=8)
+    if sent_app_id:
+        execute(
+            "UPDATE application SET last_activity_at = %s WHERE id = %s",
+            (backdated, sent_app_id),
+        )
+
+    # -- 2 pending email_suggestion rows --
+    from app.imap_watch import create_email_suggestion
+
+    suggestion_time = datetime.now(timezone.utc) - timedelta(hours=3)
+    if sent_app_id:
+        create_email_suggestion(
+            application_id=sent_app_id,
+            mailbox_from="recruiter@festina-demo.se",
+            subject="Inbjudan till intervju",
+            snippet="Hej, vi skulle vilja boka in en intervju med dig...",
+            classification="interview_invite",
+            state_proposal="interviewing",
+            received_at=suggestion_time,
+        )
+
+    if interviewing_app_id:
+        create_email_suggestion(
+            application_id=interviewing_app_id,
+            mailbox_from="hr@festina-demo.se",
+            subject="Fraga om din erfarenhet",
+            snippet="Vi har nagra fragor om din bakgrund inom Python...",
+            classification="question",
+            state_proposal=None,
+            received_at=datetime.now(timezone.utc) - timedelta(hours=1),
+        )
+
+    # -- 3 notification_log rows --
+    # 1) daily_digest delivered (via LogChannel-style insert)
+    execute(
+        """
+        INSERT INTO notification_log (channel, kind, payload, delivered, error)
+        VALUES ('log', 'daily_digest', %s, true, NULL)
+        """,
+        (json.dumps({"text": "Your daily digest is ready", "items": 5}),),
     )
 
-    # Count results
+    # 2) email_suggestion delivered
-    postings_count = len(repo_app.list_postings())
+    execute(
-    apps_count = len(repo_app.list_applications())
+        """
-    sections_count = len(repo_profile.list_sections())
+        INSERT INTO notification_log (channel, kind, payload, delivered, error)
+        VALUES ('log', 'email_suggestion', %s, true, NULL)
+        """,
+        (json.dumps({"text": "New email suggestion received", "suggestion_id": "demo"}),),
+    )
 
-    return {
+    # 3) webhook failed with error text
-        "profile": "Demo Demosson",
+    execute(
-        "postings": postings_count,
+        """
-        "applications": apps_count,
+        INSERT INTO notification_log (channel, kind, payload, delivered, error)
-        "sections": sections_count,
+        VALUES ('webhook', 'daily_digest', %s, false, %s)
-    }
+        """,
+        (
+            json.dumps({"text": "Daily digest delivery attempt", "items": 5}),
+            "HTTP 503: Service Unavailable (webhook endpoint down)",
+        ),
+    )
+
+    # -- 6 task_run telemetry rows across providers/models --
+    demo_task_runs = [
+        {"task": "score_application", "model": "gpt-4o-mini", "provider": "openai", "input_tokens": 1200, "output_tokens": 80, "cost_usd": 0.0012, "duration_ms": 1500},
+        {"task": "score_application", "model": "gpt-4o", "provider": "openai", "input_tokens": 1500, "output_tokens": 120, "cost_usd": 0.0180, "duration_ms": 2200},
+        {"task": "cv_tailor", "model": "claude-sonnet-4-20250514", "provider": "anthropic", "input_tokens": 3000, "output_tokens": 800, "cost_usd": 0.0450, "duration_ms": 4500},
+        {"task": "cl_critique", "model": "gpt-4o-mini", "provider": "openai", "input_tokens": 900, "output_tokens": 200, "cost_usd": 0.0009, "duration_ms": 1800},
+        {"task": "interview_prep", "model": "claude-3-5-sonnet-20241022", "provider": "anthropic", "input_tokens": 2200, "output_tokens": 600, "cost_usd": 0.0330, "duration_ms": 3100},
+        {"task": "score_application", "model": "gemini-1.5-flash", "provider": "google", "input_tokens": 1000, "output_tokens": 90, "cost_usd": 0.0005, "duration_ms": 900},
+    ]
+    link_app = interviewing_app_id or sent_app_id
+    for idx, tr in enumerate(demo_task_runs):
+        repo_app.create_task_run({
+            **tr,
+            "application_id": link_app if idx % 2 == 0 else None,
+        })
+
+    # -- Return counts --
+    return _seed_demo_counts()
 
 
 # --- v1.1: Email Suggestions ---

apps/api/app/schemas.py

@@ -323,6 +323,12 @@ class SeedDemoResponse(BaseModel):
     postings: int
     applications: int
     sections: int
+    clusters: int = 0
+    deadlines: int = 0
+    suggestions: int = 0
+    notifications: int = 0
+    task_runs: int = 0
+    cv_artifacts: int = 0
 
 
 # --- v1.1: Email Suggestions ---

apps/api/tests/test_v11b_wb1.py

@@ -398,36 +398,35 @@ class TestTailorCvHappyPath:
 # ========================================================================
 
 class TestTailorCvHallucinationGuard:
-    def test_hallucination_rejection_502(self, client):
+    def test_hallucination_rejection_502(self, client, monkeypatch):
-        """When mock returns bullet with no source mapping, return 502."""
+        """When the tailor output has bullets with no source mapping, return 502."""
-        app_id = _create_app_with_profile_and_sections(client)
-
-        # Patch the mock to return a fabricated bullet
         import app.llm as llm_mod
-        original = llm_mod.MOCK_OUTPUTS.get("cv_tailor", {}).copy()
+
-        try:
+        app_id = _create_app_with_profile_and_sections(client)
-            llm_mod.MOCK_OUTPUTS["cv_tailor"] = {
+        fabricated = {
-                "tailored_cv": {
+            "tailored_cv": {
-                    "summary": "Developer",
+                "summary": "Developer",
-                    "skills": ["Python"],
+                "skills": ["Python"],
-                    "experience": [
+                "experience": [
-                        {
+                    {
-                            "company": "FakeCorp",
+                        "company": "FakeCorp",
-                            "role": "Fake Role",
+                        "role": "Fake Role",
-                            "bullets": [
+                        "bullets": [
-                                "Completely fabricated achievement that has no overlap with any source bullet xyzqwerty",
+                            "Completely fabricated achievement that has no overlap with any source bullet xyzqwerty",
-                            ],
+                        ],
-                        },
+                    },
-                    ],
+                ],
-                },
+            },
-                "change_log": [{"action": "invented", "detail": "Made up a bullet"}],
+            "change_log": [{"action": "invented", "detail": "Made up a bullet"}],
-            }
+        }
-            resp = client.post(f"/api/applications/{app_id}/tailor-cv")
+        monkeypatch.setattr(
-            assert resp.status_code == 502
+            llm_mod, "run_task",
-            detail = resp.json()["detail"]
+            lambda task, prompt, *a, **k: fabricated,
-            assert "hallucination_guard" in str(detail)
+        )
-        finally:
+        resp = client.post(f"/api/applications/{app_id}/tailor-cv")
-            llm_mod.MOCK_OUTPUTS["cv_tailor"] = original
+        assert resp.status_code == 502
+        detail = resp.json()["detail"]
+        assert "hallucination_guard" in str(detail)
 
     def test_hallucination_rejection_with_empty_source_bullets(self, client):
         """When there are no source bullets, hallucination guard is not triggered (no source to map to)."""
@@ -456,37 +455,36 @@ class TestTailorCvHallucinationGuard:
         # Should succeed since source_bullets is empty -> guard not triggered
         assert resp.status_code == 200
 
-    def test_hallucination_rejection_preserves_existing_output(self, client):
+    def test_hallucination_rejection_preserves_existing_output(self, client, monkeypatch):
         """After a 502 hallucination rejection, a subsequent valid call works."""
-        app_id = _create_app_with_profile_and_sections(client)
-
-        # First: trigger hallucination
         import app.llm as llm_mod
-        original = llm_mod.MOCK_OUTPUTS.get("cv_tailor", {}).copy()
+
-        try:
+        app_id = _create_app_with_profile_and_sections(client)
-            llm_mod.MOCK_OUTPUTS["cv_tailor"] = {
+        fabricated = {
-                "tailored_cv": {
+            "tailored_cv": {
-                    "summary": "Dev",
+                "summary": "Dev",
-                    "skills": ["Python"],
+                "skills": ["Python"],
-                    "experience": [
+                "experience": [
-                        {
+                    {
-                            "company": "X",
+                        "company": "X",
-                            "role": "X",
+                        "role": "X",
-                            "bullets": ["Fabricated xyzqwerty zzz new content"],
+                        "bullets": ["Fabricated xyzqwerty zzz new content"],
-                        },
+                    },
-                    ],
+                ],
-                },
+            },
-                "change_log": [],
+            "change_log": [],
-            }
+        }
+        with monkeypatch.context() as mp:
+            mp.setattr(
+                llm_mod, "run_task",
+                lambda task, prompt, *a, **k: fabricated,
+            )
             resp1 = client.post(f"/api/applications/{app_id}/tailor-cv")
             assert resp1.status_code == 502
 
-            # Restore and retry
+        # Default prompt-aware mock is guard-safe -> succeeds
-            llm_mod.MOCK_OUTPUTS["cv_tailor"] = original
+        resp2 = client.post(f"/api/applications/{app_id}/tailor-cv")
-            resp2 = client.post(f"/api/applications/{app_id}/tailor-cv")
+        assert resp2.status_code == 200
-            assert resp2.status_code == 200
-        finally:
-            llm_mod.MOCK_OUTPUTS["cv_tailor"] = original
 
 
 # ========================================================================

apps/api/tests/test_v1_features.py

@@ -279,14 +279,22 @@ class TestInterviewPrep:
 
 class TestSeedDemo:
     def test_seed_demo_creates_data(self, client):
-        """POST /concierge/seed-demo creates profile, postings, applications."""
+        """POST /concierge/seed-demo creates profile, postings, applications, and extended data."""
         resp = client.post("/api/concierge/seed-demo")
         assert resp.status_code == 200
         data = resp.json()
         assert data["profile"] == "Demo Demosson"
-        assert data["postings"] == 6
-        assert data["applications"] == 6
         assert data["sections"] == 4
+        # 6 standalone + 3 agency + 2 deadline + 1 redflag + 1 interviewing = 13 postings
+        assert data["postings"] == 13
+        # 6 standalone + 3 agency + 2 deadline + 1 redflag + 1 interviewing = 13 applications
+        assert data["applications"] == 13
+        assert data["clusters"] >= 1
+        assert data["deadlines"] >= 2
+        assert data["suggestions"] == 2
+        assert data["notifications"] == 3
+        assert data["task_runs"] == 6
+        assert data["cv_artifacts"] >= 1
 
     def test_seed_demo_idempotent(self, client):
         """Running seed-demo twice returns the same counts."""
@@ -298,6 +306,12 @@ class TestSeedDemo:
         assert resp2.json()["postings"] == resp1.json()["postings"]
         assert resp2.json()["applications"] == resp1.json()["applications"]
         assert resp2.json()["sections"] == resp1.json()["sections"]
+        assert resp2.json()["clusters"] == resp1.json()["clusters"]
+        assert resp2.json()["deadlines"] == resp1.json()["deadlines"]
+        assert resp2.json()["suggestions"] == resp1.json()["suggestions"]
+        assert resp2.json()["notifications"] == resp1.json()["notifications"]
+        assert resp2.json()["task_runs"] == resp1.json()["task_runs"]
+        assert resp2.json()["cv_artifacts"] == resp1.json()["cv_artifacts"]
 
     def test_seed_demo_has_nudge_candidate(self, client):
         """After seeding, /today should show a nudge for the backdated sent app."""
@@ -313,6 +327,104 @@ class TestSeedDemo:
         digest = resp.json()["digest"]
         assert len(digest) >= 1
 
+    # --- WS1: Extended seed demo tests (8 new) ---
+
+    def test_seed_demo_agency_cluster_present(self, client):
+        """Seed creates a 3-posting agency cluster with the same cluster_id."""
+        client.post("/api/concierge/seed-demo")
+        postings = client.get("/api/postings").json()
+        agency_names = {"Aderanto AB", "Wise IT", "TechTalent Nord"}
+        agency_postings = [p for p in postings if p.get("company") in agency_names]
+        assert len(agency_postings) == 3
+        cluster_ids = {p["cluster_id"] for p in agency_postings if p.get("cluster_id")}
+        assert len(cluster_ids) == 1, f"Expected 1 cluster_id, got {cluster_ids}"
+
+    def test_seed_demo_deadlines_populated(self, client):
+        """Seed creates at least 2 postings with apply_by in the next 7 days."""
+        client.post("/api/concierge/seed-demo")
+        resp = client.get("/api/today")
+        assert resp.status_code == 200
+        deadlines = resp.json().get("deadlines", [])
+        assert len(deadlines) >= 2
+        for d in deadlines:
+            assert d["apply_by"] is not None
+
+    def test_seed_demo_red_flag_rationale(self, client):
+        """Seed creates an application with red_flags in its score_rationale."""
+        client.post("/api/concierge/seed-demo")
+        apps = client.get("/api/applications").json()
+        red_flag_apps = [
+            a for a in apps
+            if a.get("score_rationale") and isinstance(a["score_rationale"], dict)
+            and "red_flags" in a["score_rationale"]
+        ]
+        assert len(red_flag_apps) >= 1
+        red_flags = red_flag_apps[0]["score_rationale"]["red_flags"]
+        assert isinstance(red_flags, list)
+        assert any("unpaid trial" in str(rf).lower() for rf in red_flags)
+
+    def test_seed_demo_has_interviewing_application(self, client):
+        """Seed creates at least one application in interviewing state."""
+        client.post("/api/concierge/seed-demo")
+        apps = client.get("/api/applications").json()
+        interviewing = [a for a in apps if a["state"] == "interviewing"]
+        assert len(interviewing) >= 1
+
+    def test_seed_demo_has_cover_letter_artifact(self, client):
+        """Seed creates a cover_letter artifact (origin user_drafted) with Swedish text on the approved app."""
+        client.post("/api/concierge/seed-demo")
+        apps = client.get("/api/applications").json()
+        for a in apps:
+            artifacts = client.get(f"/api/applications/{a['id']}/artifacts").json()
+            for art in artifacts:
+                if art["kind"] == "cover_letter" and art["origin"] == "user_drafted":
+                    return
+        assert False, "No user_drafted cover_letter artifact found"
+
+    def test_seed_demo_suggestions_present(self, client):
+        """Seed creates 2 pending email_suggestion rows with expected classifications."""
+        client.post("/api/concierge/seed-demo")
+        suggestions = client.get("/api/suggestions").json()
+        assert len(suggestions) == 2
+        classifications = {s["classification"] for s in suggestions}
+        assert "interview_invite" in classifications
+        assert "question" in classifications
+        # Verify the interview_invite comes from recruiter@festina-demo.se
+        interview_suggestion = [s for s in suggestions if s["classification"] == "interview_invite"][0]
+        assert interview_suggestion["mailbox_from"] == "recruiter@festina-demo.se"
+
+    def test_seed_demo_notification_log_present(self, client):
+        """Seed creates 3 notification_log rows: 2 delivered, 1 webhook failed."""
+        client.post("/api/concierge/seed-demo")
+        resp = client.get("/api/notifications/log")
+        assert resp.status_code == 200
+        logs = resp.json()
+        assert len(logs) == 3
+        # At least one delivered (daily_digest or email_suggestion)
+        delivered = [l for l in logs if l["delivered"] is True]
+        assert len(delivered) >= 2
+        # At least one webhook failed with error text
+        failed = [l for l in logs if l["delivered"] is False]
+        assert len(failed) >= 1
+        assert failed[0]["error"] is not None
+        assert len(failed[0]["error"]) > 0
+
+    def test_seed_demo_task_run_telemetry_variance(self, client):
+        """Seed creates 6 task_run rows across multiple providers and models."""
+        client.post("/api/concierge/seed-demo")
+        resp = client.get("/api/telemetry/tasks")
+        assert resp.status_code == 200
+        tasks = resp.json()
+        assert len(tasks) == 6
+        providers = {t["provider"] for t in tasks}
+        models = {t["model"] for t in tasks}
+        assert len(providers) >= 3, f"Expected >= 3 providers, got {providers}"
+        assert len(models) >= 4, f"Expected >= 4 models, got {models}"
+        # Verify cost variance for CostDisplay
+        costs = [t["cost_usd"] for t in tasks if t["cost_usd"] is not None]
+        assert len(costs) >= 2
+        assert max(costs) > min(costs)
+
 
 # --- SMTP Transport ---
 

apps/web/Dockerfile

@@ -0,0 +1,14 @@
+# Web production image: build the SPA, serve via nginx with SPA fallback
+FROM node:22-alpine AS build
+WORKDIR /w
+ARG VITE_API_BASE=http://api:8000/api
+ENV VITE_API_BASE=$VITE_API_BASE
+COPY apps/web/package.json apps/web/package-lock.json ./
+RUN npm ci --no-audit --no-fund
+COPY apps/web ./
+RUN npm run build
+
+FROM nginx:1.27-alpine
+COPY apps/web/nginx.conf /etc/nginx/conf.d/default.conf
+COPY --from=build /w/dist /usr/share/nginx/html
+EXPOSE 80

apps/web/nginx.conf

@@ -0,0 +1,15 @@
+server {
+    listen 80;
+    server_name _;
+    root /usr/share/nginx/html;
+    index index.html;
+
+    location /api/ {
+        proxy_pass http://api:8000/api/;
+        proxy_set_header Host $host;
+    }
+
+    location / {
+        try_files $uri $uri/ /index.html;
+    }
+}

apps/web/src/views/Applications.vue

@@ -41,7 +41,10 @@ function hasRedFlags(app: Application): boolean {
 }
 
 function redFlagsFor(app: Application): string[] {
-  return redFlagsMap.value[app.id] ?? []
+  const fromBatch = redFlagsMap.value[app.id]
+  if (fromBatch) return fromBatch
+  const stored = (app.score_rationale as { red_flags?: string[] } | null)?.red_flags
+  return stored ?? []
 }
 
 function hasNudge(app: Application): boolean {
@@ -53,7 +56,11 @@ async function loadApplications() {
     applications.value = await api.getApplications()
     // Load red flags via batch scoring and nudges via today endpoint
     const [batchResult, todayResult] = await Promise.allSettled([
-      api.batchScore(applications.value.map((a) => a.id)),
+      api.batchScore(
+        applications.value
+          .filter((a) => a.state === 'discovered' || a.state === 'scored')
+          .map((a) => a.id)
+      ),
       api.getToday()
     ])
     if (batchResult.status === 'fulfilled') {

docker-compose.yml

@@ -29,6 +29,42 @@ services:
         condition: service_healthy
     restart: "no"
 
+  api:
+    build:
+      context: .
+      dockerfile: apps/api/Dockerfile.test
+    image: jobhunt-platform-api-test
+    entrypoint: uvicorn app.main:app --host 0.0.0.0 --port 8000
+    environment:
+      DATABASE_URL: postgresql://jobhunt:jobhunt@postgres:5432/jobhunt
+    working_dir: /app/apps/api
+    depends_on:
+      postgres:
+        condition: service_healthy
+    restart: "no"
+
+  web:
+    build:
+      context: .
+      dockerfile: apps/web/Dockerfile
+      args:
+        VITE_API_BASE: http://api:8000/api
+    depends_on:
+      - api
+    restart: "no"
+
+  shots:
+    build:
+      context: .
+      dockerfile: scripts/Dockerfile.shots
+    volumes:
+      - shots_out:/out
+    depends_on:
+      - api
+      - web
+    restart: "no"
+
 volumes:
   jobhunt_pgdata:
-    name: jobhunt_pgdata
+    name: jobhunt_pgdata
+  shots_out:

scripts/Dockerfile.shots

@@ -0,0 +1,5 @@
+FROM mcr.microsoft.com/playwright/python:v1.55.0-jammy
+WORKDIR /shots
+RUN pip install --no-cache-dir playwright==1.55.0
+COPY scripts/screenshots.py ./
+CMD ["python", "screenshots.py"]

scripts/screenshots.py

@@ -0,0 +1,84 @@
+"""Screenshot runner: drives the seed demo UI and saves PNGs to /out.
+
+Runs inside the compose network; browser resolves 'web' and 'api' directly.
+"""
+import json
+import sys
+import time
+import urllib.request
+
+from playwright.sync_api import sync_playwright
+
+BASE = "http://web"
+API = "http://api:8000/api"
+OUT = "/out"
+
+
+def api(method, path, body=None):
+    req = urllib.request.Request(
+        API + path,
+        data=json.dumps(body).encode() if body else None,
+        method=method,
+        headers={"Content-Type": "application/json"},
+    )
+    with urllib.request.urlopen(req, timeout=30) as r:
+        return json.loads(r.read())
+
+
+def main():
+    # Idempotent: ensures full demo dataset exists
+    seed = api("POST", "/concierge/seed-demo")
+    print("seed:", json.dumps(seed)[:200])
+
+    apps = api("GET", "/applications")
+    interview = next((a for a in apps if a["state"] == "interviewing"), apps[0])
+    detail_id = interview["id"]
+    print("detail id:", detail_id)
+
+    shots = [
+        ("welcome", "/", {}),          # first-run wizard may redirect away; force below
+        ("welcome", "/welcome", {}),
+        ("today", "/today", {}),
+        ("cv", "/cv", {}),
+        ("research", "/research", {}),
+        ("applications", "/applications", {}),
+        ("detail", f"/applications/{detail_id}", {}),
+    ]
+
+    with sync_playwright() as p:
+        browser = p.chromium.launch(args=["--disable-dev-shm-usage"])
+        page = browser.new_page(viewport={"width": 1440, "height": 900},
+                                device_scale_factor=2)
+        for name, path, _opts in shots[1:]:  # skip the "/" duplicate
+            try:
+                page.goto(BASE + path, wait_until="networkidle", timeout=30000)
+                page.wait_for_timeout(1200)
+                # close possible wizard redirect back
+                if name != "welcome" and page.url.endswith("/welcome"):
+                    page.goto(BASE + path, wait_until="networkidle", timeout=30000)
+                    page.wait_for_timeout(800)
+                page.screenshot(path=f"{OUT}/{name}.png")
+                print("shot:", name, "<-", page.url)
+            except Exception as e:
+                print("FAILED:", name, type(e).__name__, str(e)[:150])
+
+        # Interaction shot: open the Tailor CV panel on an approved application
+        approved = next((a for a in apps if a["state"] in ("approved", "interviewing")), apps[0])
+        try:
+            page.goto(f"{BASE}/applications/{approved['id']}", wait_until="networkidle", timeout=30000)
+            page.wait_for_timeout(1000)
+            btn = page.locator('[data-testid="tailor-cv-btn"]')
+            btn.click(timeout=8000)
+            page.wait_for_selector('[data-testid="tailor-panel"]', timeout=20000)
+            page.wait_for_timeout(800)
+            page.screenshot(path=f"{OUT}/detail-tailor.png")
+            print("shot: detail-tailor")
+        except Exception as e:
+            print("FAILED: detail-tailor", type(e).__name__, str(e)[:150])
+
+        browser.close()
+    print("DONE")
+
+
+if __name__ == "__main__":
+    sys.exit(main())