Fix thin proposals, the hire-rate verdict, the sector list and the thin-dossier warning

Four problems students reported with the proposal platform.

Proposals were thin and quoted the "selected offer". The dossier reader
joined each PDF page or Word file into one block, so the keyword scanner
filed whole pages (cut at 600 characters) as single facts, coaching
headings and market statistics included.
- PDF and Word files are now read with their headings and paragraph
breaks; running headers, footers and page numbers are dropped, and a
file named loosely is placed by its cover-page title.
- Each section of the team templates gets a role: facts are kept; offer,
target client and value proposition only steer the angle; weaknesses
and skills marked "Develop" become things never to claim; roadmaps,
SWOT opportunities and threats, market sizing, income targets and
"how this helps the client" are skipped. Snapshot rows become separate
claims, and promised outcomes are never kept as results.
- The Upwork Profile Optimisation document now outranks the Dossier, and
the Offer Bank is ignored once either is uploaded.
- The proposal prompt uses the offer only for the angle, never names it,
and rewrites coaching text in the first person; internal labels and
pasted capitalised headings are stripped from the output.
- On Groq the request is trimmed to fit the free per-minute allowance,
the critique re-ask is skipped, and GPT-OSS runs at low reasoning
effort. A size retry is always smaller than the first try.
- The no-AI outline is labelled "AI writing was unavailable" instead of
"Your draft is ready", and quotes strength titles, not coaching text.

Every job read "hire rate below 25%". A hire rate the screenshot did not
show was scored as a low one.
- A missing hire rate is now a caution ("check it on Upwork"); only a
visible low rate from a client with 5+ jobs posted is a NO GO, and a
visible rate above zero outranks a stray "Hires: 0".
- The screenshot reader is told that "Hires" under "Activity on this
job" is not the client's total, and the screen asks for the "About the
client" box. The verdict screen lets the user type hire rate, jobs
posted and payment status when they are missing.
- The proposal screen's "not strongly recommended" warning follows the
verdict the user sees, not the hidden fit-score tier.

The interview's industry list had 10 choices. It now has the 30 sectors
named across the discovery-call scripts (Legal and Academia first), the
dropdown accepts typed entries, and the text box is labelled. The skill
categories gain Legal, Accounting, Academic writing, Finance, HR and
Translation.

Good dossiers were called thin because the strength score read file
names only. The folder is now re-scored from the evidence actually read,
and the gap-fill message names what is missing. A 36-page team dossier
moves from 30 to 85 out of 100.

Pricing detection no longer matches "rate" inside words such as
"strategist" or "rated".

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

app/models/schemas.py

