fix(jd): unify paste / upload / load-from-search through LLM parser

The 2026-05-27 jobagent re-verify report caught the JD parser STILL
leaking section headers ("REQUIREMENTS / MUST-HAVES") and
misclassifying items across sections on Step 03 — even though
backend commit 2d75bae had already shipped the section-label
artifact scrub + benefits keyword filter in
src/services/jd_llm_parser_service.py.

Root cause was a frontend architecture issue, not a regression in
that backend fix:

  * JDReview.tsx read its Must-Have / Nice-to-Have data from
    EITHER analysisState (post-Step-04 LLM pipeline) OR a frontend
    `buildJobReview` regex over the raw text. It NEVER read from
    `jobFileState` — the LLM-parsed response from the
    /workspace/job-description/upload endpoint, which already had
    the cleaned LLM data sitting unused in state after every file
    upload.
  * Pasted text was an even bigger gap: pasting hit nothing but the
    frontend regex. No backend call at all until Step 04 fired —
    which a Step-03-only verifier with no résumé loaded can never
    trigger.

Two-phase fix, both in this commit because they only deliver value
together (Phase 1 adds the display path; Phase 2 fills it for the
paste / load-from-search paths that didn't populate jobFileState
before).

Phase 1 — JDReview reads jobFileState (frontend wiring only,
no new backend calls):
  * Introduced a unified precedence chain used everywhere derived
    JD fields are computed:
      analysisState (Step 04, !stale) > jobFileState > review (regex)
  * Applies to: heroTitle, heroLocation, heroSource label,
    hardSkills, softSkills, summaryText, bodySections (Must-Have
    Themes / Nice-to-Have Signals / etc.), and the new
    pre-analysis Hard-skills / Years-required metric tiles.
  * Removed the now-unused summaryHeadlineFromAnalysis helper.
  * Existing Match-Score tile stays placeholder pre-analysis
    (jobFileState has no fit_analysis — only Step 04 produces that).

Phase 2 — auto-parse pasted / loaded text via the existing
upload endpoint (debounced + cached):
  * New useEffect in WorkspaceShell watches manualJobText. After
    1500ms of no changes AND text >=100 chars AND auth signed_in,
    fires uploadJobDescriptionFile with a synthetic ``pasted.txt``
    Blob. The backend extracts text from .txt as a no-op and
    routes the same build_job_description_from_text_auto path the
    file-upload UI uses.
  * Result lands in jobFileState — same state slot, same shape, so
    Phase 1's display wiring picks it up automatically.
  * Refs (lastParsedTextRef / parseAbortRef / parseDebounceRef)
    handle: dedup (skip re-parsing identical text), abort
    (in-flight requests cancel if the user keeps typing), debounce
    (timer resets on every keystroke).
  * Already-uploaded text via the explicit upload UI also gets
    short-circuited via the
    ``jobFileState.job_description_text === text`` check — avoids
    a second redundant parse of the same content.
  * Failures don't surface a toast (regex preview still renders);
    quota / auth errors come through the request wrapper's own
    interceptor.

Result: ALL three input paths (paste / upload / load-from-search)
hit the LLM parser within ~1.5s of the user settling on text. The
deterministic regex remains only as a true fallback for the
brief debounce window, auth-loading states, and offline scenarios.

tsc + eslint clean on touched files.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: LEANDERANTONY

frontend/src/components/workspace/JDReview.tsx

@@ -126,13 +126,6 @@ export type JDReviewProps = {
   onClearLoadedJobDescription: () => void;
 };
 
