feat: V1 noise fix, real progress animation via SSE

V1 noise fix (parity with V2):
- optimize_latex_resume: add company param + progress_callback + filter_scraped_noise on includable pool
- latex_flow_for_api: pass company down so noise filter can screen the company name

Progress animation (real stage labels):
- api_server.py: new /api/generate-stream SSE endpoint; progress_callback bridges sync
flow stages to async SSE events (stage/pct per event, final event carries full result)
- generate_v2: progress_callback param + stage calls at keyword extract, rank, fan-out, compile
- background.js: SSE streaming path in runGenerate reads stage events and writes them to
storage so the popup updates live; falls back to blocking /api/generate if stream fails
- popup.js: stage label from storage shown in spinner instead of generic "Generating resume..."

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

api_server.py

@@ -29,7 +29,8 @@ import httpx
 import uvicorn
 from fastapi import FastAPI, Header, HTTPException, UploadFile, Form, Request, WebSocket, WebSocketDisconnect, BackgroundTasks
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
+import threading
+from fastapi.responses import JSONResponse, StreamingResponse
 from starlette.responses import Response as StarletteResponse
 
 # ── App init ──────────────────────────────────────────────────────────────────
@@ -214,6 +215,7 @@ def latex_flow_for_api(
         compile_pdf=True,
         out_dir=out_dir,
         job_title=company or job_title or "resume",
+        company=company or "",
     )
     return report, out_dir
 