@@ -42,10 +42,14 @@ SourceType = Literal[
 
 SOURCE_PRIORITY: dict[str, int] = {
     "structured_profile_json": 1,
-    "skillarbitrage_dossier_roadmap": 2,
-    "linkedin_optimization": 3,
-    "offer_blueprint": 4,
-    "upwork_profile": 5,
+    # The Upwork Profile Optimisation document is already written for
+    # clients, in the first person, with the student's real numbers, so it
+    # outranks the Dossier, which is written to the student. The Offer Bank
+    # lists offers the student did not choose, so it ranks below both.
+    "upwork_profile": 2,
+    "skillarbitrage_dossier_roadmap": 3,
+    "linkedin_optimization": 4,
+    "offer_blueprint": 5,
     "linkedin_profile": 6,
     "pricing_or_service_package": 7,
     "portfolio_or_case_study": 8,

app/prompts/proposal_prompt.py

@@ -94,10 +94,21 @@ anywhere in the proposal.
 Evidence marked "Practice project (self-initiated, not client work)" is real
 work the person did on their own. Never present it as a client engagement, a
 paid project or a client result.
+Much of the evidence comes from coaching documents written TO the freelancer
+("You review every product page…", "Your strength is…"). Rewrite it in the
+freelancer's own first-person voice; never copy it word for word. Outcomes an
+offer promises ("increase conversion by 40-80%", "at least 30% within 90
+days") are goals, not past results: never present them as something the
+freelancer has achieved. Never mention market-size statistics, income
+targets, the freelancer's training programme, or what a document calls
+itself.
 
 CHECK A2 — PROFILE ALIGNMENT (use the <profile> for positioning + voice)
 The proposal must read as if written BY the person in <profile>:
-- Anchor the angle in their "selected_offer" and "title_or_positioning".
+- Use "selected_offer" and "title_or_positioning" only to choose the angle.
+  Never quote them and never name the offer: internal labels such as
+  "Offer 2", "Part A", "Niche 1A", "selected offer" or "offer statement"
+  must not appear anywhere in the proposal.
 - Lead with their core strength / unique background from "strengths"
   (e.g. a sales/communications background, a specific industry, a metric).
 - Match the writing voice and tone implied by their profile.

app/services/beginner_evaluator.py

@@ -15,7 +15,8 @@ offline (and in tests).
 The 9 signals (each votes GO / CAUTION / NO GO):
 
  1. Proposals     — <20 GO · 20-50 CAUTION · 50+ NO GO
- 2. Hire rate     — 50%+ GO · 25-50% CAUTION · <25% / 0% / no data NO GO
+ 2. Hire rate     — 50%+ GO · 25-50% CAUTION · <25% NO GO (only for a client
+                    with a track record) · not visible CAUTION · new client GO
  3. Payment       — verified GO · not verified NO GO · no data CAUTION
  4. Client rating — 4.8+ GO · 4.5-4.8 CAUTION · <4.5 NO GO · no rating CAUTION
  5. Job desc.     — clear scope GO · everything else CAUTION (never NO GO)
@@ -65,8 +66,8 @@ REASON_PROPOSALS_50_PLUS = (
     "for a beginner profile."
 )
 REASON_HIRE_RATE_LOW = (
-    "The client's hire rate is below 25% (or shows no hires), so they rarely "
-    "hire — a high risk of wasted connects."
+    "The client has posted several jobs but hires for fewer than 1 in 4, so "
+    "they rarely hire — a high risk of wasted connects."
 )
 REASON_PAYMENT_NOT_VERIFIED = (
     "Payment is not verified, so there is a higher risk of not getting paid."
@@ -92,6 +93,20 @@ WARN_PROPOSALS_20_49 = (
     "Competition is moderate (20-50 proposals), so the proposal must be very strong."
 )
 WARN_HIRE_RATE_MID = "The client's hire rate is 25-50%, so a hire is not guaranteed."
+# A hire rate that could not be read is unknown, not low: it is checked by the
+# user, never held against the client.
+WARN_HIRE_RATE_UNKNOWN = (
+    "The client's hire rate was not visible in the screenshot. Check it in the "
+    "'About the client' box on Upwork before applying."
+)
+WARN_HIRE_RATE_LOW_UNPROVEN = (
+    "The hire rate looks low, but the client's job history was not visible. "
+    "Check how many jobs they have posted before applying."
+)
+WARN_ACTIVITY_UNPROVEN = (
+    "The client shows no hires yet, but their job history was not visible. "
+    "Check how many jobs they have posted before applying."
+)
 WARN_PAYMENT_UNKNOWN = "Payment verification was not visible, so confirm it before applying."
 WARN_RATING_MID = (
     "The client's rating is 4.5-4.8 — read the past reviews carefully before applying."
@@ -403,6 +418,10 @@ def _client_activity_bucket(jobs: Optional[int], hires: Optional[int], hire_rate
     """
     if hires is None and jobs is None and hire_rate is None:
         return "not_visible"
+    # A visible hire rate above zero outranks a hires count of 0: that 0 is
+    # most likely the "Hires: 0" Upwork shows for this one open post.
+    if hire_rate is not None and hire_rate > 0:
+        return "consistent" if hire_rate >= 50 else "mixed"
     # Explicit "posted jobs, hired no one" signal.
     if hires == 0 and ((jobs or 0) >= 1 or (hire_rate is not None and hire_rate == 0)):
         return "dead"
@@ -493,16 +512,22 @@ def evaluate(
     jobs_n = (_ints(jobs_value)[0] if _ints(jobs_value) else None)
     hires_n = (_ints(hires_value)[0] if _ints(hires_value) else None)
 
-    # If the hire-rate % isn't shown but the client has explicitly made 0 hires
-    # (a brand-new client), their effective hire rate IS 0% — record it as 0
-    # rather than "Not visible", so the table shows real data, not a blank.
-    if hire is None and hires_n == 0:
-        hire = 0.0
+    # If the hire-rate % isn't shown but both the client's jobs posted and
+    # total hires are, the rate can be worked out from them. Both counts are
+    # needed: a hires count on its own may be the "Hires: 0" that Upwork shows
+    # for this one open post, which says nothing about the client.
+    if hire is None and hires_n is not None and jobs_n:
+        hire = min(100.0, 100.0 * hires_n / jobs_n)
         if _is_missing(hire_value):
-            hire_value = "0% (no hires yet)"
+            hire_value = f"{round(hire)}% ({hires_n} hires from {jobs_n} jobs)"
     hire_b = _hire_rate_bucket(hire)
     activity_b = _client_activity_bucket(jobs_n, hires_n, hire)
     new_client = _is_new_client(jobs_n, hires_n)
+    # A low hire rate only means something once the client has a real record:
+    # enough jobs posted (or, failing that, enough hires) to judge them by.
+    # Without that evidence, low or missing numbers are a reason to check,
+    # never a reason to skip the job.
+    has_history = not new_client and (jobs_n is not None or hires_n is not None)
 
     # Signal 5 — job description quality (LLM if supplied, else heuristic).
     if isinstance(job_desc_quality, dict) and job_desc_quality.get("status") in (GO, CAUTION):
@@ -530,9 +555,10 @@ def evaluate(
     else:
         add("proposals", "Proposals", NOT_VISIBLE, CAUTION, "Proposal count was not visible.")
 
-    # 2 — Hire rate. A low/absent hire rate is a NO GO for an ESTABLISHED client,
-    # but for a NEW client (few jobs posted) it is expected and fine — beginners
-    # often win work from new clients, so we don't penalise it.
+    # 2 — Hire rate. A low hire rate is a NO GO only for a client with a real
+    # track record. For a NEW client (few jobs posted) it is expected and fine —
+    # beginners often win work from new clients. A rate that was not visible,
+    # or a low rate with no visible history, is a CAUTION: check it on Upwork.
     if hire_b == "high":
         add("hire_rate", "Hire Rate", hire_value, GO)
     elif hire_b == "mid":
@@ -540,10 +566,12 @@ def evaluate(
     elif new_client:
         add("hire_rate", "Hire Rate", (hire_value or NOT_VISIBLE) + " — new client", GO,
             "")
-    elif hire_b == "low":
+    elif hire_b == "low" and has_history:
         add("hire_rate", "Hire Rate", hire_value, NO_GO, REASON_HIRE_RATE_LOW)
+    elif hire_b == "low":
+        add("hire_rate", "Hire Rate", hire_value, CAUTION, WARN_HIRE_RATE_LOW_UNPROVEN)
     else:
-        add("hire_rate", "Hire Rate", NOT_VISIBLE, NO_GO, REASON_HIRE_RATE_LOW)
+        add("hire_rate", "Hire Rate", NOT_VISIBLE, CAUTION, WARN_HIRE_RATE_UNKNOWN)
 
     # 3 — Payment verified
     if payment == "verified":
@@ -618,8 +646,10 @@ def evaluate(
             (data if data != NOT_VISIBLE else "New client") + " — new client", GO, "")
     elif activity_b == "mixed":
         add("client_activity", "Client Activity", data, CAUTION, WARN_ACTIVITY_MIXED)
-    elif activity_b == "dead":
+    elif activity_b == "dead" and has_history:
         add("client_activity", "Client Activity", data, NO_GO, REASON_ACTIVITY_DEAD)
+    elif activity_b == "dead":
+        add("client_activity", "Client Activity", data, CAUTION, WARN_ACTIVITY_UNPROVEN)
     else:
         add("client_activity", "Client Activity", NOT_VISIBLE, CAUTION, WARN_ACTIVITY_UNKNOWN)
 
@@ -696,8 +726,10 @@ def evaluate(
 
     score_signals = {
         "payment_not_verified": payment == "not_verified",
-        # A new client's blank/low hire rate is not held against them.
-        "hire_rate_below_25": (hire_b == "low" or hire_b == "not_visible") and not new_client,
+        # Only a visible low rate from a client with a track record counts
+        # against them; a blank rate, or a new client's low one, does not.
+        "hire_rate_below_25": hire_b == "low" and has_history,
+        "hire_rate_unknown": hire_b == "not_visible" and not new_client,
         "hire_rate_mid": hire_b == "mid",
         "hire_rate_high": hire_b == "high",
         "rating_below_4_5": rating_b == "low",

app/services/dossier_reader.py

@@ -6,8 +6,10 @@ raw extracted text is never logged.
 
 Supported file types and their handlers:
 
-* ``.pdf``  -> ``pdfplumber`` (one chunk per page).
-* ``.docx`` -> ``python-docx`` (paragraphs + tables, single chunk per file).
+* ``.pdf``  -> ``pdfplumber`` (one chunk per page; headings and paragraph
+  breaks rebuilt from the layout).
+* ``.docx`` -> ``python-docx`` (paragraphs + tables in document order, single
+  chunk per file; headings marked).
 * ``.txt`` / ``.md`` -> read as utf-8 text.
 * ``.json`` -> parsed via ``json``. The structured payload is preserved.
 * ``.csv`` -> read as text plus a small ``json_data`` preview.
@@ -22,6 +24,8 @@ from __future__ import annotations
 import csv
 import hashlib
 import json
+import re
+import statistics
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Iterable, Optional
@@ -129,6 +133,179 @@ def _read_csv_preview(path: Path, max_rows: int = 50) -> tuple[str, list[list[st
     return "\n".join(text_lines), rows, None
 
 
+# ---------------------------------------------------------------------------
+# Document layout: headings and paragraphs
+# ---------------------------------------------------------------------------
+#
+# The evidence scanner works paragraph by paragraph and reads a Markdown-style
+# "## Heading" paragraph as the start of a section. PDF and Word files carry
+# neither marker on their own — pdfplumber returns a page as single-spaced
+# lines and Word paragraphs used to be joined with single line breaks — so a
+# whole page or file reached the scanner as one paragraph. The helpers below
+# rebuild both: headings come out as "## " (top level) or "### " (sub level)
+# paragraphs, and body text is split where the layout shows a paragraph break.
+
+# A line set this many points larger than the body text is a heading, and
+# this many more is a top-level heading.
+_HEADING_SIZE_STEP = 1.5
+_TOP_HEADING_SIZE_STEP = 4.0
+_HEADING_MAX_CHARS = 160
+# A gap between lines this many times the usual line gap starts a paragraph.
+_PARAGRAPH_GAP_FACTOR = 1.8
+_LIST_ITEM = re.compile(r"^\s*(?:\d{1,2}[.)]|[•▪●◦]|\\?#)\s")
+
+
+def _is_caps_heading(text: str) -> bool:
+    """True for a short ALL-CAPS line such as "HOW THIS HELPS THE CLIENT".
+
+    Five letters is the floor, so a lone acronym ("HSBC") in body text is not
+    mistaken for a heading.
+    """
+    stripped = text.strip()
+    letters = [c for c in stripped if c.isalpha()]
+    return (
+        len(letters) >= 5
+        and len(stripped) <= 80
+        and all(c.isupper() for c in letters)
+        and not stripped.endswith((".", ","))
+    )
+
+
+def _heading_marker(level: int, text: str) -> str:
+    return ("## " if level == 1 else "### ") + " ".join(text.split())[:_HEADING_MAX_CHARS]
+
+
+def _pdf_line_size(line: dict) -> float:
+    sizes = [float(c.get("size") or 0.0) for c in line.get("chars") or []]
+    return max(sizes) if sizes else 0.0
+
+
+def _pdf_line_bold(line: dict) -> bool:
+    chars = [c for c in line.get("chars") or [] if str(c.get("text") or "").strip()]
+    return bool(chars) and all("bold" in str(c.get("fontname") or "").lower() for c in chars)
+
+
+def _pdf_body_size(pages_lines: list[list[dict]]) -> float:
+    """The most common text size in the document, weighted by characters."""
+    weights: dict[float, int] = {}
+    for lines in pages_lines:
+        for line in lines:
+            size = round(_pdf_line_size(line), 1)
+            weights[size] = weights.get(size, 0) + len(str(line.get("text") or ""))
+    return max(weights, key=weights.get) if weights else 0.0
+
+
+def _pdf_page_text(
+    lines: list[dict], body_size: float, open_headings: list[str]
+) -> str:
+    """Rebuild one page's text with heading markers and paragraph breaks.
+
+    ``open_headings`` holds the top-level and sub-level heading in force when
+    the page starts; it is repeated at the top of the page (so a section that
+    runs across a page break keeps its name) and updated in place.
+    """
+    gaps = [
+        float(cur["top"]) - float(prev["bottom"])
+        for prev, cur in zip(lines, lines[1:])
+        if float(cur["top"]) >= float(prev["bottom"])
+        and abs(_pdf_line_size(cur) - body_size) < _HEADING_SIZE_STEP
+    ]
+    usual_gap = statistics.median(gaps) if gaps else 0.0
+    paragraph_gap = max(usual_gap * _PARAGRAPH_GAP_FACTOR, usual_gap + body_size * 0.5, 3.0)
+
+    blocks: list[str] = [h for h in open_headings if h]
+    paragraph: list[str] = []
+    heading: Optional[tuple[int, list[str]]] = None
+    prev: Optional[dict] = None
+
+    def close_paragraph() -> None:
+        if paragraph:
+            blocks.append("\n".join(paragraph))
+            paragraph.clear()
+
+    def close_heading() -> None:
+        nonlocal heading
+        if heading:
+            level, parts = heading
+            marker = _heading_marker(level, " ".join(parts))
+            blocks.append(marker)
+            if level == 1:
+                open_headings[:] = [marker, ""]
+            else:
+                open_headings[1] = marker
+            heading = None
+
+    for line in lines:
+        text = str(line.get("text") or "").strip()
+        if not text:
+            continue
+        size = _pdf_line_size(line)
+        level = 0
+        if size >= body_size + _TOP_HEADING_SIZE_STEP:
+            level = 1
+        elif size >= body_size + _HEADING_SIZE_STEP or _is_caps_heading(text):
+            level = 2
+        gap = float(line["top"]) - float(prev["bottom"]) if prev else 0.0
+        if level:
+            close_paragraph()
+            # A heading that wraps onto a second line continues the same
+            # heading rather than starting another one.
+            if heading and heading[0] == level and gap < paragraph_gap:
+                heading[1].append(text)
+            else:
+                close_heading()
+                heading = (level, [text])
+        else:
+            close_heading()
+            # A bold lead-in line ("14 Years of Sales-Driven…") titles the
+            # paragraph under it, so the gap just after it is not a break.
+            after_lead = (
+                len(paragraph) == 1 and prev is not None
+                and _pdf_line_bold(prev) and len(paragraph[0]) < 100
+            )
+            if paragraph and (
+                (gap > paragraph_gap and not after_lead) or _LIST_ITEM.match(text)
+            ):
+                close_paragraph()
+            paragraph.append(text)
+        prev = line
+    close_heading()
+    close_paragraph()
+    return "\n\n".join(blocks)
+
+
+def _drop_running_lines(
+    pages_lines: list[Optional[list[dict]]],
+) -> list[Optional[list[dict]]]:
+    """Remove page numbers and the header/footer lines repeated on most pages.
+
+    A footer such as "SKILL ARBITRAGE — UPWORK OPTIMISATION | 7" is set in
+    capitals, so left in place it would read as a heading at the foot of
+    every page and change the section the next page belongs to.
+    """
+    def key(line: dict) -> str:
+        return re.sub(r"\d+", "#", " ".join(str(line.get("text") or "").lower().split()))
+
+    readable = [lines for lines in pages_lines if lines]
+    counts: dict[str, int] = {}
+    for lines in readable:
+        for k in {key(line) for line in lines}:
+            counts[k] = counts.get(k, 0) + 1
+    threshold = max(3, int(len(readable) * 0.3))
+    running = {k for k, n in counts.items() if n >= threshold}
+
+    cleaned: list[Optional[list[dict]]] = []
+    for lines in pages_lines:
+        if lines is None:
+            cleaned.append(None)
+            continue
+        cleaned.append([
+            line for line in lines
+            if key(line) not in running and key(line).strip("# ")
+        ])
+    return cleaned
+
+
 def _pdf_chunks(
     path: Path,
     base_meta: dict,
@@ -142,27 +319,41 @@ def _pdf_chunks(
     try:
         with pdfplumber.open(str(path)) as pdf:
             page_iter = pdf.pages[:_PDF_MAX_PAGES]
+            # Read every page's lines first: the body text size, which tells
+            # a heading from body text, is a property of the whole document.
+            pages_lines: list[Optional[list[dict]]] = []
+            failures: dict[int, str] = {}
             for index, page in enumerate(page_iter, start=1):
                 try:
-                    text = page.extract_text() or ""
+                    pages_lines.append(page.extract_text_lines(return_chars=True) or [])
                 except Exception as exc:  # noqa: BLE001 - per-page tolerance
+                    pages_lines.append(None)
+                    failures[index] = f"page extract failed: {exc.__class__.__name__}"
+            pages_lines = _drop_running_lines(pages_lines)
+            body_size = _pdf_body_size([lines for lines in pages_lines if lines])
+            open_headings = ["", ""]
+            for index, lines in enumerate(pages_lines, start=1):
+                if lines is None:
                     records.append(
                         ChunkRecord(
                             chunk_id=_chunk_id(base_meta["file_path"], f"p{index}"),
                             page_number=index,
                             extracted_text="",
                             extraction_status="failed",
-                            extraction_warning=f"page extract failed: {exc.__class__.__name__}",
+                            extraction_warning=failures.get(index),
                             **base_meta,
                         )
                     )
                     continue
+                section = (open_headings[1] or open_headings[0]).lstrip("# ") or None
+                text = _pdf_page_text(lines, body_size, open_headings).strip()
                 records.append(
                     ChunkRecord(
                         chunk_id=_chunk_id(base_meta["file_path"], f"p{index}"),
                         page_number=index,
-                        extracted_text=text.strip(),
-                        extraction_status="ok" if text.strip() else "empty",
+                        section_name=section,
+                        extracted_text=text,
+                        extraction_status="ok" if text else "empty",
                         **base_meta,
                     )
                 )
@@ -171,6 +362,51 @@ def _pdf_chunks(
     return records, None
 
 
+# A team document names itself on its cover page even when the file name
+# does not ("Final.pdf"). A PDF or Word file its name could not place is
+# placed by these title phrases instead; checked in order, first match wins.
+_TITLE_RULES: tuple[tuple[SourceType, tuple[str, ...]], ...] = (
+    ("upwork_profile", ("upwork profile optimi", "upwork optimi")),
+    ("offer_blueprint", ("offer bank", "offer blueprint")),
+    ("linkedin_optimization", ("linkedin optimi",)),
+    ("skillarbitrage_dossier_roadmap", ("dossier", "roadmap")),
+    ("discovery_call_transcript", ("transcript",)),
+)
+_UNPLACED_SOURCES = frozenset({"unknown_supported_file", "generic_profile_document"})
+_TITLE_WINDOW_CHARS = 600
+
+
+def _place_by_title(chunks: list[ChunkRecord]) -> list[ChunkRecord]:
+    """Re-type an unplaced file's chunks from the title on its first page."""
+    if not chunks or chunks[0].source_type not in _UNPLACED_SOURCES:
+        return chunks
+    head = " ".join(chunks[0].extracted_text[:_TITLE_WINDOW_CHARS].lower().replace("#", " ").split())
+    # Covers often letter-space their titles ("S K I L L  A R B I T R A G E").
+    squashed = head.replace(" ", "")
+    for source_type, phrases in _TITLE_RULES:
+        if any(p in head or p.replace(" ", "") in squashed for p in phrases):
+            for chunk in chunks:
+                chunk.source_type = source_type
+                chunk.source_priority = SOURCE_PRIORITY[source_type]
+            break
+    return chunks
+
+
+def _docx_heading_level(paragraph) -> int:
+    """0 for body text, 1 for a top-level heading, 2 for a sub-heading."""
+    text = paragraph.text.strip()
+    style = str(getattr(getattr(paragraph, "style", None), "name", "") or "").lower()
+    if style in {"title", "heading 1"}:
+        return 1
+    if style.startswith("heading"):
+        return 2
+    runs = [r for r in paragraph.runs if r.text.strip()]
+    all_bold = bool(runs) and all(r.bold for r in runs)
+    if _is_caps_heading(text) or (all_bold and len(text) <= 80 and not text.endswith(".")):
+        return 2
+    return 0
+
+
 def _docx_chunk(
     path: Path,
     base_meta: dict,
@@ -185,15 +421,28 @@ def _docx_chunk(
     except Exception as exc:  # noqa: BLE001
         return [], f"docx open failed: {exc.__class__.__name__}"
 
-    paragraphs = [p.text for p in document.paragraphs if p.text.strip()]
-    table_texts: list[str] = []
-    for table in document.tables:
-        for row in table.rows:
-            cells = [cell.text.strip() for cell in row.cells if cell.text.strip()]
-            if cells:
-                table_texts.append(" | ".join(cells))
+    # Paragraphs and tables are read in document order, so a table (such as a
+    # key/value snapshot) stays inside the section its heading opens. Each
+    # Word paragraph is its own paragraph here, and headings are marked.
+    blocks: list[str] = []
+    for item in document.iter_inner_content():
+        if hasattr(item, "rows"):
+            for row in item.rows:
+                cells: list[str] = []
+                for cell in row.cells:
+                    value = cell.text.strip()
+                    if value and value not in cells:
+                        cells.append(value)
+                if cells:
+                    blocks.append(" | ".join(cells))
+            continue
+        text = item.text.strip()
+        if not text:
+            continue
+        level = _docx_heading_level(item)
+        blocks.append(_heading_marker(level, text) if level else text)
 
-    full_text = "\n".join(paragraphs + table_texts).strip()
+    full_text = "\n\n".join(blocks).strip()
     status: ExtractionStatus = "ok" if full_text else "empty"
     return (
         [
@@ -324,13 +573,13 @@ def _read_one_file(path: Path, rel_path: Path, ext: str) -> list[ChunkRecord]:
         if pdf_chunks:
             if warning:
                 pdf_chunks[-1].extraction_warning = _sanitize_warning(warning)
-            return pdf_chunks
+            return _place_by_title(pdf_chunks)
         return [_failed_chunk(path, base_meta, warning or "no pages")]
 
     if ext == ".docx":
         docx_chunks, warning = _docx_chunk(path, base_meta)
         if docx_chunks:
-            return docx_chunks
+            return _place_by_title(docx_chunks)
         return [_failed_chunk(path, base_meta, warning or "no content")]
 
     if ext in {".txt", ".md"}:

app/services/evidence_index.py

@@ -105,10 +105,6 @@ _SERVICE_LINE_HINTS = ("services:", "service:", "offerings:", "i offer", "we off
 _DELIVERABLE_HINTS = ("deliverables:", "deliverable:", "what you get", "you receive")
 _TARGET_CLIENT_HINTS = ("target client", "ideal client", "client avatar", "icp")
 _OFFER_HINTS = ("selected offer", "primary offer", "headline offer", "offer:", "blueprint:")
-_PRICING_HINTS = (
-    "rate", "rates", "pricing", "package", "retainer", "hourly", "fixed-fee",
-    "deposit", "fee:", "rate card",
-)
 _CERTIFICATION_HINTS = ("certified", "certification", "course completion", "credential")
 _EDUCATION_HINTS = ("bachelor", "master", "phd", "b.sc", "m.sc", "diploma", "degree")
 _LANGUAGE_HINTS = ("languages:", "language:", "fluent in", "native speaker")
@@ -130,6 +126,186 @@ def _split_csv_like(value: str) -> list[str]:
     return [s.strip() for s in re.split(r"[,;\n•·]+", value) if s.strip()]
 
 
+# ---------------------------------------------------------------------------
+# Team document sections
+# ---------------------------------------------------------------------------
+#
+# The program team writes every Dossier, Offer Bank and Upwork Profile
+# Optimisation document from one template, and each heading says what its
+# section is for. Only some sections hold facts a client may read; the rest
+# coach the student and must never reach a proposal. Each heading is matched
+# by phrase, in this order, first match wins:
+#
+# * skip         — coaching: how-to notes, roadmaps, SWOT opportunities and
+#                  threats, outreach plans, video scripts, income targets.
+# * avoid        — weaknesses and gaps: kept only as things never to claim.
+# * deliverables — what the offer delivers: one capability per paragraph,
+#                  never a result (its numbers are promises, not outcomes).
+# * services     — service tiers and rates: services, pricing, and any skill
+#                  the document says is still being developed.
+# * facts        — snapshot, strengths, bio, employment, education, skills.
+# * angle        — offer statement, target client, value proposition: they
+#                  steer the pitch, so only positioning-type claims are kept.
+#
+# A sub-heading the table does not know inherits its parent's role (so
+# "SECTION 1 — HOOK" under "Video Script" is skipped too); an unknown
+# top-level heading, or a document with no known heading at all, is scanned
+# exactly as before.
+_SECTION_ROLES: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("skip", (
+        "skill arbitrage", "how to use", "contents", "roadmap", "phase ", "week ", "by now you must",
+        "tasks for this week", "before moving to", "completion checklist",
+        "acquisition", "opportunit", "threat", "how this helps", "what life looks like",
+        "smartest move", "profile photo", "video script", "recording guideline",
+        "upload your video", "how to upload", "linked accounts", "availability setting",
+        "categories", "income", "client kpis", "upgrade trigger", "swot analysis",
+        "target list", "content pack",
+    )),
+    ("avoid", ("weakness", "additional gaps", "biggest challenge", "limitation", "out of scope")),
+    ("deliverables", ("what you will deliver", "deliverables", "what you get")),
+    ("services", ("service stack", "service fit", "tier ", "rate recommendation", "pricing")),
+    ("facts", (
+        "snapshot", "strength", "bio", "overview", "headline", "employment",
+        "work history", "experience", "education", "language", "skill",
+        "certific", "portfolio", "testimonial", "about me", "background",
+    )),
+    ("angle", (
+        "selected offer", "offer statement", "your offer", "offer ", "niche",
+        "target client", "who you serve", "ideal client", "value proposition",
+        "the pain", "positioning",
+    )),
+)
+
+# Claim types an "angle" section may contribute. Its metrics are promises
+# ("increase conversion by 40-80%"), never results, so they are not kept;
+# nor is pricing, since the money it mentions is usually the client's
+# revenue ("brands doing Rs 10-50 lakh/month"), not the student's rate.
+_ANGLE_CLAIM_TYPES = frozenset({
+    "positioning", "selected_offer", "target_client", "service",
+    "deliverable", "industry", "guarantee", "proposal_preference",
+})
+
+# Paragraphs that coach the student wherever they appear: sales copy about
+# the client's benefit, market sizing, and week-by-week task lists.
+_COACHING_PARAGRAPH = re.compile(
+    r"^\s*how this helps|market (?:was )?valued|market size|market basis|\bcagr\b|"
+    r"\bbillion\b|income target|by now you must have|tasks for this week|"
+    # A table of contents: three or more "N Title P" entries in a row.
+    r"(?:\d{1,2}\s+[A-Z][^\d\n]{2,60}?\s+\d{1,3}\s+){3,}",
+    re.IGNORECASE,
+)
+
+# An outcome the offer promises to deliver ("conversion improvement of at
+# least 30% within 30 days"). The student has not achieved it yet, so it is
+# never kept as a service or a result.
+_PROMISED_OUTCOME = re.compile(
+    r"\bat least \d|\bimprovement (?:of|from)\b|\breduction of\b|\bgrowth of\b|"
+    r"^\s*upgrade trigger",
+    re.IGNORECASE,
+)
+
+# Pricing language. Whole words only: as substrings, "rate" matched
+# "strategist", "rated" and "conversion rate", and filed them as pricing.
+_PRICING_PATTERN = re.compile(
+    r"\bpricing\b|\bretainers?\b|\bhourly\b|\bper hour\b|/\s?hr\b|\brate card\b|"
+    r"\bfixed[- ](?:fee|price)\b|\bdeposit\b|\bfee:|\bpackages?\b|"
+    r"(?:\brs\.?|\binr|\busd|\$|₹)\s?\d",
+    re.IGNORECASE,
+)
+
+# A skill the document says is not ready to sell yet.
+_DEVELOPING_SKILL = re.compile(
+    r"\bdevelop \(|requires (?:training|learning)|★★☆|★☆☆|outside (?:your|my) comfort",
+    re.IGNORECASE,
+)
+
+_HEADING_LINE = re.compile(r"^\s*(#{1,6})\s+(.+?)\s*$")
+
+# Documents written around the one offer the student chose.
+_CHOSEN_OFFER_SOURCES = frozenset({"skillarbitrage_dossier_roadmap", "upwork_profile"})
+
+
+def _section_role(heading: str, level: int, current: str) -> str:
+    """The role a heading opens; see ``_SECTION_ROLES``."""
+    text = " ".join(heading.lower().split())
+    for role, phrases in _SECTION_ROLES:
+        if any(phrase in text for phrase in phrases):
+            return role
+    if level >= 3 and current != "unknown":
+        return current
+    return "unknown"
+
+
+# Labels on the dossier's "Student Snapshot" table, each with the claim it
+# becomes. ``None`` marks private planning notes that are dropped.
+_SNAPSHOT_LABELS: tuple[tuple[str, Optional[str]], ...] = (
+    ("professional qualifications", "certification"),
+    ("tools you already know", "tool"),
+    ("target client type", "target_client"),
+    ("english proficiency", "language"),
+    ("biggest challenge", None),
+    ("income target", None),
+    ("selected offer", "selected_offer"),
+    ("subject domain", "industry"),
+    ("target client", "target_client"),
+    ("languages", "language"),
+    ("education", "education"),
+    ("location", "location"),
+    ("name", "identity"),
+)
+_SNAPSHOT_SPLIT = re.compile(
+    r"(?im)^\s*(" + "|".join(re.escape(label) for label, _ in _SNAPSHOT_LABELS)
+    + r")\b\s*[:|]?\s*"
+)
+# "Offer 2 — Academic Writing…" → "Academic Writing…": the offer's number is
+# an internal label from the Offer Bank, never something a client should see.
+_OFFER_LABEL = re.compile(r"^\s*(?:offer|niche)\s*\d+\s*[a-z]?\s*[—–:\-]\s*", re.IGNORECASE)
+
+
+def _strip_offer_label(text: str) -> str:
+    return _OFFER_LABEL.sub("", text).strip()
+
+
+def _snapshot_proofs(chunk: ChunkRecord, paragraph: str, location: str) -> list[ProofPoint]:
+    """Turn "Label value" rows from a Student Snapshot into separate claims."""
+    proofs: list[ProofPoint] = []
+    parts = _SNAPSHOT_SPLIT.split(paragraph)
+    claim_for = dict(_SNAPSHOT_LABELS)
+    # re.split with one group gives [before, label, value, label, value, ...].
+    for label, value in zip(parts[1::2], parts[2::2]):
+        claim_type = claim_for.get(label.lower())
+        value = " ".join(value.split())
+        if not claim_type or not value or value.lower().startswith(("no ", "none")):
+            continue
+        if claim_type == "selected_offer":
+            value = _strip_offer_label(value)
+        kwargs: dict[str, Any] = {}
+        if claim_type == "tool":
+            kwargs["tools"] = [re.sub(r"\(.*?\)", "", t).strip() for t in _split_csv_like(value)]
+            basic = [
+                re.sub(r"\(.*?\)", "", t).strip()
+                for t in _split_csv_like(value)
+                if re.search(r"\(\s*basic", t, re.IGNORECASE)
+            ]
+            if basic:
+                proofs.append(_make_proof(
+                    chunk=chunk, claim_type="weakness_or_constraint",
+                    claim_text="Basic level only, do not oversell: " + ", ".join(basic),
+                    location=location,
+                ))
+        elif claim_type == "industry":
+            kwargs["industries"] = [
+                re.sub(r"\(.*?\)", "", t).strip() for t in _split_csv_like(value)
+            ]
+        proofs.append(_make_proof(
+            chunk=chunk, claim_type=claim_type,  # type: ignore[arg-type]
+            claim_text=value, location=location,
+            normalized_value=value if claim_type in {"identity", "selected_offer", "location"} else None,
+            **kwargs,
+        ))
+    return proofs
+
+
 def _make_proof(
     *,
     chunk: ChunkRecord,
@@ -173,8 +349,26 @@ def _scan_text_chunk(chunk: ChunkRecord) -> list[ProofPoint]:
 
     paragraphs = _split_paragraphs(text)
     current_section: Optional[str] = chunk.section_name
+    # The role of the section being read (see _SECTION_ROLES), and whether
+    # any heading in this chunk was a known template heading.
+    role = "unknown"
+    saw_template_section = False
+    snapshot_label = ""
 
     for idx, paragraph in enumerate(paragraphs):
+        # Marked headings ("## Your Strengths") open a section and are never
+        # claims themselves. A paragraph whose first line is the heading and
+        # whose body follows (a Markdown file) keeps the body.
+        lines = paragraph.splitlines()
+        while lines and _HEADING_LINE.match(lines[0]):
+            hashes, heading = _HEADING_LINE.match(lines[0]).groups()  # type: ignore[union-attr]
+            current_section = heading.strip()
+            role = _section_role(heading, len(hashes), role)
+            saw_template_section = saw_template_section or role != "unknown"
+            lines = lines[1:]
+        if not lines:
+            continue
+        paragraph = "\n".join(lines)
         lower = paragraph.lower()
         location = f"{base_location}#para{idx + 1}"
         if current_section:
@@ -184,6 +378,51 @@ def _scan_text_chunk(chunk: ChunkRecord) -> list[ProofPoint]:
         if _SECTION_HEADER.match(first_line):
             current_section = first_line.strip().strip("#").strip()
 
+        if role == "skip" or _COACHING_PARAGRAPH.search(paragraph):
+            continue
+        # A page number or a stray fragment is not evidence.
+        if role != "unknown" and not re.search(r"[A-Za-z]{3}", paragraph):
+            continue
+        if role == "avoid":
+            proofs.append(_make_proof(
+                chunk=chunk, claim_type="weakness_or_constraint",
+                claim_text=paragraph[:300], location=location,
+            ))
+            continue
+        if role == "deliverables":
+            proofs.append(_make_proof(
+                chunk=chunk, claim_type="deliverable",
+                claim_text=paragraph[:300], location=location,
+            ))
+            continue
+        if role == "services":
+            if _DEVELOPING_SKILL.search(paragraph):
+                claim_type: ClaimType = "weakness_or_constraint"
+            elif _PROMISED_OUTCOME.search(paragraph):
+                continue
+            elif _PRICING_PATTERN.search(paragraph):
+                claim_type = "pricing"
+            else:
+                claim_type = "service"
+            proofs.append(_make_proof(
+                chunk=chunk, claim_type=claim_type,
+                claim_text=paragraph[:300], location=location,
+            ))
+            continue
+        if role == "facts" and "snapshot" in (current_section or "").lower():
+            # A label laid out on its own line ("Tools You Already Know")
+            # names the value in the paragraph that follows it.
+            if snapshot_label:
+                paragraph = snapshot_label + " " + paragraph
+                snapshot_label = ""
+            if _SNAPSHOT_SPLIT.fullmatch(paragraph.strip() + " "):
+                snapshot_label = paragraph.strip()
+                continue
+            proofs.extend(_snapshot_proofs(chunk, paragraph, location))
+            continue
+        snapshot_label = ""
+        start = len(proofs)
+
         def line_after(hint: str) -> Optional[str]:
             pos = lower.find(hint)
             if pos == -1:
@@ -296,7 +535,7 @@ def _scan_text_chunk(chunk: ChunkRecord) -> list[ProofPoint]:
                 )
             )
 
-        if any(hint in lower for hint in _PRICING_HINTS):
+        if _PRICING_PATTERN.search(paragraph):
             proofs.append(
                 _make_proof(
                     chunk=chunk,
@@ -420,7 +659,45 @@ def _scan_text_chunk(chunk: ChunkRecord) -> list[ProofPoint]:
                 )
             )
 
-    if not proofs:
+        if role == "angle":
+            proofs[start:] = [p for p in proofs[start:] if p.claim_type in _ANGLE_CLAIM_TYPES]
+            for p in proofs[start:]:
+                if p.claim_type == "selected_offer":
+                    p.claim_text = _strip_offer_label(p.claim_text)
+        elif (
+            role == "facts"
+            and "strength" in (current_section or "").lower()
+            and not any(p.claim_type == "achievement" for p in proofs[start:])
+        ):
+            # Each paragraph under "Strengths" is one strength; it is filed as
+            # one even when a keyword also filed it as, say, education.
+            proofs.append(_make_proof(
+                chunk=chunk, claim_type="achievement",
+                claim_text=paragraph, location=location,
+            ))
+        elif role == "facts" and len(proofs) == start:
+            # A fact section's paragraph is evidence even when no keyword
+            # fires: a strength reads as one, a role or bio entry as history.
+            section = (current_section or "").lower()
+            if "skill" in section:
+                # A skills list: "1 Academic Writing" or "Academic Writing".
+                skill = re.sub(r"^\s*\d+[.)]?\s*", "", " ".join(paragraph.split()))
+                if skill and len(skill) <= 60:
+                    proofs.append(_make_proof(
+                        chunk=chunk, claim_type="skill", claim_text=skill,
+                        location=location, skills=[skill],
+                    ))
+            else:
+                proofs.append(_make_proof(
+                    chunk=chunk,
+                    claim_type="achievement" if "strength" in section else "experience",
+                    claim_text=paragraph,
+                    location=location,
+                ))
+
+    # A page made only of coaching sections yields nothing on purpose; the
+    # placeholder is for files the scanner could not place at all.
+    if not proofs and not saw_template_section:
         # We still want a placeholder proof from unknown content so that
         # the file shows up in the canonical profile's source summary.
         proofs.append(
@@ -572,10 +849,22 @@ def build(chunks: Iterable[ChunkRecord]) -> list[ProofPoint]:
     ``other_relevant_evidence`` placeholder is emitted so the file is
     not silently dropped from the canonical profile's source summary.
     """
+    chunks = list(chunks)
+    # The Offer Bank lists every offer drafted for the student, including
+    # the ones they did not choose. Once the Dossier (written around the
+    # chosen offer) or the Upwork Profile Optimisation document is present,
+    # the Offer Bank would only mix unchosen offers into the proposals.
+    has_chosen_offer_source = any(
+        c.source_type in _CHOSEN_OFFER_SOURCES
+        and c.extraction_status not in {"failed", "metadata_only", "empty"}
+        for c in chunks
+    )
     index: list[ProofPoint] = []
     for chunk in chunks:
         if chunk.extraction_status in {"failed", "metadata_only", "empty"}:
             continue
+        if has_chosen_offer_source and chunk.source_type == "offer_blueprint":
+            continue
         if chunk.file_type == ".json" and chunk.json_data is not None:
             index.extend(_scan_json_chunk(chunk))
         else:

app/services/folder_validator.py

@@ -68,7 +68,7 @@ _BUCKETS: tuple[tuple[str, str, int], ...] = (
 _FILENAME_RULES: tuple[tuple[SourceType, tuple[str, ...]], ...] = (
     ("linkedin_optimization", ("linkedin optimization", "linkedin optimisation", "linkedin rewrite")),
     ("skillarbitrage_dossier_roadmap", ("skillarbitrage", "dossier", "roadmap")),
-    ("offer_blueprint", ("offer blueprint", "offer-blueprint", "offer_blueprint", "blueprint", "selected offer")),
+    ("offer_blueprint", ("offer blueprint", "offer-blueprint", "offer_blueprint", "blueprint", "selected offer", "offer bank")),
     ("upwork_profile", ("upwork",)),
     ("linkedin_profile", ("linkedin",)),
     ("discovery_call_transcript", ("transcript", "discovery call", "discovery-call", "discovery_call", "call notes")),
@@ -414,6 +414,94 @@ def score_rubric_labels() -> dict[str, str]:
     return {key: label for key, label, _w in _BUCKETS}
 
 
+# ---------------------------------------------------------------------------
+# Strength from what was read
+# ---------------------------------------------------------------------------
+#
+# ``validate`` scores a folder before anything in it is read: it sees file
+# names, and the contents of plain-text files only, so a 36-page dossier PDF
+# named "Dossier.pdf" scored 30/100 and was called thin. Once the files have
+# been read into proof points, ``score_evidence`` scores what they actually
+# hold, on the same seven buckets and weights.
+
+# The kinds of claim that fill each bucket.
+_EVIDENCE_BUCKETS: dict[str, frozenset[str]] = {
+    "positioning_and_offer": frozenset({"positioning", "selected_offer", "target_client"}),
+    "work_history_background": frozenset({"experience", "work_history", "education", "achievement"}),
+    "skills_tools_services": frozenset({"skill", "tool", "service", "deliverable"}),
+    "proof_credibility": frozenset({"metric", "testimonial", "project", "portfolio", "certification"}),
+    "proposal_preferences_pricing": frozenset({"pricing", "proposal_preference", "guarantee"}),
+}
+# The profile facts a proposal can draw on; how many are covered fills the
+# "structured profile" bucket.
+_PROFILE_FACT_GROUPS: tuple[frozenset[str], ...] = (
+    frozenset({"identity"}),
+    frozenset({"positioning", "selected_offer"}),
+    frozenset({"target_client"}),
+    frozenset({"service", "deliverable"}),
+    frozenset({"skill", "tool"}),
+    frozenset({"experience", "work_history", "achievement"}),
+    frozenset({"education", "certification"}),
+    frozenset({"language"}),
+    frozenset({"pricing"}),
+)
+_PROFILE_FACTS_FOR_FULL_MARKS = 7
+_DISTINCT_CLAIMS_FOR_DIVERSITY = 25
+
+# What each empty bucket means, in words a student understands.
+MISSING_IN_PLAIN_WORDS: dict[str, str] = {
+    "structured_profile_data": "basic profile details (education, languages, tools)",
+    "positioning_and_offer": "who you help and what you offer",
+    "work_history_background": "your work history or background",
+    "skills_tools_services": "your skills, tools and services",
+    "proof_credibility": "past results, samples or testimonials",
+    "proposal_preferences_pricing": "your rates or pricing",
+    "completeness_diversity": "enough detail overall",
+}
+
+
+def score_evidence(result: FolderValidationResult, proofs: list) -> FolderValidationResult:
+    """Re-score ``result`` from the proof points read out of its files.
+
+    The higher of the two scores stands, so a folder of well-named plain-text
+    files is never marked down. ``missing_categories`` is rebuilt to name
+    only what the files really lack.
+    """
+    claim_types = {str(getattr(p, "claim_type", "") or "") for p in proofs or []}
+    breakdown: dict[str, int] = {}
+    facts = sum(1 for group in _PROFILE_FACT_GROUPS if group & claim_types)
+    breakdown["structured_profile_data"] = round(
+        20 * min(facts, _PROFILE_FACTS_FOR_FULL_MARKS) / _PROFILE_FACTS_FOR_FULL_MARKS
+    )
+    weights = {key: weight for key, _label, weight in _BUCKETS}
+    for key, kinds in _EVIDENCE_BUCKETS.items():
+        breakdown[key] = weights[key] if kinds & claim_types else 0
+    distinct = {str(getattr(p, "claim_text", "") or "") for p in proofs or []}
+    sources = {str(getattr(p, "source_type", "") or "") for p in proofs or []}
+    breakdown["completeness_diversity"] = (
+        10 if len(distinct) >= _DISTINCT_CLAIMS_FOR_DIVERSITY or len(sources) >= 3 else 0
+    )
+    total = min(sum(breakdown.values()), 100)
+    if total >= result.strength_score:
+        result.strength_score = total
+        result.score_breakdown = breakdown
+        result.missing_categories = _missing_categories(breakdown)
+    # The pre-read warning about a low score no longer applies once the
+    # content has been scored above it.
+    if not result.below_threshold:
+        result.warnings = [w for w in result.warnings if "strength score" not in w]
+    return result
+
+
+def missing_in_plain_words(result: FolderValidationResult) -> list[str]:
+    """The empty buckets of ``result``, phrased for a student."""
+    return [
+        MISSING_IN_PLAIN_WORDS[key]
+        for key, awarded in (result.score_breakdown or {}).items()
+        if not awarded and key in MISSING_IN_PLAIN_WORDS
+    ]
+
+
 # ---------------------------------------------------------------------------
 # Main entry point
 # ---------------------------------------------------------------------------

app/services/interview.py

@@ -264,11 +264,28 @@ QUESTIONS: list[Question] = [
        "and why that one?",
        "strengths", "proposal", placeholder="The work, and why it stands out"),
 
+    # The sectors named across the programs' discovery-call scripts, with the
+    # programs' own domains first. Labels avoid commas and " - " (the answer
+    # splitter cuts on both) and very short words such as "HR" or "CA", which
+    # industry matching would find inside unrelated words in a job post.
     _q("q13", _S_DOMAIN, "Which industries or domains have you actually worked in?",
        "industries", "score", "multi",
-       ("E-commerce / D2C", "SaaS / Tech", "Healthcare", "Education", "Finance",
-        "Real estate", "Marketing agencies", "Hospitality & travel",
-        "Manufacturing", "Non-profit"),
+       ("Legal / Law firms / LPO", "Academia / Universities / Research",
+        "Accounting / CPA firms / Bookkeeping", "Finance / Banking / Fintech",
+        "Human resources / Recruitment / Staffing",
+        "Healthcare / Clinics / Wellness", "Pharma / Biotech / Life sciences",
+        "Education / EdTech / Coaching", "E-commerce / D2C / Retail",
+        "SaaS / Tech / IT services", "Startups", "Marketing / Advertising agencies",
+        "Media / Publishing / Journalism",
+        "Real estate / Construction / Infrastructure",
+        "Manufacturing / Supply chain / Logistics",
+        "Hospitality / Travel / Events", "Non-profit / NGOs / Development",
+        "Government / Public sector / PSUs", "Think tanks / Policy",
+        "Consulting / Professional services", "GCCs / Large enterprises / MNCs",
+        "Energy / Renewables / Utilities", "Agriculture / Agri-business",
+        "Fashion / Beauty / Lifestyle", "Food & beverage / Consumer products",
+        "Coaches / Creators / Course businesses", "ESG / Sustainability",
+        "Insurance", "Telecom", "Automotive"),
        placeholder="Pick all that apply, or type your own"),
     _q("q14", _S_DOMAIN,
        "Which of those do you know best? Tell me something about how that industry "
@@ -291,9 +308,12 @@ QUESTIONS: list[Question] = [
 
     _q("q18", _S_SKILLS, "What is your main skill category?",
        "skills", "score", "chips",
-       ("Writing & content", "Design & creative", "Web / software development",
-        "Marketing & SEO", "Admin & virtual assistance", "Data & analytics",
-        "Video & audio", "Customer support"),
+       ("Writing & content", "Academic & research writing", "Legal services",
+        "Accounting & bookkeeping", "Finance & business consulting",
+        "Human resources & recruiting", "Translation", "Design & creative",
+        "Web / software development", "Marketing & SEO",
+        "Admin & virtual assistance", "Data & analytics", "Video & audio",
+        "Customer support"),
        placeholder="Or type your main category"),
     _q("q19", _S_SKILLS, "Name the five skills a client would genuinely hire you for.",
        "skills", "score", placeholder="Five skills, comma separated",

app/services/llm_client.py

@@ -822,6 +822,13 @@ def _groq_text(
     kwargs: dict[str, Any] = {"model": model, "messages": messages, "temperature": 0}
     if expected_json:
         kwargs["response_format"] = {"type": "json_object"}
+    # GPT-OSS models think before they answer, and on Groq's free plan that
+    # thinking counts against the same per-minute token allowance as the
+    # answer. Low effort leaves the room for the answer itself.
+    # Sent as extra_body so an older `groq` SDK, whose create() predates the
+    # parameter, passes it through instead of rejecting it.
+    if "gpt-oss" in model.lower():
+        kwargs["extra_body"] = {"reasoning_effort": "low"}
 
     try:
         from groq import Groq  # type: ignore

app/services/proposal_generator.py

@@ -170,11 +170,29 @@ def _detect_complexity(confirmed_job: dict) -> str:
     return "standard"
 
 
+# Headings and labels from the team's coaching documents. They mean nothing
+# to a client, so any that slip into a draft (from the model or the local
+# outline) are removed: "YOUR SELECTED OFFER", "PART A — YOUR OFFER
+# STATEMENT", "HOW THIS HELPS THE CLIENT", "Offer 2 — ".
+_INTERNAL_LABELS = re.compile(
+    r"\byour selected offer\b[\s,:—–-]*|\bpart [ab]\s*[—–:-]\s*|"
+    r"\byour offer statement\b[\s,:—–-]*|\bhow this helps the (?:client|brand)\b[\s:—–-]*|"
+    r"\b(?:offer|niche)\s*\d+\s*[a-z]?\s*[—–:]\s*",
+    re.IGNORECASE,
+)
+# Four or more capitalised words in a row ("ACADEMIC WRITING SUPPORT FOR
+# MANAGEMENT") are a pasted document heading; acronyms such as "MBA" or
+# "APA" stand alone and are left as they are.
+_CAPS_HEADING_RUN = re.compile(r"\b(?:[A-Z][A-Z&/'’-]+\s+){3,}[A-Z][A-Z&/'’-]+\b\s*")
+
+
 def _strip_forbidden(text: str) -> str:
     # Strip any stray HTML/markup tags the model may emit (e.g. a trailing
     # </div>). Proposals are plain prose, so this is safe and keeps the copied
     # / downloaded text clean — not just the on-screen render.
     text = re.sub(r"</?\s*[a-zA-Z][a-zA-Z0-9]*[^>]*>", "", text)
+    text = _INTERNAL_LABELS.sub("", text)
+    text = _CAPS_HEADING_RUN.sub("", text)
     for phrase in FORBIDDEN_PHRASES:
         pattern = re.compile(re.escape(phrase), re.IGNORECASE)
         text = pattern.sub("", text)
@@ -238,12 +256,42 @@ def _opening(confirmed_job: dict, claims: list[dict]) -> str:
     return "Here is how I'd approach the brief you've shared."
 
 
+_SECOND_PERSON = re.compile(r"\s(?:You|Your)\b")
+
+
+def _lead_phrase(text: str) -> str:
+    """The short title of a coaching-document paragraph.
+
+    Dossier strengths read "Natural Communication Confidence You described
+    communication as your forte…": the title is the part a client may see;
+    the rest is written to the student. Text without such a title is cut to
+    its first sentence.
+    """
+    text = " ".join(str(text or "").split())
+    match = _SECOND_PERSON.search(text)
+    if match and 8 <= match.start() <= 120:
+        return text[: match.start()].strip(" .,:;—-")
+    sentence = re.split(r"(?<=[.!?])\s", text, maxsplit=1)[0]
+    return sentence[:160].strip()
+
+
 def _credibility(evidence: list, matched_skills: list[str], claims: list[dict]) -> str:
     parts: list[str] = []
+    # Strength titles first: they are the dossier's own summary of what the
+    # freelancer brings, and they read cleanly to a client.
+    strengths = [
+        _lead_phrase(_proof_attr(p, "claim_text", ""))
+        for p in _proofs_by_type(evidence, {"achievement"})
+    ]
+    # A paragraph that starts in lower case is the tail of one cut by a page
+    # break, not a strength of its own.
+    strengths = [s for s in strengths if s and s[0].isupper()][:3]
+    if strengths:
+        parts.append("What I bring: " + "; ".join(strengths) + ".")
     experience_proofs = _proofs_by_type(evidence, {"experience", "work_history"})
-    if experience_proofs:
+    if experience_proofs and not strengths:
         proof = experience_proofs[0]
-        text = str(_proof_attr(proof, "claim_text", "")).strip()
+        text = _lead_phrase(_proof_attr(proof, "claim_text", ""))
         if text:
             parts.append(text)
             claims.append(_claim(text, proof, kind="experience"))
@@ -263,10 +311,10 @@ def _credibility(evidence: list, matched_skills: list[str], claims: list[dict])
     if cited_skills:
         parts.append("Hands-on with " + ", ".join(cited_skills[:4]) + ".")
 
-    achievements = _proofs_by_type(evidence, {"achievement", "metric"})
-    if achievements:
-        proof = achievements[0]
-        text = str(_proof_attr(proof, "claim_text", "")).strip()
+    metrics = _proofs_by_type(evidence, {"metric"})
+    if metrics:
+        proof = metrics[0]
+        text = _lead_phrase(_proof_attr(proof, "claim_text", ""))
         if text:
             parts.append(text)
             claims.append(_claim(text, proof, kind="achievement"))
@@ -296,7 +344,9 @@ def _approach(evidence: list, claims: list[dict]) -> str:
 
     if services:
         for proof in services[:2]:
-            text = str(_proof_attr(proof, "claim_text", "")).strip()
+            # A dossier deliverable reads "1. Content Audit You review every
+            # page…": its title is the step, the rest is written to the student.
+            text = re.sub(r"^\d+\\?[.)]\s*", "", _lead_phrase(_proof_attr(proof, "claim_text", "")))
             if text:
                 bullets.append(text)
                 claims.append(_claim(text, proof, kind="service"))
@@ -317,17 +367,12 @@ def _approach(evidence: list, claims: list[dict]) -> str:
 
 
 def _differentiator(evidence: list, claims: list[dict]) -> str:
-    positioning = _proofs_by_type(evidence, {"positioning"})
-    if positioning:
-        proof = positioning[0]
-        text = str(_proof_attr(proof, "claim_text", "")).strip()
-        if text:
-            claims.append(_claim(text, proof, kind="positioning"))
-            return f"Why me, briefly: {text}"
+    # The offer statement is not quoted here: it is the angle, not proof, and
+    # its numbers are promises ("increase conversion by 40-80%").
     portfolio = _proofs_by_type(evidence, {"portfolio", "testimonial", "project"})
     if portfolio:
         proof = portfolio[0]
-        text = str(_proof_attr(proof, "claim_text", "")).strip()
+        text = _lead_phrase(_proof_attr(proof, "claim_text", ""))
         if text:
             claims.append(_claim(text, proof, kind="portfolio"))
             return f"For context on past work: {text}"
@@ -887,6 +932,10 @@ def _build_profile_block(canonical_profile: Any) -> str:
         "weaknesses_to_account_for",  # things NOT to claim (tools marked basic)
     ):
         value = _val(name)
+        if isinstance(value, list):
+            # A long list (every weakness a call transcript mentions, every
+            # deliverable in a dossier) would crowd out the evidence.
+            value = [str(v)[:200] for v in value if v][:_PROFILE_LIST_CAP]
         if value:
             summary[name] = value if not isinstance(value, str) else value[:300]
 
@@ -914,6 +963,16 @@ def _build_profile_block(canonical_profile: Any) -> str:
     return json.dumps(summary, ensure_ascii=False, indent=2) if summary else "{}"
 
 
+_PROFILE_LIST_CAP = 8
+
+# Groq's free plan allows roughly 8,000 tokens a minute for its default model,
+# and the full proposal request is about that size before any answer. On Groq
+# the evidence is trimmed to fit, and the extra critique re-ask (a second
+# full-size call in the same minute) is skipped.
+_GROQ_MAX_EVIDENCE_POINTS = 10
+_GROQ_MAX_CONTEXT_CHARS = 6000
+
+
 _CRITIQUE_CORRECTION = """
 
 CORRECTION — your previous response did not return three completed critique
@@ -948,6 +1007,7 @@ def _try_llm_generate(
     claim_text_cap: int,
     max_output_tokens: int,
     canonical_profile: Any = None,
+    enforce_critique: bool = True,
 ) -> tuple[Optional[str], list[dict[str, Any]], list[dict[str, str]], Any]:
     """Call the LLM via the central client.
 
@@ -980,7 +1040,8 @@ def _try_llm_generate(
     # succeeded and simply skipped the rounds — a failed or oversized call
     # falls through untouched so the existing size-error retry still owns it.
     if (
-        result.success
+        enforce_critique
+        and result.success
         and isinstance(result.response_json, dict)
         and not _has_three_critique_rounds(result.response_json)
     ):
@@ -1067,13 +1128,19 @@ def generate(
     if match_data:
         matched_skills = list(match_data.get("skill_match", {}).get("matched", []) or [])
 
+    on_groq = getattr(settings, "active_provider", "") == "groq"
+    max_points = settings.max_proposal_evidence_points
+    max_chars = settings.max_proposal_context_chars
+    if on_groq:
+        max_points = min(max_points, _GROQ_MAX_EVIDENCE_POINTS)
+        max_chars = min(max_chars, _GROQ_MAX_CONTEXT_CHARS)
     primary_context = build_proposal_context(
         confirmed_job,
         evidence_list,
         match_result=match_data,
         recommendation_result=recommendation,
-        max_evidence_points=settings.max_proposal_evidence_points,
-        max_context_chars=settings.max_proposal_context_chars,
+        max_evidence_points=max_points,
+        max_context_chars=max_chars,
     )
 
     used_api = False
@@ -1101,6 +1168,7 @@ def generate(
             claim_text_cap=compact_meta["claim_text_cap"],
             max_output_tokens=settings.proposal_max_output_tokens,
             canonical_profile=canonical_profile,
+            enforce_critique=not on_groq,
         )
         if llm_result is not None:
             llm_status = llm_result.status
@@ -1114,13 +1182,15 @@ def generate(
         # shrink and retry ONCE with the hard fallback settings.
         if proposal is None and _is_size_error(llm_result):
             retry_used = True
+            # Always smaller than the first try: 8 points / 8,000 chars on the
+            # default budget, and proportionally less on Groq's smaller one.
             retry_context = build_proposal_context(
                 confirmed_job,
                 evidence_list,
                 match_result=match_data,
                 recommendation_result=recommendation,
-                max_evidence_points=8,
-                max_context_chars=8000,
+                max_evidence_points=min(8, max(4, max_points - 4)),
+                max_context_chars=min(8000, int(max_chars * 0.66)),
             )
             chosen_context = retry_context
             retry_meta = retry_context["__meta__"]
@@ -1133,6 +1203,7 @@ def generate(
                 claim_text_cap=retry_meta["claim_text_cap"],
                 max_output_tokens=1200,
                 canonical_profile=canonical_profile,
+                enforce_critique=not on_groq,
             )
             if llm_result is not None:
                 llm_status = llm_result.status

app/services/screenshot_parser.py

@@ -83,7 +83,12 @@ _EXTRACTION_INSTRUCTIONS = (
     "For \"client_jobs_posted\" and "
     "\"client_hires\", capture the counts the client profile shows (e.g. "
     "\"12 jobs posted\", \"8 hires\"); the hire-rate percentage still goes in "
-    "\"hire_rate\". For \"client_last_active\", capture how recent activity is "
+    "\"hire_rate\". Take these three ONLY from the 'About the client' panel. "
+    "The 'Activity on this job' section also shows a 'Hires' line, but that "
+    "counts hires for this one post (usually 0 while it is open) — never put "
+    "it in \"client_hires\" and never use it to work out \"hire_rate\". If "
+    "the 'About the client' panel is not in the images, mark those fields "
+    "\"Not visible\". For \"client_last_active\", capture how recent activity is "
     "shown. For \"hidden_keyword\", capture any explicit instruction-style "
     "phrase planted in the description that asks the applicant to include a "
     "specific word/phrase to prove they read it (else \"Not visible\"). For "

app/ui/analysis_screen.py

@@ -197,6 +197,85 @@ def _missing_heads_up_fields(confirmed_job: dict) -> list[str]:
     return [f for f in _HEADS_UP_FIELDS if _field_is_missing(confirmed_job, f)]
 
 
+# The client details a user can type in when the screenshot missed Upwork's
+# 'About the client' box. These are the fields the hire-rate and client checks
+# hang on, so without them the verdict can only say "check it yourself".
+_TYPED_CLIENT_FIELDS = ("hire_rate", "client_jobs_posted", "payment_verification")
+_PAYMENT_CHOICES = {
+    "Not sure": "",
+    "Yes, verified": "Payment verified",
+    "No, not verified": "Payment not verified",
+}
+
+
+def _typed_client_value(field: str, raw: str) -> str:
+    """Clean one typed client detail, or "" when it can't be used.
+
+    The hire rate must be a 0-100 percentage and jobs posted a whole number;
+    anything else is dropped rather than guessed at.
+    """
+    text = " ".join(str(raw or "").split())[:40]
+    numbers = re.findall(r"\d+(?:\.\d+)?", text.replace(",", ""))
+    if field == "hire_rate":
+        if not numbers or float(numbers[0]) > 100:
+            return ""
+        return f"{numbers[0]}% hire rate"
+    if field == "client_jobs_posted":
+        return f"{int(float(numbers[0]))} jobs posted" if numbers else ""
+    return text
+
+
+def _render_client_details_form(confirmed_job: dict) -> None:
+    """Let the user fill in the client details the screenshot did not show.
+
+    Typed values only ever replace a "Not visible" field. Saving them clears
+    the cached analysis, so the verdict is worked out again with them.
+    """
+    missing = [f for f in _TYPED_CLIENT_FIELDS if _field_is_missing(confirmed_job, f)]
+    if not missing:
+        return
+    with st.container(border=True, key="ups_panel_analysis_client"):
+        theme.section_label("Add the client's details")
+        st.caption(
+            "These weren't in your screenshot. You'll find them in the "
+            "'About the client' box on the Upwork job page. Fill in what you "
+            "can and the verdict is checked again."
+        )
+        with st.form("client_details_form", border=False):
+            cols = st.columns(len(missing))
+            typed: dict[str, str] = {}
+            for col, field in zip(cols, missing):
+                if field == "hire_rate":
+                    typed[field] = col.text_input("Hire rate", placeholder="e.g. 75%")
+                elif field == "client_jobs_posted":
+                    typed[field] = col.text_input("Jobs posted", placeholder="e.g. 12")
+                else:
+                    choice = col.selectbox("Payment verified?", list(_PAYMENT_CHOICES))
+                    typed[field] = _PAYMENT_CHOICES[choice]
+            submitted = st.form_submit_button("Check again with these details")
+        if not submitted:
+            return
+        cleaned = {
+            field: _typed_client_value(field, value)
+            for field, value in typed.items()
+        }
+        cleaned = {field: value for field, value in cleaned.items() if value}
+        if not cleaned:
+            st.warning(
+                "Nothing to add yet: type the hire rate as a percentage and "
+                "jobs posted as a number."
+            )
+            return
+        updated = dict(confirmed_job)
+        for field, value in cleaned.items():
+            updated[field] = {"value": value, "confidence": "high", "source": "typed by user"}
+        st.session_state.confirmed_job_fields = updated
+        # Jobs posted is not part of the job fingerprint, so drop the cached
+        # result outright to make sure the verdict is worked out again.
+        st.session_state.match_data = None
+        st.rerun()
+
+
 def _visible_job_text(confirmed_job: dict, *, cap: int = 600) -> str:
     """Short context string from the job's visible fields for the labeling LLM."""
     parts = [
@@ -777,6 +856,7 @@ def render() -> None:
 
     # ---- Full 10-signal table + niche note ----------------------------
     _render_signal_table(beginner_eval)
+    _render_client_details_form(confirmed_job)
     _render_niche_note(beginner_eval)
 
     # ---- Strengths & concerns ----------------------------------------

app/ui/dossier_screen.py

@@ -37,6 +37,8 @@ from app.services.folder_validator import (
     FolderValidationResult,
     SUPPORTED_EXTENSIONS,
     THIN_DOSSIER_THRESHOLD,
+    missing_in_plain_words,
+    score_evidence,
     score_rubric_labels,
     validate,
 )
@@ -315,10 +317,17 @@ def _sync_dossier_uploads() -> list[dict]:
         accept_multiple_files=True,
         key=uploader_key,
         help=(
-            "Portfolio, résumé, testimonials, past proposals. Your files are "
-            "processed in this session only and are never stored on the server."
+            "Your Upwork Profile Optimisation document and your Dossier work "
+            "best; add a portfolio, résumé or testimonials if you have them. "
+            "Your files are processed in this session only and are never "
+            "stored on the server."
         ),
     )
+    st.caption(
+        "Upload your **Upwork Profile Optimisation** document and your "
+        "**Dossier**. Leave out the Offer Bank — it lists offers you didn't "
+        "choose."
+    )
 
     stored: list[dict] = ss.get(_UPLOAD_RECORDS_KEY) or []
     if files:
@@ -536,6 +545,7 @@ def _card_read_evidence() -> None:
                 st.session_state.evidence_index = proofs
                 st.session_state.canonical_profile = profile
                 st.session_state.evidence_index_meta = meta
+                _score_read_files(proofs)
 
             proofs = st.session_state.get("evidence_index")
             if proofs:
@@ -563,6 +573,18 @@ def _card_read_evidence() -> None:
 # ---------------------------------------------------------------------------
 
 
+def _score_read_files(proofs: list) -> None:
+    """Re-score the folder from what its files turned out to hold.
+
+    The validation runs before anything is read and sees file names only, so
+    a full dossier PDF scored as thin. Scoring the proof points instead is
+    what decides whether the "less than usual" offer appears.
+    """
+    result = st.session_state.get("dossier_validation")
+    if result is not None and proofs:
+        st.session_state.dossier_validation = score_evidence(result, proofs)
+
+
 def _continue_chain() -> None:
     """Run the full dossier pipeline silently, then advance.
 
@@ -593,6 +615,7 @@ def _continue_chain() -> None:
                 st.session_state.evidence_index = proofs
                 st.session_state.canonical_profile = profile
                 st.session_state.evidence_index_meta = meta
+                _score_read_files(proofs)
     if st.session_state.get("evidence_index"):
         # Persist the path so the app can auto-reload it on the next restart.
         if path:
@@ -713,10 +736,12 @@ def _card_interview_gap_fill(result: FolderValidationResult, *, debug: bool) ->
     """Offer the interview as a gap-filler for a thin dossier."""
     with st.container(border=True, key="ups_panel_dossier_6"):
         theme.section_label("Your files gave us less than usual")
+        missing = missing_in_plain_words(result)
         st.warning(
-            "There wasn't much in that folder to quote from, so proposals "
-            "will be thinner than they could be. A few questions about your "
-            "work fills the gaps — your files are kept either way."
+            "We read your files but couldn't find "
+            + (_join_words(missing) if missing else "much to quote from")
+            + ". A few questions about your work fill the gaps — your files "
+            "are kept either way."
         )
         if debug:
             st.caption(
@@ -748,6 +773,13 @@ def _card_interview_gap_fill(result: FolderValidationResult, *, debug: bool) ->
             st.rerun()
 
 
+def _join_words(items: list[str]) -> str:
+    """Join phrases as a sentence would: "a", "a and b", "a, b and c"."""
+    if len(items) <= 1:
+        return "".join(items)
+    return ", ".join(items[:-1]) + " and " + items[-1]
+
+
 def _should_offer_gap_fill(result: FolderValidationResult | None) -> bool:
     """True when real files were read but they scored thin.
 

app/ui/interview_screen.py

@@ -1382,14 +1382,22 @@ def _card_question(state: Any, question: Any, index: int, *, debug: bool) -> Non
                     ):
                         _submit(state, option, from_chip=True)
             else:
+                # Typing a name that is not in the list adds it as a new
+                # option, so a sector the list misses can be picked here too.
                 picked = st.multiselect(
                     "Pick everything that applies",
                     options,
                     key=f"iv_multi_{index}_{seq}",
+                    accept_new_options=True,
+                    placeholder="Pick from the list, or type your own and press Enter",
                 )
 
+        # On a pick-several question the box is the "not in the list" half of
+        # the answer, so it carries a visible label saying so; elsewhere it is
+        # the answer itself and the question above is its label.
+        multi_box = bool(options) and kind == "multi"
         text = st.text_area(
-            "Your answer",
+            "Not in the list? Type it here" if multi_box else "Your answer",
             key=f"iv_answer_{index}_{seq}",
             value=earlier if (editing and kind == "text") else "",
             placeholder=str(
@@ -1397,7 +1405,7 @@ def _card_question(state: Any, question: Any, index: int, *, debug: bool) -> Non
             ),
             height=110,
             max_chars=_MAX_ANSWER_CHARS,
-            label_visibility="collapsed",
+            label_visibility="visible" if multi_box else "collapsed",
         )
 
         col_send, col_prev, col_skip, col_finish = st.columns([2, 1, 1, 1])
@@ -1469,7 +1477,10 @@ def _card_question(state: Any, question: Any, index: int, *, debug: bool) -> Non
             # to read. Sent as a chip it costs no call against the free tier.
             # Typed words are not on that list, so as soon as there are any
             # the whole answer goes through validation.
-            from_picks = bool(picked) and not typed
+            # A name typed into the dropdown is a new option, not one of the
+            # list's, so it goes through validation like typed words do.
+            new_picks = [p for p in picked if p not in options]
+            from_picks = bool(picked) and not typed and not new_picks
             if not answer:
                 st.warning("Type an answer first, or use Skip.")
             else:

app/ui/proposal_screen.py

@@ -27,6 +27,12 @@ from app.ui import output_screen, theme
 # Background-task id for proposal generation (one at a time).
 _PROPOSAL_TASK = "proposal_generation"
 
+_PROPOSAL_FAILED_MESSAGE = (
+    "The AI couldn't write the proposal this time. Wait a minute, then press "
+    "Generate Proposal again. If it keeps failing, check the API key on the "
+    "Setup screen."
+)
+
 
 def _copy_button(text: str) -> None:
     """A real one-click copy button (works in deployed Streamlit)."""
@@ -80,16 +86,32 @@ def _copy_button(text: str) -> None:
 def _render_proposal(proposal_result: dict, show_debug: bool, *, settings) -> None:
     prop_meta = proposal_result.get("__meta__") or {}
     verify_meta = proposal_result.get("verification_meta") or {}
-    output_screen.render_clean_stage_banner(
-        output_screen._stage_user_state(prop_meta),
-        output_screen._stage_user_state(verify_meta),
-    )
-    theme.screen_head(
-        "proposal",
-        "Your draft is ready",
-        "A grounded first draft built only from facts in your dossier. "
-        "Read it through, then copy it straight into Upwork.",
-    )
+    # Without the AI the app can only fill a fixed outline from the files.
+    # That outline must never pass for a finished proposal.
+    written_by_ai = bool(prop_meta.get("used_api"))
+    if written_by_ai:
+        output_screen.render_clean_stage_banner(
+            output_screen._stage_user_state(prop_meta),
+            output_screen._stage_user_state(verify_meta),
+        )
+        theme.screen_head(
+            "proposal",
+            "Your draft is ready",
+            "A grounded first draft built only from facts in your dossier. "
+            "Read it through, then copy it straight into Upwork.",
+        )
+    else:
+        theme.screen_head(
+            "proposal",
+            "AI writing was unavailable",
+            "This is only a rough outline, filled in from your files without "
+            "the AI. Don't send it as it is: wait a minute, then press "
+            "Generate Proposal again.",
+        )
+        st.warning(
+            "Not a finished proposal. The AI service didn't respond this time, "
+            "so the outline below is not tailored to the job."
+        )
 
     proposal_text = proposal_result.get("proposal", "")
 
@@ -221,7 +243,14 @@ def render() -> None:
         unsafe_allow_html=True,
     )
 
-    do_not_proceed = recommendation.get("verdict") == "Do Not Proceed"
+    # The warning follows the verdict the user was shown on the Analysis
+    # screen — the job checklist — not the hidden fit-score tier, which could
+    # read "Do Not Proceed" under a "Proceed with caution" verdict.
+    beginner_eval = (match_data or {}).get("beginner_evaluation")
+    if isinstance(beginner_eval, dict) and beginner_eval.get("result"):
+        do_not_proceed = bool(beginner_eval.get("instant_no"))
+    else:
+        do_not_proceed = recommendation.get("verdict") == "Do Not Proceed"
 
     with st.container(border=True, key="ups_panel_proposal_3"):
         theme.section_label("Generate")
@@ -312,7 +341,7 @@ def render() -> None:
             st.session_state.proposal_generating = False
             st.session_state.generated_proposal = None
             st.session_state.verified_proposal = None
-            st.error(output_screen.USER_FACING_ERROR)
+            st.error(_PROPOSAL_FAILED_MESSAGE)
             return
 
     proposal_result = st.session_state.get("verified_proposal")

app/ui/screenshot_screen.py

@@ -387,8 +387,10 @@ def render() -> None:
                     _clear_screenshots_for_new_job()
                     st.rerun()
         st.caption(
-            "Missing details will be marked “Not visible”. The tool won't guess "
-            "hidden information."
+            "Include the **About the client** box (hire rate, jobs posted, "
+            "payment verified) — add a second screenshot if it doesn't fit in "
+            "one. Missing details are marked “Not visible”; the tool won't "
+            "guess hidden information."
         )
 
         # Groq is text-only: a Groq vision provider can't read screenshots.