fix(workspace): persist parsed résumé pre-analysis + raise job page_size 12→50

Two issues from user testing:

1. "Every query returns exactly 12 jobs" — NOT an RPC/corpus cap. The
   search call in WorkspaceShell hardcoded `page_size: 12` (earlier
   grep missed it — it's the shell handler, not JobSearch.tsx).
   Backend already allows up to 50. Set to 50; resolves the
   exactly-12 mystery and the page_size decision in one line.

2. Parsed résumé lost on reload. Root cause: the workspace autosave
   only fires once an analysis exists (`!analysisState → return`), so
   a parsed-résumé-only state was never persisted; the
   resume-builder, by contrast, autosaves every turn. Fix brings the
   upload path to parity WITHOUT destabilising the working
   post-analysis save:
   - New ADDITIVE effect persists a minimal snapshot the moment a
     résumé parses (signed-in, no analysis yet). It calls
     `saveWorkspaceSnapshot` DIRECTLY, never `persistLatestWorkspace`
     (which sets workspaceSaveMeta and would gate-block the analysis
     autosave) — so the analysis path is wholly untouched. Ref-guarded
     by résumé identity (one save per distinct parse, best-effort,
     retry on failure). Single-row upsert ⇒ a later analysis save
     cleanly supersedes the provisional row.
   - `applySavedWorkspaceSnapshot` gains a résumé-only early-return:
     a real analysis snapshot always has job_description.raw_text; a
     résumé-only one has job_description:{}. Without this, restoring a
     résumé-only snapshot would `setAnalysisState({})` and render a
     broken empty "analysis" — worse than the original bug.
   - No backend change: `_validate_workspace_snapshot` already accepts
     the 5 required sections as empty {} (only checks isinstance dict);
     single upsert per user_id. New hermetic test
     (test_workspace_snapshot_validation.py, 7 cases) pins that
     contract so a future tightening can't silently regress this.

Verified: backend contract test green; tsc + eslint clean. The authed
restore UX (sign in → parse → reload → résumé back, no empty-analysis)
can't be fully runtime-tested locally (authed flow) — eyeball on prod
after deploy. Frontend + test only; no backend code change.

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

Author: LEANDERANTONY

frontend/src/components/workspace/WorkspaceShell.tsx

@@ -44,6 +44,7 @@ import {
   streamWorkspaceAssistantAnswer,
   updateResumeBuilderDraft,
   uploadJobDescriptionFile,
+  saveWorkspaceSnapshot,
   uploadResumeFile,
 } from "@/lib/api";
 import type {
@@ -781,7 +782,9 @@ export function WorkspaceShell() {
         // dropdown's `remote` pick (either route returns the same rows).
         remote_only: workModes.length === 1 && workModes[0] === "remote",
         posted_within_days: postedWithinDays ? Number(postedWithinDays) : null,
-        page_size: 12,
+        // Was hardcoded 12 (the "every query returns exactly 12" cause —
+        // it was never an RPC/corpus cap). Backend allows up to 50.
+        page_size: 50,
         work_modes: workModes,
         employment_types: employmentTypes,
         sort_by: sortBy,
@@ -963,6 +966,25 @@ export function WorkspaceShell() {
     const snapshot = response.workspace_snapshot;
     if (!snapshot) return;
 
+    // Résumé-only snapshot: a parsed résumé persisted BEFORE any
+    // analysis ran (see the résumé-autosave effect). A real analysis
+    // snapshot always carries a job_description with raw_text; a
+    // résumé-only one has job_description:{}. Restore JUST the résumé
+    // and bail — calling setAnalysisState(snapshot) here would light
+    // up an empty/broken "analysis" view, and snapshot.job_description
+    // has no raw_text to read.
+    const jd = snapshot.job_description as { raw_text?: string } | undefined;
+    if (!jd || !jd.raw_text) {
+      setResumeState({
+        resume_document: snapshot.resume_document,
+        candidate_profile: snapshot.candidate_profile,
+      });
+      setSelectedResumeFile(null);
+      setResumeIntakeMode("upload");
+      setMainTab("resume");
+      return;
+    }
+
     setResumeState({
       resume_document: snapshot.resume_document,
       candidate_profile: snapshot.candidate_profile,
@@ -1622,6 +1644,63 @@ export function WorkspaceShell() {
     });
   }
 
+  // Persist a parsed résumé as soon as it exists — even before any
+  // analysis runs — so a tab reload / "Reload saved workspace"
+  // restores it (parity with the resume-builder, which already
+  // autosaves every turn). Deliberately calls saveWorkspaceSnapshot
+  // DIRECTLY, NOT persistLatestWorkspace: the latter sets
+  // workspaceSaveMeta, which would gate-block the post-analysis
+  // autosave effect below. This effect never touches workspaceSaveMeta,
+  // so the analysis path is wholly unaffected; the single-row upsert
+  // means a later analysis save cleanly supersedes this provisional
+  // row. Ref-guarded by résumé identity → fires once per distinct
+  // parsed résumé, never on every render.
+  const resumeAutoSavedRef = useRef<string | null>(null);
+  useEffect(() => {
+    if (
+      authStatus !== "signed_in" ||
+      !authSession?.features.saved_workspace_enabled ||
+      analysisState ||
+      !resumeState?.candidate_profile
+    ) {
+      return;
+    }
+    const identity = `${resumeState.candidate_profile.full_name || ""}|${
+      resumeState.resume_document?.filetype || ""
+    }`;
+    if (resumeAutoSavedRef.current === identity) return;
+    resumeAutoSavedRef.current = identity;
+    // Minimal snapshot: real résumé sections + the other
+    // _validate_workspace_snapshot-required keys as {} (empty dicts
+    // pass its isinstance(dict) check). Cast because this is an
+    // intentionally-partial WorkspaceAnalysisResponse; the backend
+    // accepts any snapshot dict and only validates the 5 keys.
+    const snapshot = {
+      resume_document: resumeState.resume_document,
+      candidate_profile: resumeState.candidate_profile,
+      job_description: {},
+      jd_summary_view: {},
+      fit_analysis: {},
+      tailored_draft: {},
+      agent_result: null,
+      artifacts: {},
+      workflow: {},
+    } as unknown as WorkspaceAnalysisResponse;
+    void saveWorkspaceSnapshot(snapshot).catch(() => {
+      // Best-effort: a failed provisional save must not disrupt the
+      // workspace (the résumé is still in client state, and running
+      // the analysis will persist the full snapshot anyway). Clear
+      // the guard so a later change can retry.
+      resumeAutoSavedRef.current = null;
+    });
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- fires once per distinct parsed résumé while signed-in with no analysis yet; the deps below fully describe that fire condition.
+  }, [
+    resumeState,
+    analysisState,
+    authStatus,
+    authSession?.features.saved_workspace_enabled,
+  ]);
+
   useEffect(() => {
     if (
       authStatus !== "signed_in" ||

tests/backend/test_workspace_snapshot_validation.py

@@ -0,0 +1,76 @@
+"""Contract test for `_validate_workspace_snapshot`.
+
+The "persist a parsed résumé before any analysis runs" feature (so a
+tab reload restores it, parity with the resume-builder) depends on a
+specific, easily-broken contract: the saved-workspace validator must
+accept a *résumé-only* snapshot — real `candidate_profile` /
+`resume_document`, but the other required sections present only as
+empty dicts (no analysis has run yet). The frontend builds exactly
+that shape and POSTs it to /workspace/save.
+
+If a future change makes `_validate_workspace_snapshot` require any of
+those sections to be *non-empty*, the provisional résumé save would
+start 4xx-ing silently and the reload-restore would regress. These
+hermetic tests (pure function, no Supabase) pin the contract.
+"""
+from __future__ import annotations
+
+import pytest
+
+from backend.services.workspace_persistence_service import (
+    _validate_workspace_snapshot,
+)
+
+# The 5 sections the validator requires to each be a dict.
+_REQUIRED = [
+    "candidate_profile",
+    "job_description",
+    "fit_analysis",
+    "tailored_draft",
+    "artifacts",
+]
+
+
+def _resume_only_snapshot() -> dict:
+    """Mirrors what the frontend résumé-autosave effect sends: real
+    résumé sections, the rest present as empty dicts."""
+    return {
+        "resume_document": {"filetype": "pdf", "text": "…"},
+        "candidate_profile": {"full_name": "Leander Antony", "skills": ["Python"]},
+        "job_description": {},
+        "jd_summary_view": {},
+        "fit_analysis": {},
+        "tailored_draft": {},
+        "agent_result": None,
+        "artifacts": {},
+        "workflow": {},
+    }
+
+
+def test_resume_only_snapshot_passes_validation():
+    # The load-bearing assertion: empty {} for the not-yet-existing
+    # sections satisfies the isinstance(dict) check, so a parsed-résumé
+    # snapshot persists fine before any analysis.
+    payload = _validate_workspace_snapshot(_resume_only_snapshot())
+    assert payload["candidate_profile"]["full_name"] == "Leander Antony"
+    for section in _REQUIRED:
+        assert isinstance(payload[section], dict)
+
+
+@pytest.mark.parametrize("missing", _REQUIRED)
+def test_missing_required_section_still_rejected(missing):
+    # The relax is "empty dict is OK", NOT "anything goes" — a section
+    # that isn't a dict at all must still raise (the validator stays a
+    # real guard).
+    snap = _resume_only_snapshot()
+    snap[missing] = None  # not a dict
+    with pytest.raises(ValueError) as exc:
+        _validate_workspace_snapshot(snap)
+    assert missing in str(exc.value)
+
+
+def test_absent_section_rejected():
+    snap = _resume_only_snapshot()
+    del snap["artifacts"]
+    with pytest.raises(ValueError):
+        _validate_workspace_snapshot(snap)