-function summaryHeadlineFromAnalysis(
-  analysis: WorkspaceAnalysisResponse | null,
-): string | null {
-  if (!analysis) return null;
-  return analysis.jd_summary_view?.summary || null;
-}
-
 export function JDReview({
   analysisState,
   analysisIsStale,
@@ -157,10 +150,41 @@ export function JDReview({
     event.target.value = "";
   }
 
+  // Data-source precedence for every derived field below:
+  //
+  //   analysisState (Step 04 ran, !stale)  >  jobFileState (LLM parse
+  //   from upload OR debounced paste-auto-parse)  >  review (frontend
+  //   deterministic regex from buildJobReview)
+  //
+  // Before the 2026-05-27 unification, JDReview only used analysisState
+  // or review — jobFileState's LLM-parsed requirements + jd_summary_view
+  // were FETCHED but never displayed. So even after a clean upload, the
+  // Must-Have / Nice-to-Have panels showed the brittle frontend regex
+  // (which leaked section headers like "REQUIREMENTS / MUST-HAVES" and
+  // misclassified items across sections). Now the LLM parse is the
+  // primary source whenever it's available, with regex only as a true
+  // fallback when no LLM parse exists yet.
+  //
+  // The jobFileState slot is populated by three paths:
+  //   1. Explicit file upload (handleJobDescriptionUpload)
+  //   2. Debounced auto-parse of pasted text (Phase 2 in WorkspaceShell)
+  //   3. Future paths that hit the same /workspace/job-description/upload
+  //      endpoint
+  // All three produce a WorkspaceJobDescriptionUploadResponse with the
+  // same { job_description, jd_summary_view } shape, so this component
+  // doesn't need to know which path populated it.
+  const llmJobDescription =
+    analysisState && !analysisIsStale
+      ? analysisState.job_description
+      : jobFileState?.job_description ?? null;
+  const llmSummaryView =
+    analysisState && !analysisIsStale
+      ? analysisState.jd_summary_view
+      : jobFileState?.jd_summary_view ?? null;
+
   const heroTitle =
     activeJob?.title ||
-    jobFileState?.job_description.title ||
-    analysisState?.job_description.title ||
+    llmJobDescription?.title ||
     review?.summaryCards.find((card) => card.label === "Target Role")?.value ||
     "Job description";
 
@@ -171,12 +195,13 @@ export function JDReview({
 
   const heroLocation =
     activeJob?.location ||
+    llmJobDescription?.location ||
     review?.summaryCards.find((card) => card.label === "Location")?.value ||
     "";
 
   const heroSource =
     activeJob?.source ||
-    (jobFileState ? "Uploaded file" : review ? "Pasted text" : "");
+    (jobFileState ? "Parsed JD" : review ? "Pasted text" : "");
 
   // Hero metrics: prefer the parsed analysisState numbers when fresh,
   // fall back to the JobReview computed by `buildJobReview` from the
@@ -197,6 +222,10 @@ export function JDReview({
     tone?: "muted";
   };
   const metrics = ((): HeroMetric[] => {
+    // Match Score tile only populates from a fresh analysisState (it's
+    // derived from fit_analysis which doesn't exist on jobFileState).
+    // jobFileState provides the requirement counts but never a score —
+    // that requires the full Step 04 pipeline.
     if (analysisState && !analysisIsStale) {
       const fit = analysisState.fit_analysis;
       return [
@@ -224,6 +253,37 @@ export function JDReview({
         },
       ];
     }
+    // Pre-analysis path: prefer jobFileState requirement counts (LLM-
+    // parsed, accurate) over the review regex counts when both exist.
+    // Match Score tile still placeholder until analysis runs.
+    if (llmJobDescription) {
+      const yrs = llmJobDescription.requirements.experience_requirement
+        ? llmJobDescription.requirements.experience_requirement
+            .replace(/[^0-9+]/g, "")
+            .slice(0, 4) || "—"
+        : "—";
+      return [
+        {
+          label: "Match score",
+          value: "—",
+          unit: "",
+          hint: analysisState && analysisIsStale
+            ? "Re-run analysis (inputs changed)"
+            : "Run analysis to compute",
+          tone: "muted",
+        },
+        {
+          label: "Hard skills",
+          value: String(llmJobDescription.requirements.hard_skills.length),
+          unit: "",
+        },
+        {
+          label: "Years required",
+          value: yrs,
+          unit: "",
+        },
+      ];
+    }
     if (review) {
       return [
         {
@@ -259,27 +319,32 @@ export function JDReview({
     return [];
   })();
 
+  // Summary headline: jd_summary_view from LLM is preferred; regex
+  // "Role Snapshot" is the last resort.
   const summaryText =
-    (analysisState && !analysisIsStale && summaryHeadlineFromAnalysis(analysisState)) ||
+    llmSummaryView?.summary ||
     review?.summarySections.find((section) => section.title === "Role Snapshot")
       ?.items?.[0] ||
     null;
 
+  // Skill arrays follow the same precedence — LLM-parsed wins.
   const hardSkills =
-    analysisState && !analysisIsStale
-      ? analysisState.job_description.requirements.hard_skills
-      : (review?.hardSkills ?? []);
+    llmJobDescription?.requirements.hard_skills ?? review?.hardSkills ?? [];
   const softSkills =
-    analysisState && !analysisIsStale
-      ? analysisState.job_description.requirements.soft_skills
-      : (review?.softSkills ?? []);
+    llmJobDescription?.requirements.soft_skills ?? review?.softSkills ?? [];
 
+  // Body sections (Must-Have Themes / Nice-to-Have Signals / etc.)
+  // prefer the LLM-built jd_summary_view.sections — that's the source
+  // that gets the section-header scrubbing + benefits-keyword filter
+  // applied in jd_llm_parser_service.py. Falls through to regex only
+  // when no LLM parse exists yet (e.g. text was just pasted and the
+  // debounce hasn't fired yet, or the user is offline).
   const bodySections =
-    analysisState && !analysisIsStale
-      ? analysisState.jd_summary_view.sections
-      : (review?.summarySections.filter(
-          (section) => section.title !== "Role Snapshot",
-        ) ?? []);
+    llmSummaryView?.sections ??
+    review?.summarySections.filter(
+      (section) => section.title !== "Role Snapshot",
+    ) ??
+    [];
 
   const inputBodyVisible = !jobInputCollapsed;
 

frontend/src/components/workspace/WorkspaceShell.tsx

@@ -516,6 +516,107 @@ export function WorkspaceShell() {
     }
   }, [activeJob, jobFileState]);
 
+  // ── JD auto-parse via LLM ─────────────────────────────────────────
+  // Debounced effect that pipes pasted / loaded-from-search JD text
+  // through the same /workspace/job-description/upload endpoint a
+  // file upload uses. The endpoint returns the LLM-parsed
+  // jd_summary_view + requirements; that response lands in
+  // `jobFileState`, and JDReview's precedence chain
+  // (analysisState > jobFileState > review) automatically picks it
+  // up to render the Must-Have Themes / Nice-to-Have Signals panels
+  // from LLM output instead of the brittle frontend regex.
+  //
+  // Why we route paste through the SAME endpoint as upload (instead
+  // of a new /jd/parse-text route): zero new backend surface, zero
+  // new tests, and a single LLM-quality contract for ALL three input
+  // paths (paste / upload / load-from-search). The endpoint takes
+  // any file via UploadedFilePayloadModel — sending the pasted text
+  // as a synthetic ``pasted.txt`` blob skips the file-extraction
+  // step internally (it's already text) and falls straight through
+  // to build_job_description_from_text_auto.
+  //
+  // Guards (all four required before firing):
+  //   1. authStatus === "signed_in" — the endpoint requires auth.
+  //   2. text length >= 100 chars — under that, regex is fine and
+  //      we don't want to burn token quota on placeholder text.
+  //   3. text hash differs from the last successfully-parsed text
+  //      — avoids re-parsing the same content on every render or
+  //      after the user pastes back the same JD they had before.
+  //   4. text differs from jobFileState.job_description_text — if a
+  //      file upload (or earlier paste-parse) already set
+  //      jobFileState from the same text, skip.
+  //
+  // Debounce: 1500 ms after the LAST keystroke. Cancels the prior
+  // timer + aborts the in-flight request, so a fast typist who pauses
+  // briefly + resumes never fires multiple parses.
+  const lastParsedTextRef = useRef<string>("");
+  const parseDebounceRef = useRef<number | null>(null);
+  const parseAbortRef = useRef<AbortController | null>(null);
+  useEffect(() => {
+    if (parseDebounceRef.current !== null) {
+      window.clearTimeout(parseDebounceRef.current);
+      parseDebounceRef.current = null;
+    }
+    if (parseAbortRef.current) {
+      parseAbortRef.current.abort();
+      parseAbortRef.current = null;
+    }
+    const text = manualJobText.trim();
+    if (!text || text.length < 100) return;
+    if (authStatus !== "signed_in") return;
+    if (text === lastParsedTextRef.current) return;
+    if (jobFileState?.job_description_text?.trim() === text) {
+      // Already parsed by an upload or earlier paste — sync the cache
+      // so future renders of the same text don't re-fire.
+      lastParsedTextRef.current = text;
+      return;
+    }
+
+    parseDebounceRef.current = window.setTimeout(async () => {
+      parseDebounceRef.current = null;
+      const abort = new AbortController();
+      parseAbortRef.current = abort;
+      setJobFileUploading(true);
+      try {
+        // Use a synthetic .txt blob to reuse the existing upload path.
+        // The backend extracts text from .txt files as a no-op and
+        // routes straight into build_job_description_from_text_auto
+        // (the same LLM path the file-upload UI uses).
+        const blob = new Blob([text], { type: "text/plain" });
+        const file = new File([blob], "pasted.txt", { type: "text/plain" });
+        const response = await uploadJobDescriptionFile(file);
+        if (abort.signal.aborted) return;
+        lastParsedTextRef.current = text;
+        setJobFileState(response);
+      } catch (error) {
+        if (abort.signal.aborted) return;
+        // Don't surface a toast for transient parse failures — the
+        // regex preview in JDReview is still rendering the user's
+        // text. A quota / auth error will surface from the request
+        // wrapper's own interceptor.
+        void error;
+      } finally {
+        if (parseAbortRef.current === abort) {
+          parseAbortRef.current = null;
+        }
+        setJobFileUploading(false);
+      }
+    }, 1500);
+
+    return () => {
+      if (parseDebounceRef.current !== null) {
+        window.clearTimeout(parseDebounceRef.current);
+        parseDebounceRef.current = null;
+      }
+    };
+    // Intentionally only re-run on manualJobText / authStatus changes.
+    // jobFileState IS read inside the effect but we don't want updates
+    // to it to re-trigger the effect (the effect SETS it, which would
+    // create a loop). The "already-parsed" check above handles the
+    // stale-jobFileState case safely on the next text change.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [manualJobText, authStatus]);
+
   const {
     savedJobs,
     savedJobsLoading,