@@ -453,6 +455,136 @@ async def _generate_from_latex_v2(
             shutil.rmtree(out_dir, ignore_errors=True)
 
 
+@app.post("/api/generate-stream")
+async def generate_stream_endpoint(
+    jd_text: str = Form(""),
+    job_title: str = Form(""),
+    company: str = Form(""),
+    maximum_ats_mode: str = Form(""),
+    confirmed_terms: str = Form(""),
+    resume_latex: str = Form(""),
+    version: str = Form(""),
+    resume: UploadFile = None,
+    x_api_token: str = Header(None),
+):
+    """SSE endpoint — same as /api/generate but streams progress events.
+
+    Events: `data: {"stage": "...", "pct": N}\\n\\n`
+    Final:  `data: {"done": true, ...full result fields...}\\n\\n`
+    Error:  `data: {"error": "...", "detail": "..."}\\n\\n`
+    """
+    _check_token(x_api_token)
+
+    max_ats = _truthy(maximum_ats_mode)
+    conf = _term_list(confirmed_terms)
+    _version = (version or "").strip().lower() or os.getenv("GEN_VERSION_DEFAULT", "v2")
+
+    if not (resume_latex or "").strip() and resume is None:
+        try:
+            from src.default_resume import get_default_resume_latex
+            resume_latex = get_default_resume_latex()
+        except Exception:
+            pass
+
+    pdf_bytes = None
+    if resume is not None:
+        pdf_bytes = await resume.read()
+
+    if not (resume_latex or "").strip() and not pdf_bytes:
+        async def _err():
+            yield f'data: {json.dumps({"error": "no_resume", "detail": "No resume provided."})}\n\n'
+        return StreamingResponse(_err(), media_type="text/event-stream")
+
+    loop = asyncio.get_event_loop()
+    queue: asyncio.Queue = asyncio.Queue()
+
+    def _progress(stage: str, pct: int):
+        loop.call_soon_threadsafe(queue.put_nowait, {"stage": stage, "pct": pct})
+
+    def _run():
+        out_dir = None
+        try:
+            latex_src = (resume_latex or "").strip()
+            if _version == "v2":
+                from src.resume_v2_natural import generate_v2
+                out_dir = tempfile.mkdtemp(prefix="stream_v2_")
+                report = generate_v2(
+                    latex_src, jd_text, job_title=job_title, company=company,
+                    out_dir=out_dir, compile_pdf=True, progress_callback=_progress,
+                )
+            else:
+                from src.latex_resume import optimize_latex_resume
+                out_dir = tempfile.mkdtemp(prefix="stream_v1_")
+                from src.candidate_vault import user_blocked_terms
+                try:
+                    blocked = list(user_blocked_terms())
+                except Exception:
+                    blocked = []
+                report = optimize_latex_resume(
+                    latex_src, jd_text,
+                    maximum_ats_mode=max_ats,
+                    confirmed_terms=conf,
+                    blocked_terms=blocked,
+                    compile_pdf=True,
+                    out_dir=out_dir,
+                    job_title=company or job_title or "resume",
+                    company=company or "",
+                    progress_callback=_progress,
+                )
+
+            # Build the same response payload as the blocking endpoints.
+            pct = int(report.get("pct", 0) or 0)
+            from src.fit_gate import MAX_ATS_READY_STATUSES
+            status = _latex_status(pct, max_ats, False)
+            download_allowed = status in MAX_ATS_READY_STATUSES
+
+            tex = report.get("tex") or latex_src
+            tex_b64 = base64.b64encode((tex or "").encode()).decode() if tex else None
+            pdf_b64 = None
+            pdf_path = report.get("pdf_path")
+            if pdf_path and os.path.exists(pdf_path):
+                with open(pdf_path, "rb") as _f:
+                    pdf_b64 = base64.b64encode(_f.read()).decode()
+
+            payload = {
+                "done": True,
+                "status": status,
+                "source": f"latex_{_version}",
+                "version": _version,
+                "download_allowed": bool(download_allowed),
+                "maximum_ats_mode": max_ats,
+                "external_coverage_pct": pct,
+                "injected_terms": report.get("injected", []),
+                "judge_note": report.get("judge_note", ""),
+                "tex_b64": tex_b64,
+                "pdf_b64": pdf_b64,
+                "docx_b64": None,
+            }
+            loop.call_soon_threadsafe(queue.put_nowait, payload)
+        except Exception as exc:
+            loop.call_soon_threadsafe(
+                queue.put_nowait, {"error": "generation_failed", "detail": str(exc)[:300]})
+        finally:
+            if out_dir:
+                shutil.rmtree(out_dir, ignore_errors=True)
+
+    t = threading.Thread(target=_run, daemon=True)
+    t.start()
+
+    async def _events():
+        while True:
+            evt = await queue.get()
+            yield f"data: {json.dumps(evt)}\n\n"
+            if evt.get("done") or evt.get("error"):
+                break
+
+    return StreamingResponse(
+        _events(),
+        media_type="text/event-stream",
+        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+    )
+
+
 async def _repair_from_latex(
     latex_src: str, jd_text: str, job_title: str, company: str,
     max_ats: bool, conf_terms: list, pasted_terms: list,

extension/background.js

@@ -441,11 +441,14 @@ async function handleGenerate({ jd_text, job_title, company, maximum_ats_mode, c
     company: company || '',
   });
 
+  // Expose the current key so _writeProgressStage can update the stage label.
+  _currentProgressKey = urlKey;
+
   // 3. Perform the network round-trip (no popup dependency).
   const result = await runGenerate({ data, hasLatex, resumeLatex, jd_text, job_title, company, maximum_ats_mode, confirmed_terms, version });
 
-  // 4. Overwrite the marker with the terminal state — done OR error — so the
-  //    popup never shows a false/forever spinner. Done regardless of popup state.
+  // 4. Overwrite the marker with the terminal state — done OR error.
+  _currentProgressKey = null;
   if (result && result.error) {
     await writeEntry(urlKey, { status: 'error', result });
   } else {
@@ -480,9 +483,8 @@ function stopKeepAlive() {
   }
 }
 
-// Network/parse layer for GENERATE. Returns a result object (success or {error}).
-async function runGenerate({ data, hasLatex, resumeLatex, jd_text, job_title, company, maximum_ats_mode, confirmed_terms, version }) {
-  // Build multipart/form-data. LaTeX takes priority over the PDF.
+// Build the multipart FormData used by both blocking and streaming generate calls.
+function _buildGenerateForm({ data, hasLatex, resumeLatex, jd_text, job_title, company, maximum_ats_mode, confirmed_terms, version }) {
   const formData = new FormData();
   formData.append('jd_text', jd_text);
   formData.append('job_title', job_title || '');
@@ -496,21 +498,67 @@ async function runGenerate({ data, hasLatex, resumeLatex, jd_text, job_title, co
   } else {
     const binaryStr = atob(data.resume_b64);
     const bytes = new Uint8Array(binaryStr.length);
-    for (let i = 0; i < binaryStr.length; i++) {
-      bytes[i] = binaryStr.charCodeAt(i);
-    }
-    const resumeBlob = new Blob([bytes], { type: 'application/pdf' });
-    formData.append('resume', resumeBlob, 'resume.pdf');
+    for (let i = 0; i < binaryStr.length; i++) bytes[i] = binaryStr.charCodeAt(i);
+    formData.append('resume', new Blob([bytes], { type: 'application/pdf' }), 'resume.pdf');
   }
+  return formData;
+}
+
+// Network/parse layer for GENERATE — uses SSE streaming so the popup receives
+// real stage labels (Analyzing JD → Placing keywords → Compiling PDF) as they
+// happen. Falls back to the blocking endpoint if streaming isn't available.
+async function runGenerate(params) {
+  const { data } = params;
+  const base = data.api_url.replace(/\/$/, '');
+  const headers = { 'X-Api-Token': data.api_token };
 
   startKeepAlive();
   try {
+    // ── SSE streaming path ────────────────────────────────────────────────────
     let resp;
     try {
-      resp = await _fetchWithRetry(`${data.api_url.replace(/\/$/, '')}/api/generate`, {
-        method: 'POST',
-        headers: { 'X-Api-Token': data.api_token },
-        body: formData,
+      resp = await fetch(`${base}/api/generate-stream`, {
+        method: 'POST', headers, body: _buildGenerateForm(params),
+      });
+    } catch (_) {
+      resp = null;
+    }
+
+    // If the streaming endpoint exists and responded, read SSE events.
+    if (resp && resp.ok && resp.body) {
+      const reader = resp.body.getReader();
+      const decoder = new TextDecoder();
+      let buf = '';
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buf += decoder.decode(value, { stream: true });
+        const lines = buf.split('\n');
+        buf = lines.pop(); // keep the incomplete last line
+        for (const line of lines) {
+          if (!line.startsWith('data: ')) continue;
+          let evt;
+          try { evt = JSON.parse(line.slice(6)); } catch { continue; }
+          if (evt.stage) {
+            // Write progress stage to storage — popup's onChanged listener shows it.
+            await _writeProgressStage(evt.stage);
+          }
+          if (evt.done) {
+            const { done: _d, ...result } = evt;
+            return result;
+          }
+          if (evt.error) {
+            return { error: evt.error, detail: evt.detail };
+          }
+        }
+      }
+      return { error: 'stream_ended', detail: 'SSE stream ended without a result.' };
+    }
+
+    // ── Fallback: blocking /api/generate ─────────────────────────────────────
+    try {
+      resp = await _fetchWithRetry(`${base}/api/generate`, {
+        method: 'POST', headers, body: _buildGenerateForm(params),
       });
     } catch (networkErr) {
       return { error: 'network_error', detail: `Cannot reach API: ${networkErr.message}` };
@@ -521,19 +569,31 @@ async function runGenerate({ data, hasLatex, resumeLatex, jd_text, job_title, co
       result = await resp.json();
     } catch {
       if (resp.status === 503) return { error: 'space_waking', detail: 'Space is waking up — wait ~30 s and try again.' };
-    return { error: 'parse_error', detail: `API returned non-JSON (status ${resp.status})` };
-    }
-
-    if (!resp.ok) {
-      return { error: result.error || 'api_error', detail: result.detail || `HTTP ${resp.status}` };
+      return { error: 'parse_error', detail: `API returned non-JSON (status ${resp.status})` };
     }
-
+    if (!resp.ok) return { error: result.error || 'api_error', detail: result.detail || `HTTP ${resp.status}` };
     return result;
   } finally {
     stopKeepAlive();
   }
 }
 
+// Write a progress stage label into the current running storage entry.
+// The popup's storage.onChanged listener picks this up and updates the status text.
+let _currentProgressKey = null;
+async function _writeProgressStage(stage) {
+  if (!_currentProgressKey) return;
+  try {
+    const d = await new Promise(res => chrome.storage.local.get(RESULTS_KEY, res));
+    const map = d[RESULTS_KEY] || {};
+    const entry = map[_currentProgressKey];
+    if (entry && entry.status === 'running') {
+      entry.stage = stage;
+      await new Promise(res => chrome.storage.local.set({ [RESULTS_KEY]: map }, res));
+    }
+  } catch (_) { /* non-fatal */ }
+}
+
 // ─── DOWNLOAD ────────────────────────────────────────────────────────────────
 
 async function handleDownload({ format, b64, filename }) {

extension/popup/popup.js

@@ -240,7 +240,8 @@ async function restoreResultForTab() {
     if (age < RUNNING_TIMEOUT_MS) {
       restoredMeta = { job_title: saved.job_title, company: saved.company };
       runBtn.disabled = true;
-      statusEl.innerHTML = '<span class="spinner"></span> Generating resume…';
+      const stageLabel = saved.stage || 'Generating resume…';
+      statusEl.innerHTML = `<span class="spinner"></span> ${stageLabel}`;
       return;
     }
     return;   // stale running marker → treat as not-found
@@ -382,7 +383,8 @@ chrome.storage.onChanged.addListener((changes, area) => {
     if (age < RUNNING_TIMEOUT_MS) {
       restoredMeta = { job_title: entry.job_title, company: entry.company };
       runBtn.disabled = true;
-      statusEl.innerHTML = '<span class="spinner"></span> Generating resume…';
+      const stageLabel = entry.stage || 'Generating resume…';
+      statusEl.innerHTML = `<span class="spinner"></span> ${stageLabel}`;
     }
   } else if (entry.status === 'done' && entry.result) {
     generatedResult = entry.result;

src/latex_resume.py

@@ -790,17 +790,27 @@ def optimize_latex_resume(
     compile_pdf: bool = True,
     out_dir: str | None = None,
     job_title: str = "",
+    company: str = "",
+    progress_callback=None,
 ) -> Dict:
     """End-to-end LaTeX flow: gate → inject → (compile) → measure coverage.
 
     Returns a report dict compatible with the existing coverage_report shape,
     plus LaTeX-specific fields (`tex`, `pdf_path`, `engine`, `compiled`).
     """
-    from .external_ats import external_coverage
+    from .external_ats import external_coverage, filter_scraped_noise
+
+    def _prog(stage, pct):
+        if progress_callback:
+            try:
+                progress_callback(stage, pct)
+            except Exception:
+                pass
 
     latex_src = latex_src or ""
     base_text = latex_to_text(latex_src)
 
+    _prog("Analyzing job description…", 10)
     decision = decide_includable_terms(
         jd_text, base_text,
         maximum_ats_mode=maximum_ats_mode,
@@ -809,9 +819,11 @@ def optimize_latex_resume(
         blocked_terms=blocked_terms,
     )
     expected = decision["expected_terms"]
-    includable = decision["includable"]
+    # V1 noise fix: strip LinkedIn UI / metadata noise from the keyword pool
+    includable = filter_scraped_noise(decision["includable"], jd_text, company)
     gated = decision["gated"]
 
+    _prog("Placing keywords in resume…", 45)
     final_src, injected = inject_keywords(latex_src, includable)
     final_text = latex_to_text(final_src)
 
@@ -858,6 +870,7 @@ def optimize_latex_resume(
     })
 
     if compile_pdf:
+        _prog("Compiling PDF…", 68)
         out_dir = out_dir or tempfile.mkdtemp(prefix="latex_resume_")
         _company_slug = _safe_jobname(job_title)
         jobname = f"Saiteja_Tirunagari_{_company_slug}_Resume" if _company_slug else "Saiteja_Tirunagari_Resume"

src/resume_v2_natural.py

@@ -815,6 +815,7 @@ def generate_v2(
     judge: dict | None = None,
     out_dir: str | None = None,
     compile_pdf: bool = True,
+    progress_callback=None,
 ) -> dict:
     """V2 multi-agent pipeline: extract keywords → ALL agents rank them by potential
     → allocate the top-ranked → every agent writes a natural candidate → judge picks
@@ -822,10 +823,18 @@ def generate_v2(
 
     Falls back to single-model, then V1-style placement, if the pool is unavailable."""
 
+    def _prog(stage, pct):
+        if progress_callback:
+            try:
+                progress_callback(stage, pct)
+            except Exception:
+                pass
+
     # 0. Sanitize the JD: strip scraped job-board page chrome (promoted-by,
     #    profile-match widgets, applicant counts, premium upsells, section labels)
     #    so keyword extraction + the coverage denominator see the REAL job
     #    description, not LinkedIn UI text. V2-only.
+    _prog("Analyzing job description…", 5)
     jd_text = _sanitize_jd_v2(jd_text)
 
     base_text = latex_to_text(latex_src or "")
@@ -835,6 +844,7 @@ def generate_v2(
     llm = LLMClient() if (fan_cfgs or (judge_cfg and judge_cfg.get("api_key"))) else None
 
     # 1. Extract + V2-noise-filter the keyword pool.
+    _prog("Extracting keywords…", 10)
     decision = decide_includable_terms(jd_text, base_text, maximum_ats_mode=True)
     includable = filter_scraped_noise(decision["includable"], jd_text, company)
 
@@ -859,6 +869,7 @@ def generate_v2(
     #         LLM round (~5-8 s wall-clock).
     rank_note = ""
     _curate_fut = _rank_fut = None
+    _prog("Curating and ranking keywords…", 20)
     with ThreadPoolExecutor(max_workers=2) as _prep_pool:
         if llm and judge_cfg and judge_cfg.get("api_key"):
             _curate_fut = _prep_pool.submit(
@@ -906,6 +917,7 @@ def generate_v2(
     #    DEFAULT = multi-agent fan-out: every fast model writes a full natural
     #    candidate, the judge (Kimi) picks the best, then Kimi runs one refine pass.
     #    Falls back to single-model, then V1 placement.
+    _prog("Generating tailored resume bullets…", 38)
     sentences: dict = {}
     v2_models_used: list[str] = []
     v2_winner = "v1_fallback"
@@ -1051,6 +1063,7 @@ def generate_v2(
         log.warning("Coverage backstop failed (non-fatal): %s", exc)
 
     # 5. Compile
+    _prog("Compiling PDF…", 82)
     comp: dict = {"compiled": False, "engine": None, "pdf_path": None}
     if compile_pdf and out_dir:
         try: