From cc72fe49e56854dae2c8d8c47f2a7a4ff99e29ac Mon Sep 17 00:00:00 2001
From: tpikachu <sjkunai@outlook.com>
Date: Thu, 2 Jul 2026 07:28:15 -0500
Subject: [PATCH 1/6] =?UTF-8?q?feat:=20Tailor=20Resume=20backend=20?=
 =?UTF-8?q?=E2=80=94=20applications,=20tailoring=20op,=20tailored=20ground?=
 =?UTF-8?q?ing=20(v1.3=20#1)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The Tailor Resume core: one LLM op (services/openai/tailor.ts, new 'tailor' model
key — full gpt-4.1 on balanced) takes a base resume × JD × application questions and
returns an ATS-friendly tailored resume (grounded ONLY in the base resume — never
invented experience), grounded answers, and the extracted jobTitle/company.

- New applications table (migration 0006, profile-cascade + created_at index) +
  applicationsRepo (global newest-first page() with LIKE search + profile join;
  delete() removes the dedicated job + its chunks).
- Each application owns a dedicated Job row holding the JD; indexJob now also
  indexes the application's tailored resume as job-scoped `tailored` chunks, and
  vectorStore.search drops base `resume` chunks when the selected job has tailored
  ones — so "Start interview" grounds sessions in the TAILORED resume + JD with the
  session pipeline untouched. Application-owned jobs are hidden from the regular
  Interviews list/page/count.
- applications:{page,get,tailor,delete} IPC + preload facade. The tailor handler
  runs ALL model calls before any DB write (an LLM failure persists nothing); an
  uploaded base resume materializes a real, reusable profile.
- tailor.test.ts (+8): request shape, grounding/ATS prompt, defensive parsing.

Verified: typecheck · 126 unit · build green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 drizzle/0006_sour_shotgun.sql                 |   18 +
 drizzle/meta/0006_snapshot.json               | 1356 +++++++++++++++++
 drizzle/meta/_journal.json                    |    7 +
 src/main/db/repositories/applications.repo.ts |  117 ++
 src/main/db/repositories/jobs.repo.ts         |   23 +-
 src/main/db/schema.ts                         |   33 +-
 src/main/ipc/applications.ipc.ts              |  120 ++
 src/main/ipc/index.ts                         |    2 +
 src/main/services/openai/models.ts            |    6 +
 src/main/services/openai/tailor.test.ts       |  113 ++
 src/main/services/openai/tailor.ts            |  104 ++
 src/main/services/rag/indexProfile.ts         |    9 +-
 src/main/services/rag/vectorStore.ts          |   19 +-
 src/preload/index.ts                          |   24 +-
 src/shared/ipc.ts                             |    6 +
 src/shared/types.ts                           |   33 +-
 16 files changed, 1975 insertions(+), 15 deletions(-)
 create mode 100644 drizzle/0006_sour_shotgun.sql
 create mode 100644 drizzle/meta/0006_snapshot.json
 create mode 100644 src/main/db/repositories/applications.repo.ts
 create mode 100644 src/main/ipc/applications.ipc.ts
 create mode 100644 src/main/services/openai/tailor.test.ts
 create mode 100644 src/main/services/openai/tailor.ts

diff --git a/drizzle/0006_sour_shotgun.sql b/drizzle/0006_sour_shotgun.sql
new file mode 100644
index 0000000..cc8e7bd
--- /dev/null
+++ b/drizzle/0006_sour_shotgun.sql
@@ -0,0 +1,18 @@
+CREATE TABLE `applications` (
+	`id` text PRIMARY KEY NOT NULL,
+	`profile_id` text NOT NULL,
+	`job_id` text NOT NULL,
+	`name` text DEFAULT '' NOT NULL,
+	`job_title` text DEFAULT '' NOT NULL,
+	`company` text,
+	`base_resume` text NOT NULL,
+	`tailored_resume` text NOT NULL,
+	`answers` text,
+	`created_at` integer DEFAULT (unixepoch() * 1000) NOT NULL,
+	`updated_at` integer DEFAULT (unixepoch() * 1000) NOT NULL,
+	FOREIGN KEY (`profile_id`) REFERENCES `profiles`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`job_id`) REFERENCES `jobs`(`id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE INDEX `applications_profile_idx` ON `applications` (`profile_id`);--> statement-breakpoint
+CREATE INDEX `applications_created_idx` ON `applications` (`created_at`);
\ No newline at end of file
diff --git a/drizzle/meta/0006_snapshot.json b/drizzle/meta/0006_snapshot.json
new file mode 100644
index 0000000..b89c557
--- /dev/null
+++ b/drizzle/meta/0006_snapshot.json
@@ -0,0 +1,1356 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "2794c821-df96-45f9-ac5f-941c81991ec4",
+  "prevId": "10d8736e-41b3-4d27-8c0e-d2b00327aae1",
+  "tables": {
+    "ai_answers": {
+      "name": "ai_answers",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "question_id": {
+          "name": "question_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "direct_answer": {
+          "name": "direct_answer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "talking_points": {
+          "name": "talking_points",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "resume_match": {
+          "name": "resume_match",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "star": {
+          "name": "star",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "clarifying_question": {
+          "name": "clarifying_question",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "risk_warning": {
+          "name": "risk_warning",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "followup_question": {
+          "name": "followup_question",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "model": {
+          "name": "model",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "tokens": {
+          "name": "tokens",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch() * 1000)"
+        }
+      },
+      "indexes": {
+        "answers_question_idx": {
+          "name": "answers_question_idx",
+          "columns": [
+            "question_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "ai_answers_question_id_detected_questions_id_fk": {
+          "name": "ai_answers_question_id_detected_questions_id_fk",
+          "tableFrom": "ai_answers",
+          "tableTo": "detected_questions",
+          "columnsFrom": [
+            "question_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "applications": {
+      "name": "applications",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "profile_id": {
+          "name": "profile_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "job_title": {
+          "name": "job_title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "company": {
+          "name": "company",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "base_resume": {
+          "name": "base_resume",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "tailored_resume": {
+          "name": "tailored_resume",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "answers": {
+          "name": "answers",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch() * 1000)"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch() * 1000)"
+        }
+      },
+      "indexes": {
+        "applications_profile_idx": {
+          "name": "applications_profile_idx",
+          "columns": [
+            "profile_id"
+          ],
+          "isUnique": false
+        },
+        "applications_created_idx": {
+          "name": "applications_created_idx",
+          "columns": [
+            "created_at"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "applications_profile_id_profiles_id_fk": {
+          "name": "applications_profile_id_profiles_id_fk",
+          "tableFrom": "applications",
+          "tableTo": "profiles",
+          "columnsFrom": [
+            "profile_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "applications_job_id_jobs_id_fk": {
+          "name": "applications_job_id_jobs_id_fk",
+          "tableFrom": "applications",
+          "tableTo": "jobs",
+          "columnsFrom": [
+            "job_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "chunks": {
+      "name": "chunks",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "profile_id": {
+          "name": "profile_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_type": {
+          "name": "source_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "ord": {
+          "name": "ord",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "token_count": {
+          "name": "token_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch() * 1000)"
+        }
+      },
+      "indexes": {
+        "chunks_profile_idx": {
+          "name": "chunks_profile_idx",
+          "columns": [
+            "profile_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "chunks_profile_id_profiles_id_fk": {
+          "name": "chunks_profile_id_profiles_id_fk",
+          "tableFrom": "chunks",
+          "tableTo": "profiles",
+          "columnsFrom": [
+            "profile_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "chunks_job_id_jobs_id_fk": {
+          "name": "chunks_job_id_jobs_id_fk",
+          "tableFrom": "chunks",
+          "tableTo": "jobs",
+          "columnsFrom": [
+            "job_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "detected_questions": {
+      "name": "detected_questions",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "session_id": {
+          "name": "session_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "text": {
+          "name": "text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'behavioral'"
+        },
+        "confidence": {
+          "name": "confidence",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "strategy": {
+          "name": "strategy",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "transcript_chunk_id": {
+          "name": "transcript_chunk_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch() * 1000)"
+        }
+      },
+      "indexes": {
+        "questions_session_idx": {
+          "name": "questions_session_idx",
+          "columns": [
+            "session_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "detected_questions_session_id_sessions_id_fk": {
+          "name": "detected_questions_session_id_sessions_id_fk",
+          "tableFrom": "detected_questions",
+          "tableTo": "sessions",
+          "columnsFrom": [
+            "session_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "documents": {
+      "name": "documents",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "profile_id": {
+          "name": "profile_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "filename": {
+          "name": "filename",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "mime": {
+          "name": "mime",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_path": {
+          "name": "source_path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "text": {
+          "name": "text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch() * 1000)"
+        }
+      },
+      "indexes": {
+        "documents_profile_idx": {
+          "name": "documents_profile_idx",
+          "columns": [
+            "profile_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "documents_profile_id_profiles_id_fk": {
+          "name": "documents_profile_id_profiles_id_fk",
+          "tableFrom": "documents",
+          "tableTo": "profiles",
+          "columnsFrom": [
+            "profile_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "embeddings": {
+      "name": "embeddings",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "chunk_id": {
+          "name": "chunk_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "model": {
+          "name": "model",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "dim": {
+          "name": "dim",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "vector": {
+          "name": "vector",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch() * 1000)"
+        }
+      },
+      "indexes": {
+        "embeddings_chunk_id_unique": {
+          "name": "embeddings_chunk_id_unique",
+          "columns": [
+            "chunk_id"
+          ],
+          "isUnique": true
+        },
+        "embeddings_chunk_idx": {
+          "name": "embeddings_chunk_idx",
+          "columns": [
+            "chunk_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "embeddings_chunk_id_chunks_id_fk": {
+          "name": "embeddings_chunk_id_chunks_id_fk",
+          "tableFrom": "embeddings",
+          "tableTo": "chunks",
+          "columnsFrom": [
+            "chunk_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "jobs": {
+      "name": "jobs",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "profile_id": {
+          "name": "profile_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "company": {
+          "name": "company",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "jd_url": {
+          "name": "jd_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "jd_text": {
+          "name": "jd_text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "parsed_jd": {
+          "name": "parsed_jd",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "company_url": {
+          "name": "company_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "company_research": {
+          "name": "company_research",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "parsed_company": {
+          "name": "parsed_company",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch() * 1000)"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch() * 1000)"
+        }
+      },
+      "indexes": {
+        "jobs_profile_idx": {
+          "name": "jobs_profile_idx",
+          "columns": [
+            "profile_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "jobs_profile_id_profiles_id_fk": {
+          "name": "jobs_profile_id_profiles_id_fk",
+          "tableFrom": "jobs",
+          "tableTo": "profiles",
+          "columnsFrom": [
+            "profile_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "notes": {
+      "name": "notes",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "profile_id": {
+          "name": "profile_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch() * 1000)"
+        }
+      },
+      "indexes": {
+        "notes_profile_idx": {
+          "name": "notes_profile_idx",
+          "columns": [
+            "profile_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "notes_profile_id_profiles_id_fk": {
+          "name": "notes_profile_id_profiles_id_fk",
+          "tableFrom": "notes",
+          "tableTo": "profiles",
+          "columnsFrom": [
+            "profile_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "profiles": {
+      "name": "profiles",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "target_role": {
+          "name": "target_role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "target_company": {
+          "name": "target_company",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "interview_type": {
+          "name": "interview_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'general'"
+        },
+        "answer_style": {
+          "name": "answer_style",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'concise'"
+        },
+        "language": {
+          "name": "language",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'en'"
+        },
+        "resume_text": {
+          "name": "resume_text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "jd_text": {
+          "name": "jd_text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "parsed_resume": {
+          "name": "parsed_resume",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "parsed_jd": {
+          "name": "parsed_jd",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch() * 1000)"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch() * 1000)"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "session_reports": {
+      "name": "session_reports",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "session_id": {
+          "name": "session_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "summary": {
+          "name": "summary",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "strengths": {
+          "name": "strengths",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "improvements": {
+          "name": "improvements",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "per_question": {
+          "name": "per_question",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch() * 1000)"
+        }
+      },
+      "indexes": {
+        "session_reports_session_id_unique": {
+          "name": "session_reports_session_id_unique",
+          "columns": [
+            "session_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "session_reports_session_id_sessions_id_fk": {
+          "name": "session_reports_session_id_sessions_id_fk",
+          "tableFrom": "session_reports",
+          "tableTo": "sessions",
+          "columnsFrom": [
+            "session_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "sessions": {
+      "name": "sessions",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "profile_id": {
+          "name": "profile_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "interview_type": {
+          "name": "interview_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'general'"
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'idle'"
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "ended_at": {
+          "name": "ended_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch() * 1000)"
+        }
+      },
+      "indexes": {
+        "sessions_profile_idx": {
+          "name": "sessions_profile_idx",
+          "columns": [
+            "profile_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "sessions_profile_id_profiles_id_fk": {
+          "name": "sessions_profile_id_profiles_id_fk",
+          "tableFrom": "sessions",
+          "tableTo": "profiles",
+          "columnsFrom": [
+            "profile_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "sessions_job_id_jobs_id_fk": {
+          "name": "sessions_job_id_jobs_id_fk",
+          "tableFrom": "sessions",
+          "tableTo": "jobs",
+          "columnsFrom": [
+            "job_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "settings": {
+      "name": "settings",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "stories": {
+      "name": "stories",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "profile_id": {
+          "name": "profile_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "situation": {
+          "name": "situation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "task": {
+          "name": "task",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "action": {
+          "name": "action",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "result": {
+          "name": "result",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "competencies": {
+          "name": "competencies",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "skills": {
+          "name": "skills",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch() * 1000)"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch() * 1000)"
+        }
+      },
+      "indexes": {
+        "stories_profile_idx": {
+          "name": "stories_profile_idx",
+          "columns": [
+            "profile_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "stories_profile_id_profiles_id_fk": {
+          "name": "stories_profile_id_profiles_id_fk",
+          "tableFrom": "stories",
+          "tableTo": "profiles",
+          "columnsFrom": [
+            "profile_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "transcript_chunks": {
+      "name": "transcript_chunks",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "session_id": {
+          "name": "session_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "speaker": {
+          "name": "speaker",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'unknown'"
+        },
+        "text": {
+          "name": "text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "is_final": {
+          "name": "is_final",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "t_start": {
+          "name": "t_start",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "t_end": {
+          "name": "t_end",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch() * 1000)"
+        }
+      },
+      "indexes": {
+        "transcript_session_idx": {
+          "name": "transcript_session_idx",
+          "columns": [
+            "session_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "transcript_chunks_session_id_sessions_id_fk": {
+          "name": "transcript_chunks_session_id_sessions_id_fk",
+          "tableFrom": "transcript_chunks",
+          "tableTo": "sessions",
+          "columnsFrom": [
+            "session_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}
\ No newline at end of file
diff --git a/drizzle/meta/_journal.json b/drizzle/meta/_journal.json
index cd8453d..9d02267 100644
--- a/drizzle/meta/_journal.json
+++ b/drizzle/meta/_journal.json
@@ -43,6 +43,13 @@
       "when": 1782843181685,
       "tag": "0005_wealthy_rhino",
       "breakpoints": true
+    },
+    {
+      "idx": 6,
+      "version": "6",
+      "when": 1782994837940,
+      "tag": "0006_sour_shotgun",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file
diff --git a/src/main/db/repositories/applications.repo.ts b/src/main/db/repositories/applications.repo.ts
new file mode 100644
index 0000000..0726e9e
--- /dev/null
+++ b/src/main/db/repositories/applications.repo.ts
@@ -0,0 +1,117 @@
+import { desc, eq, like, or, sql } from 'drizzle-orm';
+import { db, schema } from '../index';
+import { jobsRepo } from './jobs.repo';
+import type { Application, ApplicationAnswer, ApplicationListItem } from '@shared/types';
+
+type Row = typeof schema.applications.$inferSelect;
+
+function toApplication(r: Row): Application {
+  return {
+    id: r.id,
+    profileId: r.profileId,
+    jobId: r.jobId,
+    name: r.name,
+    jobTitle: r.jobTitle,
+    company: r.company,
+    baseResume: r.baseResume,
+    tailoredResume: r.tailoredResume,
+    answers: r.answers ? (JSON.parse(r.answers) as ApplicationAnswer[]) : [],
+    createdAt: r.createdAt,
+    updatedAt: r.updatedAt,
+  };
+}
+
+export const applicationsRepo = {
+  get(id: string): Application | null {
+    const r = db().select().from(schema.applications).where(eq(schema.applications.id, id)).get();
+    return r ? toApplication(r) : null;
+  },
+
+  /** The application that owns a job (if any) — used by indexJob to pick up the
+   *  tailored resume as `tailored` chunks, and by jobs list filtering. */
+  getByJobId(jobId: string): Application | null {
+    const r = db()
+      .select()
+      .from(schema.applications)
+      .where(eq(schema.applications.jobId, jobId))
+      .get();
+    return r ? toApplication(r) : null;
+  },
+
+  create(input: {
+    profileId: string;
+    jobId: string;
+    name: string;
+    jobTitle: string;
+    company: string | null;
+    baseResume: string;
+    tailoredResume: string;
+    answers: ApplicationAnswer[];
+  }): Application {
+    const id = crypto.randomUUID();
+    db()
+      .insert(schema.applications)
+      .values({
+        id,
+        profileId: input.profileId,
+        jobId: input.jobId,
+        name: input.name,
+        jobTitle: input.jobTitle,
+        company: input.company,
+        baseResume: input.baseResume,
+        tailoredResume: input.tailoredResume,
+        answers: JSON.stringify(input.answers),
+      })
+      .run();
+    return this.get(id)!;
+  },
+
+  /** A page of applications across ALL profiles, newest first, optionally filtered
+   *  by a search over name/title/company. Server-side LIMIT/OFFSET (see jobs.page). */
+  page(opts: { query?: string; limit: number; offset: number }): {
+    items: ApplicationListItem[];
+    total: number;
+  } {
+    const q = (opts.query ?? '').trim();
+    const where = q
+      ? or(
+          like(schema.applications.name, `%${q}%`),
+          like(schema.applications.jobTitle, `%${q}%`),
+          like(schema.applications.company, `%${q}%`),
+        )
+      : undefined;
+
+    const items = db()
+      .select({
+        row: schema.applications,
+        profileName: schema.profiles.name,
+      })
+      .from(schema.applications)
+      .leftJoin(schema.profiles, eq(schema.profiles.id, schema.applications.profileId))
+      .where(where)
+      .orderBy(desc(schema.applications.createdAt))
+      .limit(opts.limit)
+      .offset(opts.offset)
+      .all()
+      .map((r) => ({ ...toApplication(r.row), profileName: r.profileName ?? null }));
+
+    const total =
+      db()
+        .select({ c: sql<number>`count(*)` })
+        .from(schema.applications)
+        .where(where)
+        .get()?.c ?? 0;
+    return { items, total };
+  },
+
+  /** Delete an application AND its dedicated job (JD/company/tailored chunks +
+   *  embeddings; sessions keep their history with jobId nulled — same semantics as
+   *  deleting a job). The app row is removed explicitly too, so this works whether
+   *  or not the DB enforces the ON DELETE cascade from jobs. */
+  delete(id: string): void {
+    const app = this.get(id);
+    if (!app) return;
+    jobsRepo.delete(app.jobId);
+    db().delete(schema.applications).where(eq(schema.applications.id, id)).run();
+  },
+};
diff --git a/src/main/db/repositories/jobs.repo.ts b/src/main/db/repositories/jobs.repo.ts
index 4fa1ca8..f738261 100644
--- a/src/main/db/repositories/jobs.repo.ts
+++ b/src/main/db/repositories/jobs.repo.ts
@@ -1,9 +1,15 @@
-import { and, desc, eq, inArray, like, or, sql } from 'drizzle-orm';
+import { and, desc, eq, inArray, like, notInArray, or, sql } from 'drizzle-orm';
 import { db, schema } from '../index';
 import type { Job } from '@shared/types';
 
 type Row = typeof schema.jobs.$inferSelect;
 
+/** Jobs owned by an application (Tailor Resume) are managed from the Applications
+ *  table — hide them from the regular Interviews list/page so they don't
+ *  double-surface (and can't be deleted out from under their application). */
+const notApplicationOwned = () =>
+  notInArray(schema.jobs.id, db().select({ id: schema.applications.jobId }).from(schema.applications));
+
 function toJob(r: Row): Job {
   return {
     id: r.id,
@@ -27,7 +33,7 @@ export const jobsRepo = {
     return db()
       .select()
       .from(schema.jobs)
-      .where(eq(schema.jobs.profileId, profileId))
+      .where(and(eq(schema.jobs.profileId, profileId), notApplicationOwned()))
       .orderBy(desc(schema.jobs.updatedAt))
       .all()
       .map(toJob);
@@ -38,9 +44,16 @@ export const jobsRepo = {
     return r ? toJob(r) : null;
   },
 
-  /** Total interviews (jobs) across all profiles — for the sidebar stats. */
+  /** Total interviews (jobs) across all profiles — for the sidebar stats. Excludes
+   *  application-owned jobs (those are counted as applications, not interviews). */
   count(): number {
-    return db().select({ c: sql<number>`count(*)` }).from(schema.jobs).get()?.c ?? 0;
+    return (
+      db()
+        .select({ c: sql<number>`count(*)` })
+        .from(schema.jobs)
+        .where(notApplicationOwned())
+        .get()?.c ?? 0
+    );
   },
 
   /** A page of jobs for a profile, newest first, optionally filtered by a search
@@ -50,7 +63,7 @@ export const jobsRepo = {
     total: number;
   } {
     const q = (opts.query ?? '').trim();
-    const base = eq(schema.jobs.profileId, opts.profileId);
+    const base = and(eq(schema.jobs.profileId, opts.profileId), notApplicationOwned());
     const where = q
       ? and(base, or(like(schema.jobs.title, `%${q}%`), like(schema.jobs.company, `%${q}%`)))
       : base;
diff --git a/src/main/db/schema.ts b/src/main/db/schema.ts
index db47571..5d2c37d 100644
--- a/src/main/db/schema.ts
+++ b/src/main/db/schema.ts
@@ -96,6 +96,34 @@ export const stories = sqliteTable(
   (t) => ({ byProfile: index('stories_profile_idx').on(t.profileId) }),
 );
 
+// A job application from the Tailor Resume flow. Owns a dedicated jobs row (the JD +
+// the tailored resume's `tailored` chunks); "Start interview" launches a session with
+// (profile_id, job_id) so grounding swaps to the tailored resume automatically.
+export const applications = sqliteTable(
+  'applications',
+  {
+    id: text('id').primaryKey(),
+    profileId: text('profile_id')
+      .notNull()
+      .references(() => profiles.id, { onDelete: 'cascade' }),
+    jobId: text('job_id')
+      .notNull()
+      .references(() => jobs.id, { onDelete: 'cascade' }),
+    name: text('name').notNull().default(''), // candidate/application name
+    jobTitle: text('job_title').notNull().default(''), // extracted from the JD
+    company: text('company'), // extracted from the JD
+    baseResume: text('base_resume').notNull(), // input snapshot (provenance)
+    tailoredResume: text('tailored_resume').notNull(), // markdown — PDF + chunk source
+    answers: text('answers'), // json[] — [{ question, answer }]
+    createdAt: integer('created_at').notNull().default(now),
+    updatedAt: integer('updated_at').notNull().default(now),
+  },
+  (t) => ({
+    byProfile: index('applications_profile_idx').on(t.profileId),
+    byCreated: index('applications_created_idx').on(t.createdAt),
+  }),
+);
+
 export const chunks = sqliteTable(
   'chunks',
   {
@@ -103,9 +131,10 @@ export const chunks = sqliteTable(
     profileId: text('profile_id')
       .notNull()
       .references(() => profiles.id, { onDelete: 'cascade' }),
-    // Resume/notes/story chunks have jobId null; JD chunks belong to a specific job.
+    // Resume/notes/story chunks have jobId null; JD/company/tailored chunks belong
+    // to a specific job.
     jobId: text('job_id').references(() => jobs.id, { onDelete: 'cascade' }),
-    sourceType: text('source_type').notNull(), // resume | jd | note | company | story
+    sourceType: text('source_type').notNull(), // resume | jd | note | company | story | tailored
     sourceId: text('source_id'),
     ord: integer('ord').notNull().default(0),
     content: text('content').notNull(),
diff --git a/src/main/ipc/applications.ipc.ts b/src/main/ipc/applications.ipc.ts
new file mode 100644
index 0000000..8f31bbd
--- /dev/null
+++ b/src/main/ipc/applications.ipc.ts
@@ -0,0 +1,120 @@
+import { z } from 'zod';
+import { IPC } from '@shared/ipc';
+import { handle, zId } from './helpers';
+import { applicationsRepo } from '../db/repositories/applications.repo';
+import { profilesRepo } from '../db/repositories/profiles.repo';
+import { jobsRepo } from '../db/repositories/jobs.repo';
+import { tailorApplication } from '../services/openai/tailor';
+import { parseJobDescription, parseResume } from '../services/openai/parsing';
+import { indexJob, reindexProfile } from '../services/rag/indexProfile';
+import { apiKeyStore } from '../services/security/apiKey';
+
+export function registerApplicationsIpc(): void {
+  handle(
+    IPC.applications.page,
+    z.object({
+      query: z.string().default(''),
+      limit: z.number().int().min(1).max(100).default(8),
+      offset: z.number().int().min(0).default(0),
+    }),
+    ({ query, limit, offset }) => applicationsRepo.page({ query, limit, offset }),
+  );
+
+  handle(IPC.applications.get, zId, ({ id }) => {
+    const app = applicationsRepo.get(id);
+    if (!app) throw new Error('Application not found');
+    return app;
+  });
+
+  // The Tailor Resume operation. ALL model calls run first — nothing is persisted
+  // unless they succeed — then: (create profile for an uploaded base resume) →
+  // dedicated job (JD) → application row → indexJob (embeds jd + tailored chunks).
+  handle(
+    IPC.applications.tailor,
+    z.object({
+      profileId: z.string().nullable().default(null), // existing profile as the base…
+      baseResumeText: z.string().nullable().default(null), // …or an uploaded/pasted resume
+      jdText: z.string().min(1),
+      questions: z.array(z.string()).default([]),
+    }),
+    async ({ profileId, baseResumeText, jdText, questions }) => {
+      if (!apiKeyStore.isPresent())
+        throw new Error('Add your OpenAI API key in Settings to tailor a resume.');
+
+      // Resolve the BASE resume text.
+      let baseResume: string;
+      const existing = profileId ? profilesRepo.get(profileId) : null;
+      if (profileId) {
+        if (!existing) throw new Error('Profile not found.');
+        if (!existing.resumeText?.trim())
+          throw new Error('This profile has no resume text — add one, or upload a resume.');
+        baseResume = existing.resumeText;
+      } else {
+        if (!baseResumeText?.trim())
+          throw new Error('Select a profile or provide the base resume text.');
+        baseResume = baseResumeText;
+      }
+
+      // Model calls first (tailor + JD parse + resume parse for a new profile), so a
+      // failure here leaves the database untouched.
+      const result = await tailorApplication({
+        baseResume,
+        jdText,
+        questions: questions.map((q) => q.trim()).filter(Boolean),
+      });
+      const parsedJd = await parseJobDescription(jdText);
+      const parsedResume = existing ? null : await parseResume(baseResume);
+
+      // Uploaded base resume → materialize a real, reusable profile for it (sessions
+      // and jobs both require an owning profile).
+      let owner = existing;
+      if (!owner) {
+        owner = profilesRepo.create({
+          name: result.candidateName || 'Imported resume',
+          targetRole: result.jobTitle,
+          targetCompany: result.company || null,
+          interviewType: 'general',
+          language: 'en',
+          resumeText: baseResume,
+          jdText: null,
+        });
+        profilesRepo.update(owner.id, { parsedResume });
+        await reindexProfile(owner.id);
+      }
+
+      // The application's dedicated job: holds the JD + (via indexJob) the tailored
+      // chunks. Hidden from the regular Interviews table.
+      const job = jobsRepo.create({
+        profileId: owner.id,
+        title: result.jobTitle || 'Untitled role',
+        company: result.company || null,
+        jdUrl: null,
+        jdText,
+        companyUrl: null,
+        notes: null,
+      });
+      jobsRepo.update(job.id, { parsedJd });
+
+      const app = applicationsRepo.create({
+        profileId: owner.id,
+        jobId: job.id,
+        name: result.candidateName || owner.name,
+        jobTitle: result.jobTitle,
+        company: result.company || null,
+        baseResume,
+        tailoredResume: result.tailoredResume,
+        answers: result.answers,
+      });
+
+      // Embed JD + tailored chunks. If embedding fails the app still exists; its
+      // sessions fall back to base-resume grounding until a re-index succeeds.
+      const { embedded } = await indexJob(job.id);
+      return { application: app, embedded };
+    },
+  );
+
+  handle(IPC.applications.delete, zId, ({ id }) => {
+    applicationsRepo.delete(id);
+    return { deleted: true as const };
+  });
+}
diff --git a/src/main/ipc/index.ts b/src/main/ipc/index.ts
index 67c6f17..cf8868a 100644
--- a/src/main/ipc/index.ts
+++ b/src/main/ipc/index.ts
@@ -3,6 +3,7 @@ import { registerSettingsIpc } from './settings.ipc';
 import { registerProfilesIpc } from './profiles.ipc';
 import { registerDocumentsIpc } from './documents.ipc';
 import { registerJobsIpc } from './jobs.ipc';
+import { registerApplicationsIpc } from './applications.ipc';
 import { registerNotesIpc } from './notes.ipc';
 import { registerStoriesIpc } from './stories.ipc';
 import { registerSessionIpc } from './session.ipc';
@@ -22,6 +23,7 @@ export function registerIpc(): void {
   registerProfilesIpc();
   registerDocumentsIpc();
   registerJobsIpc();
+  registerApplicationsIpc();
   registerNotesIpc();
   registerStoriesIpc();
   registerSessionIpc();
diff --git a/src/main/services/openai/models.ts b/src/main/services/openai/models.ts
index 8f78d5c..ba8b88b 100644
--- a/src/main/services/openai/models.ts
+++ b/src/main/services/openai/models.ts
@@ -16,6 +16,9 @@ const BALANCED = {
   // screenshot path (vision.ts). The one task where a reasoning model earns its cost:
   // latency-tolerant (the user waits a beat) and correctness is the whole point.
   coding: 'gpt-5-mini',
+  // Resume tailoring (Tailor Resume flow) — one-off, latency-tolerant, and the output
+  // IS the user's application document, so it gets the full non-reasoning model.
+  tailor: 'gpt-4.1',
 } as const;
 
 export type ModelKey = keyof typeof BALANCED;
@@ -39,6 +42,7 @@ export const PRESETS: Record<PresetName, Record<ModelKey, string>> = {
     tts: 'gpt-4o-mini-tts',
     mock: 'gpt-4.1-mini',
     coding: 'gpt-5-mini',
+    tailor: 'gpt-4.1-mini',
   },
   best: {
     answer: 'gpt-4.1', // full model: higher quality, still non-reasoning = still snappy
@@ -49,6 +53,7 @@ export const PRESETS: Record<PresetName, Record<ModelKey, string>> = {
     tts: 'gpt-4o-mini-tts',
     mock: 'gpt-4.1',
     coding: 'gpt-5', // strongest reasoning solver for the hardest problems
+    tailor: 'gpt-5', // reasoning model may deliberate over wording; latency is fine here
   },
 };
 
@@ -82,6 +87,7 @@ export type ReasoningEffort = 'low' | 'medium' | 'high';
  *  default; the live answer/classify paths stay on fast non-reasoning models. */
 export const defaultEfforts: Partial<Record<ModelKey, ReasoningEffort>> = {
   coding: 'low',
+  tailor: 'medium', // only sent when the resolved tailor model is a reasoning one ('best')
 };
 
 /** Effective effort for a task (user override → built-in default → none). */
diff --git a/src/main/services/openai/tailor.test.ts b/src/main/services/openai/tailor.test.ts
new file mode 100644
index 0000000..d2f3d14
--- /dev/null
+++ b/src/main/services/openai/tailor.test.ts
@@ -0,0 +1,113 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+// Capture the request body passed to responses.create and feed back a fixed JSON
+// reply. Mock the model resolver so models.ts → db → better-sqlite3 never loads.
+const h = vi.hoisted(() => ({
+  lastBody: null as Record<string, unknown> | null,
+  reply: '{}',
+}));
+vi.mock('./client', () => ({
+  openai: () => ({
+    responses: {
+      create: (body: Record<string, unknown>) => {
+        h.lastBody = body;
+        return { output_text: h.reply };
+      },
+    },
+  }),
+}));
+vi.mock('./models', () => ({
+  model: (k: string) => `model:${k}`,
+  reasoningParam: () => ({}),
+}));
+
+import { tailorApplication } from './tailor';
+
+function input(over: Partial<Parameters<typeof tailorApplication>[0]> = {}) {
+  return {
+    baseResume: 'Jane Doe\nSWE at Acme. Cut p99 latency 40% with a Node cache layer.',
+    jdText: 'Senior Backend Engineer at Globex. Requires Node.js and caching at scale.',
+    questions: ['Why do you want to work here?'],
+    ...over,
+  };
+}
+
+const systemPrompt = () =>
+  String((h.lastBody!.input as { role: string; content: string }[])[0].content);
+const userPrompt = () =>
+  String((h.lastBody!.input as { role: string; content: string }[])[1].content);
+
+const FULL = JSON.stringify({
+  candidateName: 'Jane Doe',
+  jobTitle: 'Senior Backend Engineer',
+  company: 'Globex',
+  tailoredResume: '# Jane Doe\n\n## Summary\nBackend engineer…',
+  answers: [{ question: 'Why do you want to work here?', answer: 'Because…' }],
+});
+
+beforeEach(() => {
+  h.lastBody = null;
+  h.reply = FULL;
+});
+
+describe('tailorApplication — request', () => {
+  it('uses the tailor model and asks for JSON', async () => {
+    await tailorApplication(input());
+    expect(h.lastBody!.model).toBe('model:tailor');
+    expect(h.lastBody!.text).toEqual({ format: { type: 'json_object' } });
+  });
+
+  it('mandates grounding + ATS structure in the system prompt', async () => {
+    await tailorApplication(input());
+    const s = systemPrompt();
+    expect(s).toMatch(/NEVER invent/i);
+    expect(s).toMatch(/ATS/i);
+    expect(s).toMatch(/no tables/i);
+  });
+
+  it('feeds the base resume, JD, and numbered questions into the prompt', async () => {
+    await tailorApplication(input());
+    const u = userPrompt();
+    expect(u).toContain('Cut p99 latency 40%');
+    expect(u).toContain('Senior Backend Engineer at Globex');
+    expect(u).toContain('1. Why do you want to work here?');
+  });
+
+  it('marks the questions section empty when none are given', async () => {
+    await tailorApplication(input({ questions: [] }));
+    expect(userPrompt()).toContain('APPLICATION QUESTIONS: (none)');
+  });
+});
+
+describe('tailorApplication — defensive parsing', () => {
+  it('returns the parsed result', async () => {
+    const r = await tailorApplication(input());
+    expect(r).toEqual({
+      candidateName: 'Jane Doe',
+      jobTitle: 'Senior Backend Engineer',
+      company: 'Globex',
+      tailoredResume: '# Jane Doe\n\n## Summary\nBackend engineer…',
+      answers: [{ question: 'Why do you want to work here?', answer: 'Because…' }],
+    });
+  });
+
+  it('throws when the model returns no tailored resume (nothing gets persisted)', async () => {
+    h.reply = JSON.stringify({ candidateName: 'X', answers: [] });
+    await expect(tailorApplication(input())).rejects.toThrow(/no resume/i);
+  });
+
+  it('defaults missing name/title/company to empty strings', async () => {
+    h.reply = JSON.stringify({ tailoredResume: '# R' });
+    const r = await tailorApplication(input());
+    expect(r).toMatchObject({ candidateName: '', jobTitle: '', company: '', answers: [] });
+  });
+
+  it('drops malformed answer entries (missing question or answer)', async () => {
+    h.reply = JSON.stringify({
+      tailoredResume: '# R',
+      answers: [{ question: 'Q1' }, { answer: 'orphan' }, { question: 'Q2', answer: 'A2' }, 7],
+    });
+    const r = await tailorApplication(input());
+    expect(r.answers).toEqual([{ question: 'Q2', answer: 'A2' }]);
+  });
+});
diff --git a/src/main/services/openai/tailor.ts b/src/main/services/openai/tailor.ts
new file mode 100644
index 0000000..8772a6f
--- /dev/null
+++ b/src/main/services/openai/tailor.ts
@@ -0,0 +1,104 @@
+import { openai } from './client';
+import { model, reasoningParam } from './models';
+import type { ApplicationAnswer } from '@shared/types';
+
+export interface TailorInput {
+  /** The candidate's real resume text (profile resume or an uploaded file). */
+  baseResume: string;
+  jdText: string;
+  /** Application questions to answer (may be empty). */
+  questions: string[];
+}
+
+/** What the single tailoring call produces. */
+export interface TailorResult {
+  candidateName: string; // extracted from the base resume
+  jobTitle: string; // extracted from the JD
+  company: string; // extracted from the JD ('' when absent)
+  tailoredResume: string; // ATS-friendly markdown
+  answers: ApplicationAnswer[];
+}
+
+const SYSTEM = `You are an expert resume writer and career coach. You are given a candidate's
+REAL resume (the only source of truth about them), a job description, and optional
+application questions. Return JSON only, with keys:
+
+- candidateName: the candidate's name as written on the resume ("" if absent).
+- jobTitle: the job title, extracted from the JD ("" if unclear).
+- company: the hiring company name, extracted from the JD ("" if unclear).
+- tailoredResume: the resume rewritten to TARGET THIS JOB, as clean markdown.
+- answers: one { "question", "answer" } object per application question, in order.
+
+TAILORING RULES (the resume):
+- GROUND EVERYTHING in the base resume. NEVER invent employers, titles, dates, degrees,
+  projects, metrics, or skills the candidate doesn't have. You may reword, reorder,
+  emphasize, quantify only with numbers already present, and trim what's irrelevant.
+- Mirror the JD's language TRUTHFULLY: where the candidate genuinely has a skill the JD
+  asks for, use the JD's exact keywords for it (ATS keyword matching). Skills the
+  candidate lacks are simply omitted — never added.
+- ATS-FRIENDLY structure, as markdown: name on the first line as an H1; one contact line
+  (only details present in the base resume); then standard sections in this order, each an
+  H2 — Summary, Skills, Experience, Education (plus Certifications/Projects only if the
+  base resume has them). Experience entries: a bold "Role — Company" line, a plain date
+  line if dates exist, then 3-6 achievement bullets (strongest, most JD-relevant first).
+- Single column, plain text only: no tables, no images, no columns, no icons, no emoji.
+- Concise: aim for the content of a 1-2 page resume. Cut filler, keep impact.
+
+ANSWER RULES (the application questions):
+- Answer AS the candidate, first person, grounded ONLY in the base resume (plus honest
+  motivation/fit reasoning from the JD). Never invent experience. 60-150 words each,
+  natural and human — no corporate filler, no "As an AI".
+- If a question can't be answered from their background, be honest and pivot to the
+  closest real, transferable experience.`;
+
+/**
+ * One call tailors the resume + answers the application questions + extracts the
+ * job title/company. Output is defensively defaulted so a malformed model response
+ * can't crash the handler — and nothing is persisted unless this call succeeds.
+ */
+export async function tailorApplication(input: TailorInput): Promise<TailorResult> {
+  const user = [
+    'BASE RESUME (the only source of truth about the candidate):',
+    input.baseResume.slice(0, 24_000),
+    '',
+    'JOB DESCRIPTION:',
+    input.jdText.slice(0, 24_000),
+    '',
+    input.questions.length
+      ? `APPLICATION QUESTIONS:\n${input.questions.map((q, i) => `${i + 1}. ${q}`).join('\n')}`
+      : 'APPLICATION QUESTIONS: (none)',
+    '',
+    'Produce the JSON now.',
+  ].join('\n');
+
+  const res = await openai().responses.create({
+    model: model('tailor'),
+    ...reasoningParam('tailor'),
+    input: [
+      { role: 'system', content: SYSTEM },
+      { role: 'user', content: user },
+    ],
+    text: { format: { type: 'json_object' } },
+  });
+
+  const raw = JSON.parse(res.output_text) as Partial<TailorResult> & { answers?: unknown };
+  const str = (v: unknown): string => (typeof v === 'string' ? v.trim() : '');
+
+  const answers: ApplicationAnswer[] = (Array.isArray(raw.answers) ? (raw.answers as unknown[]) : [])
+    .map((a) => {
+      const o = (a ?? {}) as Record<string, unknown>;
+      return { question: str(o.question), answer: str(o.answer) };
+    })
+    .filter((a) => a.question && a.answer);
+
+  const tailoredResume = str(raw.tailoredResume);
+  if (!tailoredResume) throw new Error('Tailoring failed — the model returned no resume.');
+
+  return {
+    candidateName: str(raw.candidateName),
+    jobTitle: str(raw.jobTitle),
+    company: str(raw.company),
+    tailoredResume,
+    answers,
+  };
+}
diff --git a/src/main/services/rag/indexProfile.ts b/src/main/services/rag/indexProfile.ts
index 1253e96..4d376e4 100644
--- a/src/main/services/rag/indexProfile.ts
+++ b/src/main/services/rag/indexProfile.ts
@@ -7,6 +7,7 @@ import { vectorToBuffer } from './vectorMath';
 import { model } from '../openai/models';
 import { profilesRepo } from '../../db/repositories/profiles.repo';
 import { storiesRepo, storyInsertValues } from '../../db/repositories/stories.repo';
+import { applicationsRepo } from '../../db/repositories/applications.repo';
 import { apiKeyStore } from '../security/apiKey';
 import type { Story, StoryDraft, StoryInput } from '@shared/types';
 
@@ -88,9 +89,15 @@ export async function indexJob(jobId: string): Promise<{ chunks: number; embedde
   db().delete(schema.chunks).where(eq(schema.chunks.jobId, jobId)).run();
   if (!apiKeyStore.isPresent()) return { chunks: 0, embedded: 0 };
 
-  const sources: { type: 'jd' | 'company'; text: string }[] = [];
+  const sources: { type: 'jd' | 'company' | 'tailored'; text: string }[] = [];
   if (job.jdText) sources.push({ type: 'jd', text: job.jdText });
   if (job.companyResearch) sources.push({ type: 'company', text: job.companyResearch });
+  // An application-owned job also indexes its TAILORED resume (job-scoped), which
+  // replaces the base resume in retrieval for this job's sessions (see vectorStore).
+  // Indexed here — inside indexJob's single clear-and-reinsert pass — so jd/company/
+  // tailored chunks never wipe each other.
+  const app = applicationsRepo.getByJobId(jobId);
+  if (app?.tailoredResume) sources.push({ type: 'tailored', text: app.tailoredResume });
   if (sources.length === 0) return { chunks: 0, embedded: 0 };
 
   const rows: { id: string; content: string }[] = [];
diff --git a/src/main/services/rag/vectorStore.ts b/src/main/services/rag/vectorStore.ts
index 97e8f80..31af79e 100644
--- a/src/main/services/rag/vectorStore.ts
+++ b/src/main/services/rag/vectorStore.ts
@@ -56,12 +56,21 @@ export const sqliteVectorStore: VectorStore = {
       .from(schema.chunks)
       .innerJoin(schema.embeddings, eq(schema.embeddings.chunkId, schema.chunks.id))
       .where(eq(schema.chunks.profileId, profileId))
-      .all()
-      // Always include base chunks (resume/notes, jobId null); include JD chunks
-      // only for the selected job.
-      .filter((r) => r.jobId == null || r.jobId === jobId);
+      .all();
+
+    // An application job carries `tailored` chunks (the resume rewritten FOR that
+    // job) — when present, they REPLACE the base resume for this job's retrieval,
+    // so the session grounds in the tailored resume. Notes/stories still apply.
+    const hasTailored = rows.some((r) => r.jobId === jobId && r.sourceType === 'tailored');
+    const filtered = rows.filter(
+      (r) =>
+        // Base chunks (resume/notes/stories, jobId null) + the selected job's chunks…
+        (r.jobId == null || r.jobId === jobId) &&
+        // …minus the base resume when this job has a tailored one.
+        !(hasTailored && r.jobId == null && r.sourceType === 'resume'),
+    );
 
-    return rows
+    return filtered
       .map((r) => ({
         id: r.id,
         sourceType: r.sourceType as ChunkSource,
diff --git a/src/preload/index.ts b/src/preload/index.ts
index 023da06..6f2ed4e 100644
--- a/src/preload/index.ts
+++ b/src/preload/index.ts
@@ -1,7 +1,13 @@
 import { contextBridge, ipcRenderer } from 'electron';
 import { EVENTS, IPC } from '@shared/ipc';
 import type { AnswerPrefs, ClientInfo, SavePrompt, UpdateStatus } from '@shared/ipc';
-import type { InterviewBrief, SparringFeedback, Story } from '@shared/types';
+import type {
+  Application,
+  ApplicationListItem,
+  InterviewBrief,
+  SparringFeedback,
+  Story,
+} from '@shared/types';
 import type { Result } from '@shared/result';
 
 /** invoke + unwrap the Result envelope so renderer code uses normal try/catch. */
@@ -109,6 +115,22 @@ const api = {
     brief: (id: string) => invoke<InterviewBrief>(IPC.jobs.brief, { id }),
     delete: (id: string) => invoke(IPC.jobs.delete, { id }),
   },
+  applications: {
+    page: (query: string, limit: number, offset: number) =>
+      invoke<{ items: ApplicationListItem[]; total: number }>(IPC.applications.page, {
+        query,
+        limit,
+        offset,
+      }),
+    get: (id: string) => invoke<Application>(IPC.applications.get, { id }),
+    tailor: (input: {
+      profileId: string | null;
+      baseResumeText: string | null;
+      jdText: string;
+      questions: string[];
+    }) => invoke<{ application: Application; embedded: number }>(IPC.applications.tailor, input),
+    delete: (id: string) => invoke<{ deleted: true }>(IPC.applications.delete, { id }),
+  },
   notes: {
     list: (profileId: string) => invoke(IPC.notes.list, { profileId }),
     create: (profileId: string, content: string) =>
diff --git a/src/shared/ipc.ts b/src/shared/ipc.ts
index 566003d..7644c84 100644
--- a/src/shared/ipc.ts
+++ b/src/shared/ipc.ts
@@ -62,6 +62,12 @@ export const IPC = {
     create: 'notes:create',
     delete: 'notes:delete',
   },
+  applications: {
+    page: 'applications:page',
+    get: 'applications:get',
+    tailor: 'applications:tailor', // the Tailor Resume op: LLM → profile/job/app rows + index
+    delete: 'applications:delete',
+  },
   stories: {
     list: 'stories:list',
     generate: 'stories:generate', // extract STAR stories from the résumé (replaces all)
diff --git a/src/shared/types.ts b/src/shared/types.ts
index ef694f8..3a5a3e6 100644
--- a/src/shared/types.ts
+++ b/src/shared/types.ts
@@ -20,7 +20,9 @@ export type InterviewType =
 export type AnswerFormat = 'key_points' | 'explanation' | 'detailed' | 'story_teller';
 
 export type DocumentKind = 'resume' | 'jd' | 'note' | 'other';
-export type ChunkSource = 'resume' | 'jd' | 'note' | 'company' | 'story';
+/** `tailored` = an application's tailored resume, indexed job-scoped; when a job has
+ *  tailored chunks, retrieval drops the base `resume` chunks for that job's sessions. */
+export type ChunkSource = 'resume' | 'jd' | 'note' | 'company' | 'story' | 'tailored';
 export type SessionStatus = 'idle' | 'live' | 'stopped';
 export type Speaker = 'interviewer' | 'candidate' | 'unknown';
 
@@ -181,6 +183,35 @@ export interface Job {
   updatedAt: number;
 }
 
+/** One application question + its grounded answer (Tailor Resume flow). */
+export interface ApplicationAnswer {
+  question: string;
+  answer: string;
+}
+
+/** A job application produced by the Tailor Resume flow: an ATS-friendly resume
+ *  tailored from a base resume × a JD (grounded — no invented experience), plus
+ *  answers to the application's questions. Owns a dedicated Job row holding the JD;
+ *  the tailored resume is indexed as that job's `tailored` chunks, so "Start
+ *  interview" grounds the live session in the TAILORED resume + JD. */
+export interface Application {
+  id: string;
+  profileId: string; // owning (real) profile — sessions/stories still belong to it
+  jobId: string; // dedicated job row (JD + tailored chunks); hidden from the Interviews table
+  name: string; // candidate/application name — shown as "[name] - [jobTitle] at [company]"
+  jobTitle: string;
+  company: string | null;
+  baseResume: string; // input snapshot (provenance)
+  tailoredResume: string; // markdown — the PDF source + `tailored` chunk source
+  answers: ApplicationAnswer[];
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface ApplicationListItem extends Application {
+  profileName: string | null;
+}
+
 export interface RetrievedChunk {
   id: string;
   sourceType: ChunkSource;

From fca76927663a569dc0ce1ec677c8834d0ed5c0d9 Mon Sep 17 00:00:00 2001
From: tpikachu <sjkunai@outlook.com>
Date: Thu, 2 Jul 2026 07:31:04 -0500
Subject: [PATCH 2/6] feat: tailored-resume PDF export (v1.3 #2)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Save any application's tailored resume as an ATS-friendly PDF. A deliberately
minimal, dependency-free markdown→HTML converter (resumeHtml.ts — headings,
bullets, bold, paragraphs; HTML-escaped first; single column, standard fonts,
one inline style, no scripts) renders in a hidden ephemeral BrowserWindow via a
data: URL, then webContents.printToPDF (Letter, custom inch margins, tagged PDF)
and a native save dialog (sanitized "[name] - [title] at [company].pdf" default).
The window is destroyed in a finally so it can never leak.

applications:export-pdf IPC + preload; resumeHtml.test.ts (+5, incl. escaping).

Verified: typecheck · 131 unit · build green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/main/ipc/applications.ipc.ts              |  9 +++
 .../services/documents/resumeHtml.test.ts     | 55 +++++++++++++
 src/main/services/documents/resumeHtml.ts     | 80 +++++++++++++++++++
 src/main/services/documents/resumePdf.ts      | 46 +++++++++++
 src/preload/index.ts                          |  2 +
 src/shared/ipc.ts                             |  1 +
 6 files changed, 193 insertions(+)
 create mode 100644 src/main/services/documents/resumeHtml.test.ts
 create mode 100644 src/main/services/documents/resumeHtml.ts
 create mode 100644 src/main/services/documents/resumePdf.ts

diff --git a/src/main/ipc/applications.ipc.ts b/src/main/ipc/applications.ipc.ts
index 8f31bbd..d02a08b 100644
--- a/src/main/ipc/applications.ipc.ts
+++ b/src/main/ipc/applications.ipc.ts
@@ -7,6 +7,7 @@ import { jobsRepo } from '../db/repositories/jobs.repo';
 import { tailorApplication } from '../services/openai/tailor';
 import { parseJobDescription, parseResume } from '../services/openai/parsing';
 import { indexJob, reindexProfile } from '../services/rag/indexProfile';
+import { exportResumePdf } from '../services/documents/resumePdf';
 import { apiKeyStore } from '../services/security/apiKey';
 
 export function registerApplicationsIpc(): void {
@@ -113,6 +114,14 @@ export function registerApplicationsIpc(): void {
     },
   );
 
+  // Save the tailored resume as an ATS-friendly PDF (native save dialog).
+  handle(IPC.applications.exportPdf, zId, async ({ id }) => {
+    const app = applicationsRepo.get(id);
+    if (!app) throw new Error('Application not found');
+    const label = `${app.name} - ${app.jobTitle}${app.company ? ` at ${app.company}` : ''}`;
+    return exportResumePdf(app.tailoredResume, label);
+  });
+
   handle(IPC.applications.delete, zId, ({ id }) => {
     applicationsRepo.delete(id);
     return { deleted: true as const };
diff --git a/src/main/services/documents/resumeHtml.test.ts b/src/main/services/documents/resumeHtml.test.ts
new file mode 100644
index 0000000..ed0052e
--- /dev/null
+++ b/src/main/services/documents/resumeHtml.test.ts
@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { resumeMarkdownToHtml, resumePrintDocument } from './resumeHtml';
+
+describe('resumeMarkdownToHtml', () => {
+  it('converts headings, bullets, bold, and paragraphs', () => {
+    const md = [
+      '# Jane Doe',
+      'jane@doe.dev | 555-0100',
+      '',
+      '## Experience',
+      '**Senior Engineer — Acme**',
+      '2021 - Present',
+      '- Cut p99 latency **40%**',
+      '* Led a team of 4',
+      '',
+      'Plain closing paragraph.',
+    ].join('\n');
+    const html = resumeMarkdownToHtml(md);
+    expect(html).toContain('<h1>Jane Doe</h1>');
+    expect(html).toContain('<h2>Experience</h2>');
+    expect(html).toContain('<strong>Senior Engineer — Acme</strong>');
+    expect(html).toContain('<ul><li>Cut p99 latency <strong>40%</strong></li><li>Led a team of 4</li></ul>');
+    expect(html).toContain('<p>Plain closing paragraph.</p>');
+    // Adjacent non-blank lines join into ONE paragraph with a line break.
+    expect(html).toContain('<p><strong>Senior Engineer — Acme</strong><br>2021 - Present</p>');
+  });
+
+  it('escapes HTML in the (untrusted) resume text BEFORE formatting', () => {
+    const html = resumeMarkdownToHtml('# A <script>alert(1)</script>\n- 5 < 10 & **x > y**');
+    expect(html).not.toContain('<script>');
+    expect(html).toContain('&lt;script&gt;');
+    expect(html).toContain('<li>5 &lt; 10 &amp; <strong>x &gt; y</strong></li>');
+  });
+
+  it('handles CRLF input and blank-line separation', () => {
+    const html = resumeMarkdownToHtml('para one\r\n\r\npara two');
+    expect(html).toContain('<p>para one</p>');
+    expect(html).toContain('<p>para two</p>');
+  });
+
+  it('returns empty output for empty input', () => {
+    expect(resumeMarkdownToHtml('')).toBe('');
+  });
+});
+
+describe('resumePrintDocument', () => {
+  it('wraps the body in a self-contained, script-free, single-style document', () => {
+    const doc = resumePrintDocument('# Jane');
+    expect(doc).toContain('<!DOCTYPE html>');
+    expect(doc).toContain('<h1>Jane</h1>');
+    expect(doc).toContain('font-family: Arial');
+    expect(doc).not.toContain('<script'); // ATS + CSP: never any script
+    expect((doc.match(/<style>/g) ?? []).length).toBe(1);
+  });
+});
diff --git a/src/main/services/documents/resumeHtml.ts b/src/main/services/documents/resumeHtml.ts
new file mode 100644
index 0000000..0b1bf67
--- /dev/null
+++ b/src/main/services/documents/resumeHtml.ts
@@ -0,0 +1,80 @@
+// Pure markdown→HTML for the tailored-resume PDF. DELIBERATELY minimal — the
+// simplicity IS the ATS feature: single column, standard headings, plain bullets,
+// no tables/images/links/scripts. Kept dependency-free and separate from the
+// Electron glue (resumePdf.ts) so it's unit-testable.
+
+/** Escape text for safe embedding in HTML (the LLM output is untrusted text). */
+function esc(s: string): string {
+  return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+
+/** `**bold**` → <strong> (applied AFTER escaping; no other inline markup). */
+function inline(s: string): string {
+  return esc(s).replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>');
+}
+
+/** Convert the tailored resume's markdown subset to clean, linear HTML:
+ *  # / ## / ### headings, - or * bullets, blank-line paragraphs, **bold**. */
+export function resumeMarkdownToHtml(markdown: string): string {
+  const lines = markdown.replace(/\r\n/g, '\n').split('\n');
+  const out: string[] = [];
+  let list: string[] = [];
+  let para: string[] = [];
+
+  const flushList = () => {
+    if (list.length) out.push(`<ul>${list.map((li) => `<li>${li}</li>`).join('')}</ul>`);
+    list = [];
+  };
+  const flushPara = () => {
+    if (para.length) out.push(`<p>${para.join('<br>')}</p>`);
+    para = [];
+  };
+
+  for (const raw of lines) {
+    const line = raw.trim();
+    const heading = /^(#{1,3})\s+(.*)$/.exec(line);
+    const bullet = /^[-*]\s+(.*)$/.exec(line);
+    if (!line) {
+      flushList();
+      flushPara();
+    } else if (heading) {
+      flushList();
+      flushPara();
+      const level = heading[1].length;
+      out.push(`<h${level}>${inline(heading[2])}</h${level}>`);
+    } else if (bullet) {
+      flushPara();
+      list.push(inline(bullet[1]));
+    } else {
+      flushList();
+      para.push(inline(line));
+    }
+  }
+  flushList();
+  flushPara();
+  return out.join('\n');
+}
+
+/** Wrap the converted body in a self-contained, ATS-friendly print document:
+ *  standard fonts, black on white, single column, one inline <style>, no scripts. */
+export function resumePrintDocument(markdown: string): string {
+  return `<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<style>
+  body { font-family: Arial, Helvetica, sans-serif; font-size: 11pt; line-height: 1.35;
+         color: #000; background: #fff; max-width: 7.5in; margin: 0 auto; }
+  h1 { font-size: 18pt; margin: 0 0 2pt; }
+  h2 { font-size: 13pt; margin: 14pt 0 4pt; border-bottom: 1px solid #000; padding-bottom: 2pt; }
+  h3 { font-size: 11.5pt; margin: 10pt 0 2pt; }
+  p  { margin: 0 0 6pt; }
+  ul { margin: 0 0 8pt 18pt; padding: 0; }
+  li { margin: 0 0 3pt; }
+</style>
+</head>
+<body>
+${resumeMarkdownToHtml(markdown)}
+</body>
+</html>`;
+}
diff --git a/src/main/services/documents/resumePdf.ts b/src/main/services/documents/resumePdf.ts
new file mode 100644
index 0000000..f52a791
--- /dev/null
+++ b/src/main/services/documents/resumePdf.ts
@@ -0,0 +1,46 @@
+import { BrowserWindow, dialog } from 'electron';
+import { writeFile } from 'fs/promises';
+import { getMainWindow } from '../../windows/mainWindow';
+import { resumePrintDocument } from './resumeHtml';
+
+/**
+ * Render the tailored resume (markdown) to an ATS-friendly PDF and let the user
+ * pick where to save it. Renders in a hidden, ephemeral BrowserWindow loading a
+ * self-contained data: URL (inline style only — CSP-compliant, no scripts), then
+ * webContents.printToPDF. Returns { saved:false } when the user cancels the dialog.
+ */
+export async function exportResumePdf(
+  markdown: string,
+  suggestedName: string,
+): Promise<{ saved: boolean; filePath?: string }> {
+  // Windows-invalid filename chars → '-', keep it readable.
+  const safeName = `${suggestedName.replace(/[\\/:*?"<>|]/g, '-').trim() || 'Tailored resume'}.pdf`;
+
+  const win = getMainWindow();
+  const options = { defaultPath: safeName, filters: [{ name: 'PDF', extensions: ['pdf'] }] };
+  const res = win ? await dialog.showSaveDialog(win, options) : await dialog.showSaveDialog(options);
+  if (res.canceled || !res.filePath) return { saved: false };
+
+  const printWin = new BrowserWindow({
+    show: false, // printToPDF renders offscreen — the window is never displayed
+    webPreferences: { sandbox: true, contextIsolation: true, nodeIntegration: false },
+  });
+  try {
+    const html = resumePrintDocument(markdown);
+    // loadURL resolves on did-finish-load, so the DOM is painted before printing.
+    await printWin.loadURL(`data:text/html;charset=utf-8,${encodeURIComponent(html)}`);
+    const pdf = await printWin.webContents.printToPDF({
+      pageSize: 'Letter',
+      landscape: false,
+      printBackground: false,
+      displayHeaderFooter: false,
+      // Electron 33: inches. Modest margins keep ATS text extraction clean.
+      margins: { marginType: 'custom', top: 0.5, bottom: 0.5, left: 0.6, right: 0.6 },
+      generateTaggedPDF: true, // tagged/structured PDF = most reliable ATS extraction
+    });
+    await writeFile(res.filePath, pdf);
+    return { saved: true, filePath: res.filePath };
+  } finally {
+    printWin.destroy(); // never leak the hidden window, even on failure
+  }
+}
diff --git a/src/preload/index.ts b/src/preload/index.ts
index 6f2ed4e..45168c1 100644
--- a/src/preload/index.ts
+++ b/src/preload/index.ts
@@ -129,6 +129,8 @@ const api = {
       jdText: string;
       questions: string[];
     }) => invoke<{ application: Application; embedded: number }>(IPC.applications.tailor, input),
+    exportPdf: (id: string) =>
+      invoke<{ saved: boolean; filePath?: string }>(IPC.applications.exportPdf, { id }),
     delete: (id: string) => invoke<{ deleted: true }>(IPC.applications.delete, { id }),
   },
   notes: {
diff --git a/src/shared/ipc.ts b/src/shared/ipc.ts
index 7644c84..010c9eb 100644
--- a/src/shared/ipc.ts
+++ b/src/shared/ipc.ts
@@ -66,6 +66,7 @@ export const IPC = {
     page: 'applications:page',
     get: 'applications:get',
     tailor: 'applications:tailor', // the Tailor Resume op: LLM → profile/job/app rows + index
+    exportPdf: 'applications:export-pdf', // tailored resume → ATS-friendly PDF (save dialog)
     delete: 'applications:delete',
   },
   stories: {

From 7876267a44eb26a1807e4af30bb6d762f106b342 Mon Sep 17 00:00:00 2001
From: tpikachu <sjkunai@outlook.com>
Date: Thu, 2 Jul 2026 07:35:16 -0500
Subject: [PATCH 3/6] =?UTF-8?q?feat:=20Tailor=20Resume=20page=20=E2=80=94?=
 =?UTF-8?q?=20form,=20applications=20table,=20start=20interview=20(v1.3=20?=
 =?UTF-8?q?#3)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

New "Tailor Resume" nav page (/tailor):
- Form: base resume from a profile OR uploaded/pasted (PDF/DOCX/TXT/MD via the
  existing extract pipeline); JD via paste/upload/URL fetch; optional application
  questions (one per line). "Tailor resume" runs the op with a busy overlay.
- Result opens in ApplicationModal: the tailored resume (markdown), the grounded
  application answers, Download PDF, and delete (two-step confirm).
- Applications table: dense DataTable, server-paginated + searchable, newest
  first, labeled "[name] - [jobTitle] at [company]". Per-row "Start interview"
  launches a live session with the application's (profile, job) — grounded in the
  TAILORED resume + JD via the tailored-chunk retrieval rule; shows ● live while
  that session runs. Row click opens the detail view.

Verified: typecheck · 131 unit · build green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/renderer/dashboard/App.tsx              |   4 +
 src/renderer/dashboard/ApplicationModal.tsx | 135 +++++++
 src/renderer/dashboard/pages/TailorPage.tsx | 397 ++++++++++++++++++++
 3 files changed, 536 insertions(+)
 create mode 100644 src/renderer/dashboard/ApplicationModal.tsx
 create mode 100644 src/renderer/dashboard/pages/TailorPage.tsx

diff --git a/src/renderer/dashboard/App.tsx b/src/renderer/dashboard/App.tsx
index b8cac46..a47d284 100644
--- a/src/renderer/dashboard/App.tsx
+++ b/src/renderer/dashboard/App.tsx
@@ -9,6 +9,7 @@ import ProfileEditorPage from './pages/ProfileEditorPage';
 import InterviewPage from './pages/InterviewPage';
 import MockPage from './pages/MockPage';
 import SparringPage from './pages/SparringPage';
+import TailorPage from './pages/TailorPage';
 import ReportsPage from './pages/ReportsPage';
 import SettingsPage from './pages/SettingsPage';
 import WhatsNewPage from './pages/WhatsNewPage';
@@ -23,6 +24,7 @@ import {
   ReportIcon,
   SettingsIcon,
   MicIcon,
+  UploadIcon,
   UserIcon,
 } from '../components/icons';
 import { Logo } from '../components/Logo';
@@ -35,6 +37,7 @@ const navItems = [
   { to: '/interview', label: 'Interview', Icon: MicIcon, tour: 'nav-session' },
   { to: '/mock', label: 'Mock Interview', Icon: MockIcon, tour: 'nav-mock' },
   { to: '/sparring', label: 'Sparring', Icon: BoltIcon, tour: 'nav-sparring' },
+  { to: '/tailor', label: 'Tailor Resume', Icon: UploadIcon, tour: 'nav-tailor' },
   { to: '/reports', label: 'Reports', Icon: ReportIcon, tour: 'nav-reports' },
   { to: '/settings', label: 'Settings', Icon: SettingsIcon, tour: 'nav-settings' },
   ...(DEV ? [{ to: '/dev', label: 'DB Explorer', Icon: DatabaseIcon, tour: 'nav-dev' }] : []),
@@ -137,6 +140,7 @@ export default function App() {
           <Route path="/interview" element={<InterviewPage />} />
           <Route path="/mock" element={<MockPage />} />
           <Route path="/sparring" element={<SparringPage />} />
+          <Route path="/tailor" element={<TailorPage />} />
           <Route path="/reports" element={<ReportsPage />} />
           <Route path="/settings" element={<SettingsPage />} />
           <Route path="/whats-new" element={<WhatsNewPage />} />
diff --git a/src/renderer/dashboard/ApplicationModal.tsx b/src/renderer/dashboard/ApplicationModal.tsx
new file mode 100644
index 0000000..1e20608
--- /dev/null
+++ b/src/renderer/dashboard/ApplicationModal.tsx
@@ -0,0 +1,135 @@
+import { useEffect, useState } from 'react';
+import { api } from '../lib/api';
+import type { Application } from '@shared/types';
+import { Badge, Button, Modal } from '../components/ui';
+import { Markdown } from '../components/Markdown';
+
+/** View one application: the tailored resume (markdown), the grounded answers to
+ *  the application questions, PDF download, and delete. Used both for a fresh
+ *  tailoring result and for rows opened from the applications table. */
+export function ApplicationModal({
+  open,
+  app,
+  onClose,
+  onDeleted,
+}: {
+  open: boolean;
+  app: Application | null;
+  onClose: () => void;
+  onDeleted: (id: string) => void;
+}) {
+  const [busy, setBusy] = useState<string | null>(null);
+  const [notice, setNotice] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [confirmDelete, setConfirmDelete] = useState(false);
+
+  // Reset transient state whenever a different application (or none) is shown.
+  useEffect(() => {
+    setBusy(null);
+    setNotice(null);
+    setError(null);
+    setConfirmDelete(false);
+  }, [open, app?.id]);
+
+  if (!app) return null;
+  const label = `${app.name} - ${app.jobTitle}${app.company ? ` at ${app.company}` : ''}`;
+
+  const downloadPdf = async () => {
+    setBusy('Exporting PDF…');
+    setError(null);
+    setNotice(null);
+    try {
+      const r = await api.applications.exportPdf(app.id);
+      if (r.saved) setNotice(`Saved to ${r.filePath}`);
+    } catch (e) {
+      setError((e as Error).message);
+    } finally {
+      setBusy(null);
+    }
+  };
+
+  const doDelete = async () => {
+    setBusy('Deleting…');
+    setError(null);
+    try {
+      await api.applications.delete(app.id);
+      onDeleted(app.id);
+      onClose();
+    } catch (e) {
+      setError((e as Error).message);
+    } finally {
+      setBusy(null);
+    }
+  };
+
+  return (
+    <Modal open={open} onClose={onClose} title={label} width="max-w-3xl">
+      <div className="space-y-5">
+        {error && (
+          <p className="rounded-lg border border-red-500/40 bg-red-500/10 px-3 py-2 text-sm text-red-300">
+            {error}
+          </p>
+        )}
+        {notice && (
+          <p className="rounded-lg border border-green-500/40 bg-green-500/10 px-3 py-2 text-sm text-green-300">
+            {notice}
+          </p>
+        )}
+
+        <div className="flex flex-wrap items-center gap-2">
+          <Button variant="primary" disabled={!!busy} onClick={() => void downloadPdf()}>
+            {busy === 'Exporting PDF…' ? 'Exporting…' : 'Download PDF'}
+          </Button>
+          {confirmDelete ? (
+            <>
+              <span className="text-xs text-neutral-500">
+                Delete this application (and its tailored grounding)?
+              </span>
+              <Button variant="ghost" onClick={() => setConfirmDelete(false)}>
+                Cancel
+              </Button>
+              <Button variant="danger" disabled={!!busy} onClick={() => void doDelete()}>
+                Delete
+              </Button>
+            </>
+          ) : (
+            <Button variant="ghost" className="text-red-300" onClick={() => setConfirmDelete(true)}>
+              Delete
+            </Button>
+          )}
+        </div>
+
+        {/* The tailored, ATS-friendly resume. */}
+        <section>
+          <div className="mb-2 flex items-baseline gap-2">
+            <h4 className="text-sm font-semibold text-neutral-200">Tailored resume</h4>
+            <Badge tone="green">ATS-friendly</Badge>
+          </div>
+          <div className="max-h-96 overflow-y-auto rounded-xl border border-white/10 bg-neutral-950/40 p-4 text-sm leading-relaxed">
+            <Markdown>{app.tailoredResume}</Markdown>
+          </div>
+        </section>
+
+        {/* Grounded answers to the application's questions. */}
+        {app.answers.length > 0 && (
+          <section>
+            <h4 className="mb-2 text-sm font-semibold text-neutral-200">Application answers</h4>
+            <div className="space-y-3">
+              {app.answers.map((a, i) => (
+                <div key={i} className="rounded-xl border border-white/10 bg-neutral-950/40 p-3">
+                  <p className="text-sm font-medium text-blue-200">{a.question}</p>
+                  <p className="mt-1 text-sm leading-relaxed text-neutral-300">{a.answer}</p>
+                </div>
+              ))}
+            </div>
+          </section>
+        )}
+
+        <p className="text-xs text-neutral-500">
+          Tailored only from your base resume — nothing invented. “Start interview” from the
+          applications table grounds the live session in this tailored resume + the JD.
+        </p>
+      </div>
+    </Modal>
+  );
+}
diff --git a/src/renderer/dashboard/pages/TailorPage.tsx b/src/renderer/dashboard/pages/TailorPage.tsx
new file mode 100644
index 0000000..cbc3581
--- /dev/null
+++ b/src/renderer/dashboard/pages/TailorPage.tsx
@@ -0,0 +1,397 @@
+import { useEffect, useState } from 'react';
+import { Link } from 'react-router-dom';
+import { api } from '../../lib/api';
+import { useProfileStore } from '../../store/useProfileStore';
+import { useSettingsStore } from '../../store/useSettingsStore';
+import { useLiveSession } from '../../store/useLiveSession';
+import type { Application, ApplicationListItem } from '@shared/types';
+import { Badge, BusyOverlay, Button, Card, Field, Page, Select, TextArea, TextInput } from '../../components/ui';
+import { DataTable, type Column } from '../../components/DataTable';
+import { ApplicationModal } from '../ApplicationModal';
+import { PlayIcon, UploadIcon } from '../../components/icons';
+
+const APPS_PER_PAGE = 8;
+
+export default function TailorPage() {
+  const { profiles, load } = useProfileStore();
+  const { settings, load: loadSettings } = useSettingsStore();
+  const live = useLiveSession();
+  const { session } = live;
+
+  // ---- Tailor form ----
+  const [profileId, setProfileId] = useState(''); // '' = upload/paste a base resume instead
+  const [baseText, setBaseText] = useState('');
+  const [baseFile, setBaseFile] = useState<string | null>(null);
+  const [jdText, setJdText] = useState('');
+  const [jdUrl, setJdUrl] = useState('');
+  const [questionsText, setQuestionsText] = useState('');
+  const [busyMsg, setBusyMsg] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  // ---- Result / detail modal ----
+  const [viewApp, setViewApp] = useState<Application | null>(null);
+  const [viewOpen, setViewOpen] = useState(false);
+
+  // ---- Applications table (server-paginated + searchable, newest first) ----
+  const [rows, setRows] = useState<ApplicationListItem[]>([]);
+  const [total, setTotal] = useState(0);
+  const [query, setQuery] = useState('');
+  const [page, setPage] = useState(0);
+  const [loading, setLoading] = useState(false);
+  const [rev, setRev] = useState(0); // bump to re-fetch after tailor/delete
+  const [busyAppId, setBusyAppId] = useState<string | null>(null);
+
+  useEffect(() => {
+    void load();
+    void loadSettings();
+  }, [load, loadSettings]);
+
+  // (Re)load the current page on search/page change (search debounced).
+  useEffect(() => {
+    const t = setTimeout(() => {
+      setLoading(true);
+      api.applications
+        .page(query.trim(), APPS_PER_PAGE, page * APPS_PER_PAGE)
+        .then((r) => {
+          setRows(r.items);
+          setTotal(r.total);
+        })
+        .catch(() => {})
+        .finally(() => setLoading(false));
+    }, 200);
+    return () => clearTimeout(t);
+  }, [query, page, rev]);
+
+  const selectedProfile = profiles.find((p) => p.id === profileId);
+  const baseReady = profileId ? !!selectedProfile?.resumeText : !!baseText.trim();
+  const canTailor = baseReady && !!jdText.trim() && !!settings?.apiKeyPresent;
+
+  const withBusy = async (msg: string, fn: () => Promise<void>) => {
+    setBusyMsg(msg);
+    setError(null);
+    try {
+      await fn();
+    } catch (e) {
+      setError((e as Error).message);
+    } finally {
+      setBusyMsg(null);
+    }
+  };
+
+  const uploadBase = () =>
+    withBusy('Extracting text from file…', async () => {
+      const { filePath } = await api.dialog.openFile();
+      if (!filePath) return;
+      const { text, filename } = (await api.documents.extractFile(filePath)) as {
+        text: string;
+        filename: string;
+      };
+      setProfileId('');
+      setBaseText(text);
+      setBaseFile(filename);
+    });
+
+  const uploadJd = () =>
+    withBusy('Extracting text from file…', async () => {
+      const { filePath } = await api.dialog.openFile();
+      if (!filePath) return;
+      const { text } = (await api.documents.extractFile(filePath)) as { text: string };
+      setJdText(text);
+    });
+
+  const fetchJd = () =>
+    withBusy('Fetching the job posting…', async () => {
+      if (!jdUrl.trim()) return;
+      const { text } = (await api.documents.fetchUrl(jdUrl.trim())) as { text: string };
+      setJdText(text);
+    });
+
+  const tailor = () =>
+    withBusy('Tailoring your resume — this can take a minute…', async () => {
+      const questions = questionsText
+        .split('\n')
+        .map((q) => q.trim())
+        .filter(Boolean);
+      const r = await api.applications.tailor({
+        profileId: profileId || null,
+        baseResumeText: profileId ? null : baseText,
+        jdText: jdText.trim(),
+        questions,
+      });
+      setViewApp(r.application);
+      setViewOpen(true);
+      setPage(0);
+      setRev((v) => v + 1);
+      void load(); // an uploaded base resume may have created a new profile
+    });
+
+  // Start a live interview grounded in this application's tailored resume + JD.
+  const startInterview = async (app: ApplicationListItem) => {
+    if (session) return;
+    setBusyAppId(app.id);
+    try {
+      const a = settings?.audio ?? { source: 'system' as const, micDeviceId: null };
+      await live.startNew({
+        profileId: app.profileId,
+        jobId: app.jobId,
+        interviewType: 'general',
+        answerFormat: 'key_points',
+        source: a.source,
+        micDeviceId: a.micDeviceId,
+      });
+    } finally {
+      setBusyAppId(null);
+    }
+  };
+
+  const openApp = async (id: string) => {
+    try {
+      setViewApp(await api.applications.get(id));
+      setViewOpen(true);
+    } catch (e) {
+      setError((e as Error).message);
+    }
+  };
+
+  const columns: Column<ApplicationListItem>[] = [
+    {
+      key: 'label',
+      header: 'Application',
+      render: (a) => (
+        <div>
+          <div className="font-medium text-neutral-100">
+            {a.name} - {a.jobTitle || 'Untitled role'}
+            {a.company ? ` at ${a.company}` : ''}
+          </div>
+          {a.profileName && <div className="text-xs text-neutral-500">{a.profileName}</div>}
+        </div>
+      ),
+    },
+    {
+      key: 'created',
+      header: 'Created',
+      className: 'w-40',
+      render: (a) => (
+        <span className="text-xs text-neutral-400">{new Date(a.createdAt).toLocaleString()}</span>
+      ),
+    },
+    {
+      key: 'actions',
+      header: '',
+      className: 'w-56 text-right',
+      render: (a) => (
+        <div className="flex items-center justify-end gap-1.5" onClick={(e) => e.stopPropagation()}>
+          {session?.jobId === a.jobId ? (
+            <Badge tone="green">● live</Badge>
+          ) : (
+            <Button
+              variant="success"
+              disabled={!settings?.apiKeyPresent || !!session}
+              loading={busyAppId === a.id}
+              title="Start a live interview grounded in this tailored resume + JD"
+              onClick={() => void startInterview(a)}
+            >
+              <PlayIcon /> Start interview
+            </Button>
+          )}
+          <Button variant="ghost" onClick={() => void openApp(a.id)}>
+            View
+          </Button>
+        </div>
+      ),
+    },
+  ];
+
+  return (
+    <Page
+      title="Tailor Resume"
+      subtitle="Turn your resume + a job description into an ATS-friendly tailored resume and application answers — then interview against exactly what you submitted."
+    >
+      {busyMsg && <BusyOverlay message={busyMsg} />}
+
+      {(error || live.micError || live.sessionError) && (
+        <div className="mb-4 flex items-start justify-between gap-3 rounded-lg border border-red-500/40 bg-red-500/10 px-3 py-2 text-sm text-red-300">
+          <span>{error || live.micError || live.sessionError}</span>
+          <button
+            onClick={() => {
+              setError(null);
+              live.clearMicError();
+              live.clearSessionError();
+            }}
+            className="shrink-0 rounded p-0.5 text-red-300/70 hover:text-red-200"
+            aria-label="Dismiss"
+          >
+            ✕
+          </button>
+        </div>
+      )}
+
+      {session && (
+        <p className="mb-4 text-xs text-neutral-500">
+          ● An interview is live — transcript, answers, and all controls are in the Cue Card.
+        </p>
+      )}
+
+      <div className="space-y-5">
+        {/* The tailor form. */}
+        <Card>
+          <h3 className="mb-1 font-medium">New application</h3>
+          <p className="mb-4 text-xs text-neutral-500">
+            The tailored resume is grounded ONLY in your base resume — reworded and reordered for
+            the job, never invented.
+          </p>
+
+          <div className="grid gap-4 sm:grid-cols-2">
+            <Field label="Base resume — use a profile…">
+              <Select
+                value={profileId}
+                onChange={(e) => {
+                  setProfileId(e.target.value);
+                  if (e.target.value) {
+                    setBaseText('');
+                    setBaseFile(null);
+                  }
+                }}
+              >
+                <option value="">Upload / paste instead…</option>
+                {profiles.map((p) => (
+                  <option key={p.id} value={p.id}>
+                    {p.name}
+                    {p.targetRole ? ` · ${p.targetRole}` : ''}
+                  </option>
+                ))}
+              </Select>
+            </Field>
+            {!profileId && (
+              <Field label="…or upload a resume file">
+                <Button variant="default" onClick={() => void uploadBase()}>
+                  <UploadIcon /> Upload (PDF / DOCX / TXT / MD)
+                </Button>
+                {baseFile && (
+                  <span className="ml-2 align-middle text-xs text-green-300">{baseFile} ✓</span>
+                )}
+              </Field>
+            )}
+          </div>
+
+          {profileId && selectedProfile && !selectedProfile.resumeText && (
+            <p className="mt-2 text-xs text-amber-400">
+              ⚠ This profile has no resume text —{' '}
+              <Link to={`/profiles/${selectedProfile.id}`} className="underline">
+                add one
+              </Link>{' '}
+              or upload a file instead.
+            </p>
+          )}
+
+          {!profileId && (
+            <div className="mt-3">
+              <Field label="Base resume text">
+                <TextArea
+                  rows={6}
+                  value={baseText}
+                  onChange={(e) => setBaseText(e.target.value)}
+                  placeholder="Paste your resume text (or upload a file above). A reusable profile is created from it."
+                />
+              </Field>
+            </div>
+          )}
+
+          <div className="mt-4">
+            <Field label="Job description">
+              <TextArea
+                rows={6}
+                value={jdText}
+                onChange={(e) => setJdText(e.target.value)}
+                placeholder="Paste the job description…"
+              />
+            </Field>
+            <div className="mt-2 flex flex-wrap items-center gap-2">
+              <Button variant="default" onClick={() => void uploadJd()}>
+                <UploadIcon /> Upload JD
+              </Button>
+              <TextInput
+                value={jdUrl}
+                onChange={(e) => setJdUrl(e.target.value)}
+                placeholder="…or paste the posting URL"
+                className="min-w-56 flex-1"
+              />
+              <Button variant="default" disabled={!jdUrl.trim()} onClick={() => void fetchJd()}>
+                Fetch
+              </Button>
+            </div>
+          </div>
+
+          <div className="mt-4">
+            <Field label="Application questions (optional — one per line)">
+              <TextArea
+                rows={3}
+                value={questionsText}
+                onChange={(e) => setQuestionsText(e.target.value)}
+                placeholder={'Why do you want to work here?\nDescribe a challenging project you led.'}
+              />
+            </Field>
+          </div>
+
+          {!settings?.apiKeyPresent && (
+            <p className="mt-3 text-xs text-amber-400">
+              ⚠ No OpenAI key —{' '}
+              <Link to="/settings" className="underline">
+                add it in Settings
+              </Link>
+              .
+            </p>
+          )}
+
+          <Button
+            variant="primary"
+            className="mt-4"
+            disabled={!canTailor}
+            onClick={() => void tailor()}
+          >
+            Tailor resume
+          </Button>
+        </Card>
+
+        {/* Applications — dense, paginated, searchable, newest first. */}
+        <Card>
+          <div className="mb-3">
+            <h3 className="font-medium">Applications</h3>
+            <p className="mt-1 text-xs text-neutral-500">
+              Every tailored application, newest first. <strong>Start interview</strong> grounds a
+              live session in that application’s tailored resume + JD.
+            </p>
+          </div>
+          <DataTable<ApplicationListItem>
+            columns={columns}
+            rows={rows}
+            rowKey={(a) => a.id}
+            total={total}
+            page={page}
+            pageSize={APPS_PER_PAGE}
+            onPage={setPage}
+            query={query}
+            onQuery={(q) => {
+              setQuery(q);
+              setPage(0);
+            }}
+            searchPlaceholder="Search by name, role, or company…"
+            onRowClick={(a) => void openApp(a.id)}
+            loading={loading}
+            empty="No applications yet — tailor your first resume above."
+          />
+        </Card>
+      </div>
+
+      <ApplicationModal
+        open={viewOpen}
+        app={viewApp}
+        onClose={() => setViewOpen(false)}
+        onDeleted={() => {
+          setPage(0);
+          setRev((v) => v + 1);
+        }}
+      />
+    </Page>
+  );
+}

From db26947d9042fcdd38fb776370a0253b1d2a89b6 Mon Sep 17 00:00:00 2001
From: tpikachu <sjkunai@outlook.com>
Date: Thu, 2 Jul 2026 07:58:48 -0500
Subject: [PATCH 4/6] fix: address adversarial review of Tailor Resume + docs
 (v1.3 #4)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fixes the 5 confirmed findings from the 4-dimension refute-verify review:

- Indexing is now BEST-EFFORT, after every row exists: reindexProfile (new-profile
  path) + indexJob moved into one try/catch that returns indexError instead of
  failing the whole op — a 429/network error can no longer orphan a profile,
  discard the paid tailor result, hide a saved application behind an error banner,
  or invite duplicate profiles/applications on retry. TailorPage surfaces the
  partial state with recovery guidance.
- New applications:reindex IPC + a "Re-index" button in ApplicationModal — the
  recovery path for a failed index (application jobs are hidden from the only
  other re-index trigger), and a way to re-embed after switching embedding models.
- The "Interview ended" save/discard prompt is now GLOBAL (SavePromptModal in
  App): sessions started from Tailor Resume and stopped via the Cue Card get the
  prompt wherever the user is; InterviewPage's table refreshes off pendingSave
  clearing (its duplicate modal removed).

Docs: IPC map (applications section), OpenAI service (tailor.ts), DB (applications
table, tailored chunks, deletion semantics, indexes), session log.

Verified: typecheck · 131 unit · build green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 docs/04-DATABASE.md                           | 30 +++++--
 docs/05-IPC-MAP.md                            | 15 ++++
 docs/06-OPENAI-SERVICE.md                     | 14 +++
 docs/sessions/2026-07-02.md                   | 63 ++++++++++++++
 src/main/ipc/applications.ipc.ts              | 33 +++++--
 src/preload/index.ts                          |  7 +-
 src/renderer/dashboard/App.tsx                |  5 ++
 src/renderer/dashboard/ApplicationModal.tsx   | 24 ++++++
 src/renderer/dashboard/SavePromptModal.tsx    | 79 +++++++++++++++++
 .../dashboard/pages/InterviewPage.tsx         | 86 ++-----------------
 src/renderer/dashboard/pages/TailorPage.tsx   |  6 ++
 src/shared/ipc.ts                             |  1 +
 12 files changed, 267 insertions(+), 96 deletions(-)
 create mode 100644 docs/sessions/2026-07-02.md
 create mode 100644 src/renderer/dashboard/SavePromptModal.tsx

diff --git a/docs/04-DATABASE.md b/docs/04-DATABASE.md
index 8b57cab..5dc9139 100644
--- a/docs/04-DATABASE.md
+++ b/docs/04-DATABASE.md
@@ -12,7 +12,8 @@ profiles 1───* documents 1───* chunks ──* embeddings
    │                                   (1:1 chunk:embedding)
    ├──* notes
    ├──* stories                      (STAR stories; also indexed as `story` chunks, job_id null)
-   ├──* jobs ────* chunks            (JD + company-research chunks carry job_id; resume/note/story chunks have job_id null)
+   ├──* applications ──1 jobs        (Tailor Resume: each application owns a dedicated, hidden job; its tailored resume = that job's `tailored` chunks)
+   ├──* jobs ────* chunks            (JD + company-research + tailored chunks carry job_id; resume/note/story chunks have job_id null)
    │       └──── sessions            (a session optionally references the job it's for)
    └──* sessions 1──* transcript_chunks
                  1──* detected_questions 1──* ai_answers
@@ -68,6 +69,12 @@ Uploaded file metadata + parsed text.
 Freeform additional notes attached to a profile.
 | id | profile_id FK | content | created_at |
 
+### `applications`
+A Tailor Resume application: the ATS-friendly resume tailored from a base resume × JD,
+plus grounded answers to the application questions. Owns a dedicated jobs row (hidden
+from the Interviews UI) whose `tailored` chunks ground that application's interviews.
+| id | profile_id FK (cascade) | job_id FK (cascade) | name | job_title | company | base_resume | tailored_resume | answers (json[]) | created_at | updated_at |
+
 ### `stories`
 Reusable STAR stories extracted from the résumé, tagged by competency + skills.
 Profile-level (reused across every interview); also indexed as `story` chunks so
@@ -75,13 +82,16 @@ they can ground live answers.
 | id | profile_id FK | title | situation | task | action | result | competencies (json[]) | skills (json[]) | created_at | updated_at |
 
 ### `chunks`
-Chunked text from documents/notes/profile fields/stories for RAG.
-| id | profile_id FK | job_id FK (nullable) | source_type (resume/jd/note/company/story) | source_id | ord | content | token_count | created_at |
+Chunked text from documents/notes/profile fields/stories/tailored resumes for RAG.
+| id | profile_id FK | job_id FK (nullable) | source_type (resume/jd/note/company/story/tailored) | source_id | ord | content | token_count | created_at |
 
-`job_id` is set on JD **and** company-research chunks (both cascade on job
+`job_id` is set on JD, company-research, **and** `tailored` chunks (all cascade on job
 delete); resume/note/story chunks have `job_id` null. `story` chunks are managed
 by `indexStories` (one chunk per story) and are deliberately **excluded** from the
 résumé/notes re-index, so re-saving a résumé doesn't wipe the curated story bank.
+`tailored` chunks (an application's tailored resume, indexed by `indexJob`) REPLACE the
+base `resume` chunks in retrieval whenever the selected job has them — that's how
+"Start interview" on an application grounds in the tailored resume instead of the base.
 
 ### `embeddings`
 | id | chunk_id FK (unique) | model | dim | vector BLOB | created_at |
@@ -115,14 +125,16 @@ Known keys:
 - `tour_done` — `'1'` once the first-run guided tour is completed/skipped.
 
 ## Deletion semantics
-Deleting a profile cascades to its documents, notes, stories, jobs, chunks,
-embeddings, sessions, and everything under sessions (FK `on delete cascade`). Deleting a job
-cascades to its JD chunks and nulls `sessions.job_id` (the session history is
-kept). Original uploaded files in `userData/documents/` are removed by the
-documents service.
+Deleting a profile cascades to its documents, notes, stories, applications, jobs,
+chunks, embeddings, sessions, and everything under sessions (FK `on delete cascade`).
+Deleting a job cascades to its JD/company/tailored chunks and nulls `sessions.job_id`
+(the session history is kept). Deleting an application removes its dedicated job the
+same way, then the application row. Original uploaded files in `userData/documents/`
+are removed by the documents service.
 
 ## Indexes
 - `chunks(profile_id)`, `jobs(profile_id)`, `stories(profile_id)`,
+  `applications(profile_id)`, `applications(created_at)`,
   `embeddings(chunk_id)`, `transcript_chunks(session_id)`,
   `detected_questions(session_id)`, `ai_answers(question_id)`,
   `sessions(profile_id)`, `documents(profile_id)`, `notes(profile_id)`.
diff --git a/docs/05-IPC-MAP.md b/docs/05-IPC-MAP.md
index d411997..0762961 100644
--- a/docs/05-IPC-MAP.md
+++ b/docs/05-IPC-MAP.md
@@ -91,6 +91,21 @@ independently.
 | `notes:create` | `{ profileId, content }` | `Note` |
 | `notes:delete` | `{ id }` | `{ deleted: true }` |
 
+### applications (Tailor Resume)
+A job application produced by the Tailor Resume flow: an ATS-friendly resume tailored
+from a base resume × JD (grounded — never invented), plus answers to the application
+questions. Each application owns a dedicated (hidden) job row; its tailored resume is
+indexed as that job's `tailored` chunks, so "Start interview" (session.start with the
+app's profile+job) grounds the live session in the TAILORED resume + JD.
+| Channel | Request | Response |
+|---|---|---|
+| `applications:page` | `{ query?, limit=8, offset=0 }` | `{ items: ApplicationListItem[], total }` (global, newest first; `LIKE` over name/title/company) |
+| `applications:get` | `{ id }` | `Application` |
+| `applications:tailor` | `{ profileId\|null, baseResumeText\|null, jdText, questions[] }` | `{ application, embedded, indexError }` (ALL model calls run before any write — an LLM failure persists nothing. An uploaded base resume materializes a real profile. Indexing is best-effort AFTER the rows exist: on failure the app is still saved and `indexError` is set — recover via `applications:reindex`) |
+| `applications:reindex` | `{ id }` | `{ embedded }` (re-embed the JD + tailored chunks — recovery/refresh) |
+| `applications:export-pdf` | `{ id }` | `{ saved, filePath? }` (tailored resume → ATS-friendly PDF via a hidden window + printToPDF; native save dialog; `saved:false` on cancel) |
+| `applications:delete` | `{ id }` | `{ deleted: true }` (also removes the dedicated job + its chunks; sessions keep history with jobId nulled) |
+
 ### stories
 The per-profile STAR story bank (`Story[]`). Stories are extracted from the parsed
 résumé, persisted, and indexed as `story` chunks so they ground live answers.
diff --git a/docs/06-OPENAI-SERVICE.md b/docs/06-OPENAI-SERVICE.md
index 24894f9..56beb04 100644
--- a/docs/06-OPENAI-SERVICE.md
+++ b/docs/06-OPENAI-SERVICE.md
@@ -86,6 +86,20 @@ so it grounds the answer, stays citable, and the Cue Card surfaces it as a promi
 **"📖 Story to tell"** callout (`StoryCue` in Overlay.tsx, derived from the `contextSent` chunks —
 no extra IPC event or embedding call).
 
+### tailor.ts — `tailorApplication(input) => TailorResult`
+Powers **Tailor Resume** (v1.3). One call (new `tailor` model key — full `gpt-4.1` on
+balanced, `gpt-5` on best; latency-tolerant, quality-critical) takes the BASE resume ×
+JD × application questions and returns `{ candidateName, jobTitle, company,
+tailoredResume, answers[] }`. The prompt grounds EVERYTHING in the base resume (reword/
+reorder/emphasize — never invent employers, dates, metrics, or skills), mirrors the JD's
+keywords only where truthful (ATS matching), and mandates ATS structure: single column,
+standard H2 sections, plain markdown, no tables/images. Answers are first-person and
+grounded. Defensively parsed; throws if no resume comes back (so nothing persists).
+The `applications:tailor` handler then materializes a profile (uploaded-base path),
+a dedicated job (JD), and the application row; `indexJob` embeds the tailored resume as
+job-scoped `tailored` chunks, and `vectorStore.search` drops base `resume` chunks for
+jobs that have them — live sessions ground in the TAILORED resume + JD.
+
 ### embeddings.ts — `embed(texts: string[]) => Float32Array[]`
 Batches inputs, returns vectors; caller stores BLOBs. Records model + dim.
 
diff --git a/docs/sessions/2026-07-02.md b/docs/sessions/2026-07-02.md
new file mode 100644
index 0000000..0ffbbde
--- /dev/null
+++ b/docs/sessions/2026-07-02.md
@@ -0,0 +1,63 @@
+# 2026-07-02
+
+v1.2.0 released (tag → GitHub Release). Started **v1.3's flagship: Tailor Resume**
+(branch `feat/tailor-resume`), designed via a 4-agent survey (upload/extract reuse,
+RAG grounding design, dashboard UI patterns, PDF export options).
+
+## Tailor Resume (v1.3)
+
+**The flow:** pick a profile OR upload/paste a resume (base) → paste/upload/URL-fetch a
+JD → optional application questions → ONE LLM op returns an **ATS-friendly tailored
+resume** (grounded ONLY in the base resume — reword/reorder/emphasize, never invent) +
+grounded answers + extracted jobTitle/company → **PDF download** → auto-saved as an
+**Application** (`[name] - [jobTitle] at [company]`) in a dense, paginated, searchable,
+newest-first table → per-row **Start interview** grounds a live session in the
+TAILORED resume + JD.
+
+**Key design decisions (survey-driven):**
+- **Grounding swap via `tailored` chunks, not derived profiles.** Each application owns
+  a dedicated Job row (hidden from the Interviews UI via a `notInArray` subquery in
+  `jobsRepo.list/page/count`). `indexJob` also indexes the application's tailored resume
+  as job-scoped `tailored` chunks (inside its single clear-and-reinsert pass), and
+  `vectorStore.search` drops base `resume` chunks whenever the selected job has tailored
+  ones. Session pipeline untouched; notes/stories still ground; non-application jobs
+  are unaffected (the filter is a no-op without tailored chunks).
+- **Uploaded base resume materializes a real profile** (named from the resume), keeping
+  the NOT NULL FKs and giving the user a reusable profile — no hidden-profile leakage.
+- **Model-calls-first ordering:** tailor + JD-parse + resume-parse all run before any DB
+  write, so an LLM failure persists nothing.
+- **PDF via hidden window + `printToPDF`** (zero deps): a deliberately minimal md→html
+  converter (`documents/resumeHtml.ts`, escape-first, single column, standard fonts, no
+  scripts — the simplicity IS the ATS feature) → data: URL → tagged Letter PDF → native
+  save dialog. Window destroyed in `finally`.
+- New `tailor` model key (balanced `gpt-4.1` / low_cost mini / best `gpt-5` + medium
+  effort) — one-off, latency-tolerant, quality-critical.
+
+**Shipped in 3 commits** (`cc72fe4` backend + migration 0006 + tailor.test (+8);
+`fca7692` PDF export + resumeHtml.test (+5); `7876267` the /tailor page + nav).
+
+**Adversarial review** (4 dimensions → refute-verify; 5 confirmed, 1 refuted):
+1-2. *(med)* Embedding calls (`reindexProfile`, `indexJob`) violated the handler's own
+   "nothing persisted unless model calls succeed" invariant: a 429 mid-sequence could
+   orphan a profile, discard the paid tailor result, duplicate profiles/applications on
+   retry, and surface a saved application as a total failure with a stale table.
+3. *(med)* A failed index had **no recovery path ever** (application jobs are hidden from
+   the only re-index trigger), silently grounding interviews in the base resume while
+   the Cue Card claimed JD context.
+4. *(med)* The "Interview ended" save/discard prompt lived only on InterviewPage — a
+   session started from TailorPage and stopped via the Cue Card never showed it (and a
+   stale prompt would pop on the next /interview visit).
+5. *(low)* Duplicate-application accumulation on retry (same root as 1-2).
+
+**Fixes:** indexing is now BEST-EFFORT after all rows exist (`try/catch` → returns
+`indexError`; TailorPage surfaces it); new `applications:reindex` IPC + a **Re-index**
+button in ApplicationModal (recovery + re-embed after model changes); the save/discard
+prompt extracted to a global `SavePromptModal` rendered in App (appears on any page;
+InterviewPage refreshes its table off `pendingSave` clearing).
+
+Verified: `typecheck` · 131 unit (+13) · `build` green throughout.
+
+## Next
+- v1.3.0 release cut when the user asks (changelog + version bump).
+- Possible fast-follows: re-tailor an existing application; mock/sparring against an
+  application's JD; live-verify the tailor prompt quality on real JDs.
diff --git a/src/main/ipc/applications.ipc.ts b/src/main/ipc/applications.ipc.ts
index d02a08b..aa75e82 100644
--- a/src/main/ipc/applications.ipc.ts
+++ b/src/main/ipc/applications.ipc.ts
@@ -8,7 +8,9 @@ import { tailorApplication } from '../services/openai/tailor';
 import { parseJobDescription, parseResume } from '../services/openai/parsing';
 import { indexJob, reindexProfile } from '../services/rag/indexProfile';
 import { exportResumePdf } from '../services/documents/resumePdf';
+import { normalizeOpenAIError } from '../services/openai/client';
 import { apiKeyStore } from '../services/security/apiKey';
+import { log } from '../services/security/logger';
 
 export function registerApplicationsIpc(): void {
   handle(
@@ -67,7 +69,8 @@ export function registerApplicationsIpc(): void {
       const parsedResume = existing ? null : await parseResume(baseResume);
 
       // Uploaded base resume → materialize a real, reusable profile for it (sessions
-      // and jobs both require an owning profile).
+      // and jobs both require an owning profile). Its embedding runs in the
+      // best-effort block below, AFTER the application row exists.
       let owner = existing;
       if (!owner) {
         owner = profilesRepo.create({
@@ -80,7 +83,6 @@ export function registerApplicationsIpc(): void {
           jdText: null,
         });
         profilesRepo.update(owner.id, { parsedResume });
-        await reindexProfile(owner.id);
       }
 
       // The application's dedicated job: holds the JD + (via indexJob) the tailored
@@ -107,13 +109,32 @@ export function registerApplicationsIpc(): void {
         answers: result.answers,
       });
 
-      // Embed JD + tailored chunks. If embedding fails the app still exists; its
-      // sessions fall back to base-resume grounding until a re-index succeeds.
-      const { embedded } = await indexJob(job.id);
-      return { application: app, embedded };
+      // BEST-EFFORT indexing — every row already exists, so an embedding failure
+      // (429/network) must NOT fail the operation or lose the paid result. Sessions
+      // fall back to base-resume grounding until "Re-index" succeeds; a new profile's
+      // base chunks self-heal on its next resume save.
+      let embedded = 0;
+      let indexError: string | null = null;
+      try {
+        if (!existing) await reindexProfile(owner.id);
+        ({ embedded } = await indexJob(job.id));
+      } catch (e) {
+        indexError = normalizeOpenAIError(e);
+        log.warn('applications:tailor indexing failed (app saved)', indexError);
+      }
+      return { application: app, embedded, indexError };
     },
   );
 
+  // Re-embed an application's grounding (JD + tailored chunks) — the recovery path
+  // when indexing failed at tailor time (and a way to re-embed after model changes).
+  handle(IPC.applications.reindex, zId, async ({ id }) => {
+    const app = applicationsRepo.get(id);
+    if (!app) throw new Error('Application not found');
+    const { embedded } = await indexJob(app.jobId);
+    return { embedded };
+  });
+
   // Save the tailored resume as an ATS-friendly PDF (native save dialog).
   handle(IPC.applications.exportPdf, zId, async ({ id }) => {
     const app = applicationsRepo.get(id);
diff --git a/src/preload/index.ts b/src/preload/index.ts
index 45168c1..904da86 100644
--- a/src/preload/index.ts
+++ b/src/preload/index.ts
@@ -128,7 +128,12 @@ const api = {
       baseResumeText: string | null;
       jdText: string;
       questions: string[];
-    }) => invoke<{ application: Application; embedded: number }>(IPC.applications.tailor, input),
+    }) =>
+      invoke<{ application: Application; embedded: number; indexError: string | null }>(
+        IPC.applications.tailor,
+        input,
+      ),
+    reindex: (id: string) => invoke<{ embedded: number }>(IPC.applications.reindex, { id }),
     exportPdf: (id: string) =>
       invoke<{ saved: boolean; filePath?: string }>(IPC.applications.exportPdf, { id }),
     delete: (id: string) => invoke<{ deleted: true }>(IPC.applications.delete, { id }),
diff --git a/src/renderer/dashboard/App.tsx b/src/renderer/dashboard/App.tsx
index a47d284..7599292 100644
--- a/src/renderer/dashboard/App.tsx
+++ b/src/renderer/dashboard/App.tsx
@@ -17,6 +17,7 @@ import DevDbExplorerPage from './pages/DevDbExplorerPage';
 import { Titlebar } from './Titlebar';
 import { SidebarStatus } from './SidebarStatus';
 import { UpdateBanner } from './UpdateBanner';
+import { SavePromptModal } from './SavePromptModal';
 import {
   BoltIcon,
   DatabaseIcon,
@@ -149,6 +150,10 @@ export default function App() {
       </main>
       </div>
 
+      {/* Global: sessions can be started from several pages and stopped from the
+          Cue Card — the save-or-discard prompt must appear wherever the user is. */}
+      <SavePromptModal />
+
       {running && <Tour steps={TOUR_STEPS} onClose={finishTour} />}
     </div>
   );
diff --git a/src/renderer/dashboard/ApplicationModal.tsx b/src/renderer/dashboard/ApplicationModal.tsx
index 1e20608..be744dd 100644
--- a/src/renderer/dashboard/ApplicationModal.tsx
+++ b/src/renderer/dashboard/ApplicationModal.tsx
@@ -62,6 +62,22 @@ export function ApplicationModal({
     }
   };
 
+  // Recovery path when indexing failed at tailor time (also re-embeds after
+  // switching the embedding model): re-index the JD + tailored grounding chunks.
+  const reindex = async () => {
+    setBusy('Re-indexing…');
+    setError(null);
+    setNotice(null);
+    try {
+      const r = await api.applications.reindex(app.id);
+      setNotice(`Re-indexed ✓ — ${r.embedded} chunks embedded. Interviews now ground in this tailored resume.`);
+    } catch (e) {
+      setError((e as Error).message);
+    } finally {
+      setBusy(null);
+    }
+  };
+
   return (
     <Modal open={open} onClose={onClose} title={label} width="max-w-3xl">
       <div className="space-y-5">
@@ -80,6 +96,14 @@ export function ApplicationModal({
           <Button variant="primary" disabled={!!busy} onClick={() => void downloadPdf()}>
             {busy === 'Exporting PDF…' ? 'Exporting…' : 'Download PDF'}
           </Button>
+          <Button
+            variant="ghost"
+            disabled={!!busy}
+            title="Re-embed the tailored resume + JD for live-interview grounding"
+            onClick={() => void reindex()}
+          >
+            {busy === 'Re-indexing…' ? 'Re-indexing…' : 'Re-index'}
+          </Button>
           {confirmDelete ? (
             <>
               <span className="text-xs text-neutral-500">
diff --git a/src/renderer/dashboard/SavePromptModal.tsx b/src/renderer/dashboard/SavePromptModal.tsx
new file mode 100644
index 0000000..651fccb
--- /dev/null
+++ b/src/renderer/dashboard/SavePromptModal.tsx
@@ -0,0 +1,79 @@
+import { useEffect, useState } from 'react';
+import { api } from '../lib/api';
+import { useLiveSession } from '../store/useLiveSession';
+import type { InterviewType } from '@shared/types';
+import { Button, Field, Modal, Select } from '../components/ui';
+
+const INTERVIEW_TYPES: { value: InterviewType; label: string }[] = [
+  { value: 'general', label: 'General' },
+  { value: 'behavioral', label: 'Behavioral' },
+  { value: 'technical', label: 'Technical' },
+  { value: 'coding', label: 'Coding' },
+  { value: 'system_design', label: 'System design' },
+  { value: 'product', label: 'Product' },
+  { value: 'sales', label: 'Sales' },
+];
+
+/** Global "Interview ended" save-or-discard prompt. Rendered in App (not a page):
+ *  sessions can be started from several pages (Interview, Tailor Resume) and are
+ *  usually STOPPED from the Cue Card — the prompt must appear wherever the user is. */
+export function SavePromptModal() {
+  const { pendingSave, clearPendingSave } = useLiveSession();
+  const [saveType, setSaveType] = useState<InterviewType>('general');
+
+  useEffect(() => {
+    if (pendingSave) setSaveType(pendingSave.interviewType);
+  }, [pendingSave]);
+
+  const save = async () => {
+    if (!pendingSave) return;
+    await api.session.setInterviewType(pendingSave.sessionId, saveType);
+    clearPendingSave();
+  };
+  const discard = async () => {
+    if (!pendingSave) return;
+    await api.session.delete(pendingSave.sessionId);
+    clearPendingSave();
+  };
+
+  return (
+    <Modal open={!!pendingSave} onClose={clearPendingSave} title="Interview ended" width="max-w-md">
+      <div className="space-y-4">
+        <p className="text-sm text-neutral-300">
+          Save this interview{pendingSave?.jobTitle ? ` for “${pendingSave.jobTitle}”` : ''}?{' '}
+          <span className="text-neutral-500">
+            {pendingSave?.questionCount
+              ? `${pendingSave.questionCount} question${pendingSave.questionCount === 1 ? '' : 's'} captured.`
+              : 'No questions were captured.'}
+          </span>
+        </p>
+        <Field label="What kind of interview was this?">
+          <Select value={saveType} onChange={(e) => setSaveType(e.target.value as InterviewType)}>
+            {INTERVIEW_TYPES.map((t) => (
+              <option key={t.value} value={t.value}>
+                {t.label}
+              </option>
+            ))}
+          </Select>
+        </Field>
+        <div className="flex items-center justify-between pt-1">
+          <Button variant="ghost" className="text-red-300" onClick={() => void discard()}>
+            Discard
+          </Button>
+          <div className="flex gap-2">
+            <Button variant="ghost" onClick={clearPendingSave}>
+              Decide later
+            </Button>
+            <Button variant="primary" onClick={() => void save()}>
+              Save to Reports
+            </Button>
+          </div>
+        </div>
+        <p className="text-xs text-neutral-500">
+          “Discard” permanently deletes this session and its transcript. “Decide later” keeps it
+          for now — you can delete it from Reports.
+        </p>
+      </div>
+    </Modal>
+  );
+}
diff --git a/src/renderer/dashboard/pages/InterviewPage.tsx b/src/renderer/dashboard/pages/InterviewPage.tsx
index 94cb691..482b830 100644
--- a/src/renderer/dashboard/pages/InterviewPage.tsx
+++ b/src/renderer/dashboard/pages/InterviewPage.tsx
@@ -4,8 +4,8 @@ import { api } from '../../lib/api';
 import { useProfileStore } from '../../store/useProfileStore';
 import { useSettingsStore } from '../../store/useSettingsStore';
 import { useLiveSession, type Line } from '../../store/useLiveSession';
-import type { InterviewType, Job, SessionDetail, SessionListItem } from '@shared/types';
-import { Badge, Button, Card, Field, Modal, Page, Select } from '../../components/ui';
+import type { Job, SessionDetail, SessionListItem } from '@shared/types';
+import { Badge, Button, Card, Field, Page, Select } from '../../components/ui';
 import { DataTable, type Column } from '../../components/DataTable';
 import { JobFormModal } from '../JobFormModal';
 import { BriefModal } from '../BriefModal';
@@ -14,16 +14,6 @@ import { PlayIcon, PlusIcon } from '../../components/icons';
 
 const JOBS_PER_PAGE = 5;
 
-const INTERVIEW_TYPES: { value: InterviewType; label: string }[] = [
-  { value: 'general', label: 'General' },
-  { value: 'behavioral', label: 'Behavioral' },
-  { value: 'technical', label: 'Technical' },
-  { value: 'coding', label: 'Coding' },
-  { value: 'system_design', label: 'System design' },
-  { value: 'product', label: 'Product' },
-  { value: 'sales', label: 'Sales' },
-];
-
 export default function InterviewPage() {
   const { profiles, load } = useProfileStore();
   const { settings, load: loadSettings } = useSettingsStore();
@@ -50,14 +40,10 @@ export default function InterviewPage() {
   // Latest session per job, so each row offers Start (none yet) or Resume.
   const [sessionsByJob, setSessionsByJob] = useState<Map<string, SessionListItem>>(new Map());
   const [busyJobId, setBusyJobId] = useState<string | null>(null);
-  const [sessionsRev, setSessionsRev] = useState(0); // bump to re-fetch the session map
 
-  // Save-or-discard prompt for the just-ended session (pushed from main on stop).
-  const { pendingSave, clearPendingSave } = live;
-  const [saveType, setSaveType] = useState<InterviewType>('general');
-  useEffect(() => {
-    if (pendingSave) setSaveType(pendingSave.interviewType);
-  }, [pendingSave]);
+  // The save-or-discard prompt itself is GLOBAL (SavePromptModal in App) — here we
+  // only watch it so the table's Start/Resume buttons refresh after save/discard.
+  const { pendingSave } = live;
 
   useEffect(() => {
     void load();
@@ -103,7 +89,7 @@ export default function InterviewPage() {
       }
       setSessionsByJob(map);
     })();
-  }, [profileId, session, sessionsRev]);
+  }, [profileId, session, pendingSave]);
 
   // Reset the selection + paging whenever the profile changes.
   useEffect(() => {
@@ -188,20 +174,6 @@ export default function InterviewPage() {
     }
   };
 
-  // Save the just-ended session with the chosen interview type, or discard it.
-  const saveSession = async () => {
-    if (!pendingSave) return;
-    await api.session.setInterviewType(pendingSave.sessionId, saveType);
-    clearPendingSave();
-    setSessionsRev((r) => r + 1);
-  };
-  const discardSession = async () => {
-    if (!pendingSave) return;
-    await api.session.delete(pendingSave.sessionId);
-    clearPendingSave();
-    setSessionsRev((r) => r + 1);
-  };
-
   const jobColumns: Column<Job>[] = [
     {
       key: 'title',
@@ -412,52 +384,6 @@ export default function InterviewPage() {
 
       {/* Pre-interview prep brief (résumé × JD × company), generated on open. */}
       <BriefModal open={!!briefJob} job={briefJob} onClose={() => setBriefJob(null)} />
-
-      {/* Save-or-discard the interview that just ended. */}
-      <Modal
-        open={!!pendingSave}
-        onClose={clearPendingSave}
-        title="Interview ended"
-        width="max-w-md"
-      >
-        <div className="space-y-4">
-          <p className="text-sm text-neutral-300">
-            Save this interview{pendingSave?.jobTitle ? ` for “${pendingSave.jobTitle}”` : ''}?
-            {' '}
-            <span className="text-neutral-500">
-              {pendingSave?.questionCount
-                ? `${pendingSave.questionCount} question${pendingSave.questionCount === 1 ? '' : 's'} captured.`
-                : 'No questions were captured.'}
-            </span>
-          </p>
-          <Field label="What kind of interview was this?">
-            <Select value={saveType} onChange={(e) => setSaveType(e.target.value as InterviewType)}>
-              {INTERVIEW_TYPES.map((t) => (
-                <option key={t.value} value={t.value}>
-                  {t.label}
-                </option>
-              ))}
-            </Select>
-          </Field>
-          <div className="flex items-center justify-between pt-1">
-            <Button variant="ghost" className="text-red-300" onClick={() => void discardSession()}>
-              Discard
-            </Button>
-            <div className="flex gap-2">
-              <Button variant="ghost" onClick={clearPendingSave}>
-                Decide later
-              </Button>
-              <Button variant="primary" onClick={() => void saveSession()}>
-                Save to Reports
-              </Button>
-            </div>
-          </div>
-          <p className="text-xs text-neutral-500">
-            “Discard” permanently deletes this session and its transcript. “Decide later” keeps it
-            for now — you can delete it from Reports.
-          </p>
-        </div>
-      </Modal>
     </Page>
   );
 }
diff --git a/src/renderer/dashboard/pages/TailorPage.tsx b/src/renderer/dashboard/pages/TailorPage.tsx
index cbc3581..04c8279 100644
--- a/src/renderer/dashboard/pages/TailorPage.tsx
+++ b/src/renderer/dashboard/pages/TailorPage.tsx
@@ -123,6 +123,12 @@ export default function TailorPage() {
       setPage(0);
       setRev((v) => v + 1);
       void load(); // an uploaded base resume may have created a new profile
+      // Saved, but grounding wasn't embedded (e.g. a rate limit) — recoverable.
+      if (r.indexError)
+        setError(
+          `Application saved, but indexing its grounding failed (${r.indexError}). ` +
+            'Open it and press "Re-index" so interviews use the tailored resume.',
+        );
     });
 
   // Start a live interview grounded in this application's tailored resume + JD.
diff --git a/src/shared/ipc.ts b/src/shared/ipc.ts
index 010c9eb..92a4fc4 100644
--- a/src/shared/ipc.ts
+++ b/src/shared/ipc.ts
@@ -66,6 +66,7 @@ export const IPC = {
     page: 'applications:page',
     get: 'applications:get',
     tailor: 'applications:tailor', // the Tailor Resume op: LLM → profile/job/app rows + index
+    reindex: 'applications:reindex', // re-embed the JD + tailored chunks (recovery/refresh)
     exportPdf: 'applications:export-pdf', // tailored resume → ATS-friendly PDF (save dialog)
     delete: 'applications:delete',
   },

From 9022d1fa47856d0a5865d9e4f6aef835bfb1e767 Mon Sep 17 00:00:00 2001
From: tpikachu <sjkunai@outlook.com>
Date: Thu, 2 Jul 2026 18:02:30 -0500
Subject: [PATCH 5/6] =?UTF-8?q?feat:=20Tailor=20Resume=20refinements=20?=
 =?UTF-8?q?=E2=80=94=20row=20delete,=20dedupe/parse-once,=20base-vs-tailor?=
 =?UTF-8?q?ed=20diff=20(v1.3=20#5)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Three refinements from live testing:

- Row delete: each applications-table row gets a ✕ with a two-step inline confirm
  (modal delete kept). Hidden for the live application's row; deleteApp guards and
  the modal's Delete disables — deleting mid-interview would silently downgrade the
  live session's grounding.
- No duplicate operations: the tailor handler resolves the owning profile up front
  (selected, else an existing profile with the SAME resume text), so repeat
  tailorings from one uploaded resume reuse one profile instead of creating
  duplicates; parseResume runs AT MOST ONCE per profile (skipped when already
  parsed) and reindexProfile only for created/newly-parsed profiles.
- Compare with base: ApplicationModal toggle showing side-by-side panes with
  word-level highlights (red = removed, green = added/rewritten) via a new
  dependency-free LCS diff (renderer/lib/wordDiff.ts, +6 tests; plain side-by-side
  fallback for very long resumes).

Fixes the 3 confirmed adversarial-review findings: out-of-range page self-heals
after deleting the last row of the last page; applications:reindex now also
re-embeds the owning profile's base chunks (a failed first index was otherwise
unrecoverable); delete-while-live is guarded at row, modal, and handler level.

Verified: typecheck · 137 unit · build green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 docs/05-IPC-MAP.md                          |   2 +-
 docs/sessions/2026-07-02.md                 |  26 +++++
 src/main/ipc/applications.ipc.ts            |  41 +++++---
 src/renderer/dashboard/ApplicationModal.tsx | 107 +++++++++++++++++---
 src/renderer/dashboard/pages/TailorPage.tsx |  85 +++++++++++++---
 src/renderer/lib/wordDiff.test.ts           |  51 ++++++++++
 src/renderer/lib/wordDiff.ts                |  80 +++++++++++++++
 7 files changed, 351 insertions(+), 41 deletions(-)
 create mode 100644 src/renderer/lib/wordDiff.test.ts
 create mode 100644 src/renderer/lib/wordDiff.ts

diff --git a/docs/05-IPC-MAP.md b/docs/05-IPC-MAP.md
index 0762961..db0fcd8 100644
--- a/docs/05-IPC-MAP.md
+++ b/docs/05-IPC-MAP.md
@@ -102,7 +102,7 @@ app's profile+job) grounds the live session in the TAILORED resume + JD.
 | `applications:page` | `{ query?, limit=8, offset=0 }` | `{ items: ApplicationListItem[], total }` (global, newest first; `LIKE` over name/title/company) |
 | `applications:get` | `{ id }` | `Application` |
 | `applications:tailor` | `{ profileId\|null, baseResumeText\|null, jdText, questions[] }` | `{ application, embedded, indexError }` (ALL model calls run before any write — an LLM failure persists nothing. An uploaded base resume materializes a real profile. Indexing is best-effort AFTER the rows exist: on failure the app is still saved and `indexError` is set — recover via `applications:reindex`) |
-| `applications:reindex` | `{ id }` | `{ embedded }` (re-embed the JD + tailored chunks — recovery/refresh) |
+| `applications:reindex` | `{ id }` | `{ embedded }` (re-embed the owning profile's base chunks AND the job's jd/tailored chunks — full recovery/refresh) |
 | `applications:export-pdf` | `{ id }` | `{ saved, filePath? }` (tailored resume → ATS-friendly PDF via a hidden window + printToPDF; native save dialog; `saved:false` on cancel) |
 | `applications:delete` | `{ id }` | `{ deleted: true }` (also removes the dedicated job + its chunks; sessions keep history with jobId nulled) |
 
diff --git a/docs/sessions/2026-07-02.md b/docs/sessions/2026-07-02.md
index 0ffbbde..47b5060 100644
--- a/docs/sessions/2026-07-02.md
+++ b/docs/sessions/2026-07-02.md
@@ -57,6 +57,32 @@ InterviewPage refreshes its table off `pendingSave` clearing).
 
 Verified: `typecheck` · 131 unit (+13) · `build` green throughout.
 
+## Refinements (user feedback after testing)
+
+1. **Row delete** — a ✕ with a two-step inline confirm on each applications-table row
+   (modal delete kept).
+2. **Profile dedupe + parse-at-most-once** — the tailor handler resolves the owning
+   profile up front (selected, else an existing profile with the SAME resume text), so
+   repeat tailorings from one upload reuse one profile; `parseResume` is skipped whenever
+   the owner is already parsed; `reindexProfile` runs only for created/newly-parsed
+   profiles.
+3. **Base vs tailored comparison** — a "Compare with base" toggle in ApplicationModal:
+   side-by-side panes with word-level highlights (red = removed, green = added/rewritten)
+   via a new dependency-free LCS util (`renderer/lib/wordDiff.ts`, +6 tests; plain
+   side-by-side fallback past the 4M-cell DP guard).
+
+**Adversarial review of the refinements** (2 dimensions → refute-verify; 3 confirmed):
+- *(med)* deleting the last row of the last page stranded an empty out-of-range page →
+  the fetch effect now self-heals to the new last page (covers all callers).
+- *(low)* the parse-once gate made a failed first base-index unrecoverable (Re-index only
+  healed the job) → `applications:reindex` now re-embeds the profile's base chunks AND
+  the job's jd/tailored chunks.
+- *(low)* the row ✕ could delete an application whose interview was LIVE, silently
+  downgrading its grounding mid-session → the ✕ is hidden for the live row, `deleteApp`
+  guards, and the modal's Delete is disabled with a hint.
+
+Verified: `typecheck` · 137 unit (+6) · `build` green.
+
 ## Next
 - v1.3.0 release cut when the user asks (changelog + version bump).
 - Possible fast-follows: re-tailor an existing application; mock/sparring against an
diff --git a/src/main/ipc/applications.ipc.ts b/src/main/ipc/applications.ipc.ts
index aa75e82..0df6bd9 100644
--- a/src/main/ipc/applications.ipc.ts
+++ b/src/main/ipc/applications.ipc.ts
@@ -58,20 +58,29 @@ export function registerApplicationsIpc(): void {
         baseResume = baseResumeText;
       }
 
-      // Model calls first (tailor + JD parse + resume parse for a new profile), so a
-      // failure here leaves the database untouched.
+      // Resolve the OWNING profile up front (reads only): the selected one, or — for
+      // an uploaded/pasted base — an existing profile with the SAME resume text, so
+      // repeat tailorings from one resume reuse it (no duplicate profiles).
+      let owner =
+        existing ??
+        profilesRepo.list().find((p) => (p.resumeText ?? '').trim() === baseResume.trim()) ??
+        null;
+
+      // Model calls first (tailor + JD parse + resume parse), so a failure here
+      // leaves the database untouched. The base resume is parsed AT MOST ONCE per
+      // profile — skipped whenever the owner already has a parsed resume.
       const result = await tailorApplication({
         baseResume,
         jdText,
         questions: questions.map((q) => q.trim()).filter(Boolean),
       });
       const parsedJd = await parseJobDescription(jdText);
-      const parsedResume = existing ? null : await parseResume(baseResume);
+      const parsedResume = owner?.parsedResume ? null : await parseResume(baseResume);
 
-      // Uploaded base resume → materialize a real, reusable profile for it (sessions
-      // and jobs both require an owning profile). Its embedding runs in the
-      // best-effort block below, AFTER the application row exists.
-      let owner = existing;
+      // Uploaded base resume with no matching profile → materialize a real, reusable
+      // profile for it (sessions and jobs both require an owning profile). Its
+      // embedding runs in the best-effort block below, AFTER the application exists.
+      let createdProfile = false;
       if (!owner) {
         owner = profilesRepo.create({
           name: result.candidateName || 'Imported resume',
@@ -82,8 +91,9 @@ export function registerApplicationsIpc(): void {
           resumeText: baseResume,
           jdText: null,
         });
-        profilesRepo.update(owner.id, { parsedResume });
+        createdProfile = true;
       }
+      if (parsedResume) profilesRepo.update(owner.id, { parsedResume });
 
       // The application's dedicated job: holds the JD + (via indexJob) the tailored
       // chunks. Hidden from the regular Interviews table.
@@ -116,7 +126,9 @@ export function registerApplicationsIpc(): void {
       let embedded = 0;
       let indexError: string | null = null;
       try {
-        if (!existing) await reindexProfile(owner.id);
+        // Only a newly created (or newly parsed) profile needs its base re-indexed;
+        // a reused/matched profile's chunks are already in place.
+        if (createdProfile || parsedResume) await reindexProfile(owner.id);
         ({ embedded } = await indexJob(job.id));
       } catch (e) {
         indexError = normalizeOpenAIError(e);
@@ -126,13 +138,16 @@ export function registerApplicationsIpc(): void {
     },
   );
 
-  // Re-embed an application's grounding (JD + tailored chunks) — the recovery path
-  // when indexing failed at tailor time (and a way to re-embed after model changes).
+  // Re-embed an application's grounding — the recovery path when indexing failed at
+  // tailor time (and a way to re-embed after model changes). Heals BOTH the owning
+  // profile's base chunks (a failed first reindex is otherwise never retried — the
+  // parse-once gate skips matched profiles) AND the job's jd/tailored chunks.
   handle(IPC.applications.reindex, zId, async ({ id }) => {
     const app = applicationsRepo.get(id);
     if (!app) throw new Error('Application not found');
-    const { embedded } = await indexJob(app.jobId);
-    return { embedded };
+    const profile = await reindexProfile(app.profileId);
+    const job = await indexJob(app.jobId);
+    return { embedded: profile.embedded + job.embedded };
   });
 
   // Save the tailored resume as an ATS-friendly PDF (native save dialog).
diff --git a/src/renderer/dashboard/ApplicationModal.tsx b/src/renderer/dashboard/ApplicationModal.tsx
index be744dd..dba5aa8 100644
--- a/src/renderer/dashboard/ApplicationModal.tsx
+++ b/src/renderer/dashboard/ApplicationModal.tsx
@@ -1,8 +1,10 @@
-import { useEffect, useState } from 'react';
+import { useEffect, useMemo, useState } from 'react';
 import { api } from '../lib/api';
+import { useLiveSession } from '../store/useLiveSession';
 import type { Application } from '@shared/types';
 import { Badge, Button, Modal } from '../components/ui';
 import { Markdown } from '../components/Markdown';
+import { wordDiff, type DiffSegment } from '../lib/wordDiff';
 
 /** View one application: the tailored resume (markdown), the grounded answers to
  *  the application questions, PDF download, and delete. Used both for a fresh
@@ -22,6 +24,9 @@ export function ApplicationModal({
   const [notice, setNotice] = useState<string | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [confirmDelete, setConfirmDelete] = useState(false);
+  const [compare, setCompare] = useState(false); // side-by-side base vs tailored
+  const { session } = useLiveSession();
+  const isLive = !!app && session?.jobId === app.jobId; // a live interview grounds in this app
 
   // Reset transient state whenever a different application (or none) is shown.
   useEffect(() => {
@@ -29,8 +34,15 @@ export function ApplicationModal({
     setNotice(null);
     setError(null);
     setConfirmDelete(false);
+    setCompare(false);
   }, [open, app?.id]);
 
+  // Word-level diff, computed only when comparing. Null = too large → plain panes.
+  const diff = useMemo(
+    () => (compare && app ? wordDiff(app.baseResume, app.tailoredResume) : null),
+    [compare, app],
+  );
+
   if (!app) return null;
   const label = `${app.name} - ${app.jobTitle}${app.company ? ` at ${app.company}` : ''}`;
 
@@ -96,6 +108,13 @@ export function ApplicationModal({
           <Button variant="primary" disabled={!!busy} onClick={() => void downloadPdf()}>
             {busy === 'Exporting PDF…' ? 'Exporting…' : 'Download PDF'}
           </Button>
+          <Button
+            variant="ghost"
+            title="See what changed against your base resume"
+            onClick={() => setCompare((v) => !v)}
+          >
+            {compare ? 'Hide comparison' : 'Compare with base'}
+          </Button>
           <Button
             variant="ghost"
             disabled={!!busy}
@@ -117,22 +136,48 @@ export function ApplicationModal({
               </Button>
             </>
           ) : (
-            <Button variant="ghost" className="text-red-300" onClick={() => setConfirmDelete(true)}>
+            <Button
+              variant="ghost"
+              className="text-red-300"
+              disabled={isLive}
+              title={isLive ? 'A live interview is using this application — stop it first' : undefined}
+              onClick={() => setConfirmDelete(true)}
+            >
               Delete
             </Button>
           )}
         </div>
 
-        {/* The tailored, ATS-friendly resume. */}
-        <section>
-          <div className="mb-2 flex items-baseline gap-2">
-            <h4 className="text-sm font-semibold text-neutral-200">Tailored resume</h4>
-            <Badge tone="green">ATS-friendly</Badge>
-          </div>
-          <div className="max-h-96 overflow-y-auto rounded-xl border border-white/10 bg-neutral-950/40 p-4 text-sm leading-relaxed">
-            <Markdown>{app.tailoredResume}</Markdown>
-          </div>
-        </section>
+        {/* The tailored, ATS-friendly resume — or a base-vs-tailored comparison. */}
+        {compare ? (
+          <section>
+            <div className="mb-2 flex items-baseline gap-2">
+              <h4 className="text-sm font-semibold text-neutral-200">Base vs tailored</h4>
+              {diff ? (
+                <span className="text-xs text-neutral-600">
+                  <span className="rounded-sm bg-red-500/25 px-1 text-red-200">removed</span> ·{' '}
+                  <span className="rounded-sm bg-green-500/25 px-1 text-green-200">added / rewritten</span>
+                </span>
+              ) : (
+                <span className="text-xs text-neutral-600">too long to highlight — shown side by side</span>
+              )}
+            </div>
+            <div className="grid grid-cols-2 gap-3">
+              <DiffPane title="Base resume" segs={diff?.base} fallback={app.baseResume} />
+              <DiffPane title="Tailored" segs={diff?.revised} fallback={app.tailoredResume} />
+            </div>
+          </section>
+        ) : (
+          <section>
+            <div className="mb-2 flex items-baseline gap-2">
+              <h4 className="text-sm font-semibold text-neutral-200">Tailored resume</h4>
+              <Badge tone="green">ATS-friendly</Badge>
+            </div>
+            <div className="max-h-96 overflow-y-auto rounded-xl border border-white/10 bg-neutral-950/40 p-4 text-sm leading-relaxed">
+              <Markdown>{app.tailoredResume}</Markdown>
+            </div>
+          </section>
+        )}
 
         {/* Grounded answers to the application's questions. */}
         {app.answers.length > 0 && (
@@ -157,3 +202,41 @@ export function ApplicationModal({
     </Modal>
   );
 }
+
+/** One side of the base-vs-tailored comparison: highlighted diff segments when
+ *  available, otherwise the plain text (inputs too large to diff). */
+function DiffPane({
+  title,
+  segs,
+  fallback,
+}: {
+  title: string;
+  segs: DiffSegment[] | undefined;
+  fallback: string;
+}) {
+  return (
+    <div className="min-w-0">
+      <div className="mb-1 text-xs font-medium text-neutral-500">{title}</div>
+      <div className="max-h-96 overflow-y-auto whitespace-pre-wrap rounded-xl border border-white/10 bg-neutral-950/40 p-3 text-xs leading-relaxed text-neutral-300">
+        {segs
+          ? segs.map((s, i) =>
+              s.op === 'same' ? (
+                <span key={i}>{s.text}</span>
+              ) : (
+                <span
+                  key={i}
+                  className={
+                    s.op === 'del'
+                      ? 'rounded-sm bg-red-500/25 text-red-200'
+                      : 'rounded-sm bg-green-500/25 text-green-200'
+                  }
+                >
+                  {s.text}
+                </span>
+              ),
+            )
+          : fallback}
+      </div>
+    </div>
+  );
+}
diff --git a/src/renderer/dashboard/pages/TailorPage.tsx b/src/renderer/dashboard/pages/TailorPage.tsx
index 04c8279..cd68e3a 100644
--- a/src/renderer/dashboard/pages/TailorPage.tsx
+++ b/src/renderer/dashboard/pages/TailorPage.tsx
@@ -40,6 +40,7 @@ export default function TailorPage() {
   const [loading, setLoading] = useState(false);
   const [rev, setRev] = useState(0); // bump to re-fetch after tailor/delete
   const [busyAppId, setBusyAppId] = useState<string | null>(null);
+  const [confirmDeleteId, setConfirmDeleteId] = useState<string | null>(null); // row two-step delete
 
   useEffect(() => {
     void load();
@@ -53,6 +54,12 @@ export default function TailorPage() {
       api.applications
         .page(query.trim(), APPS_PER_PAGE, page * APPS_PER_PAGE)
         .then((r) => {
+          // Self-heal an out-of-range page (e.g. the last row of the last page was
+          // deleted): jump to the new last page instead of stranding an empty view.
+          if (r.items.length === 0 && r.total > 0 && page > 0) {
+            setPage(Math.ceil(r.total / APPS_PER_PAGE) - 1);
+            return;
+          }
           setRows(r.items);
           setTotal(r.total);
         })
@@ -159,6 +166,26 @@ export default function TailorPage() {
     }
   };
 
+  const deleteApp = async (id: string, jobId: string) => {
+    // A live interview is grounded in this application — deleting mid-session would
+    // silently downgrade its answers to base-resume grounding.
+    if (session?.jobId === jobId) {
+      setError('This application has a live interview — stop it before deleting.');
+      setConfirmDeleteId(null);
+      return;
+    }
+    setBusyAppId(id);
+    try {
+      await api.applications.delete(id);
+      setConfirmDeleteId(null);
+      setRev((v) => v + 1);
+    } catch (e) {
+      setError((e as Error).message);
+    } finally {
+      setBusyAppId(null);
+    }
+  };
+
   const columns: Column<ApplicationListItem>[] = [
     {
       key: 'label',
@@ -184,25 +211,53 @@ export default function TailorPage() {
     {
       key: 'actions',
       header: '',
-      className: 'w-56 text-right',
+      className: 'w-64 text-right',
       render: (a) => (
         <div className="flex items-center justify-end gap-1.5" onClick={(e) => e.stopPropagation()}>
-          {session?.jobId === a.jobId ? (
-            <Badge tone="green">● live</Badge>
+          {confirmDeleteId === a.id ? (
+            <>
+              <span className="text-xs text-neutral-500">Delete this application?</span>
+              <Button variant="ghost" onClick={() => setConfirmDeleteId(null)}>
+                Cancel
+              </Button>
+              <Button
+                variant="danger"
+                loading={busyAppId === a.id}
+                onClick={() => void deleteApp(a.id, a.jobId)}
+              >
+                Delete
+              </Button>
+            </>
           ) : (
-            <Button
-              variant="success"
-              disabled={!settings?.apiKeyPresent || !!session}
-              loading={busyAppId === a.id}
-              title="Start a live interview grounded in this tailored resume + JD"
-              onClick={() => void startInterview(a)}
-            >
-              <PlayIcon /> Start interview
-            </Button>
+            <>
+              {session?.jobId === a.jobId ? (
+                <Badge tone="green">● live</Badge>
+              ) : (
+                <Button
+                  variant="success"
+                  disabled={!settings?.apiKeyPresent || !!session}
+                  loading={busyAppId === a.id}
+                  title="Start a live interview grounded in this tailored resume + JD"
+                  onClick={() => void startInterview(a)}
+                >
+                  <PlayIcon /> Start interview
+                </Button>
+              )}
+              <Button variant="ghost" onClick={() => void openApp(a.id)}>
+                View
+              </Button>
+              {session?.jobId !== a.jobId && (
+                <Button
+                  variant="ghost"
+                  className="text-red-300"
+                  title="Delete this application (and its tailored grounding)"
+                  onClick={() => setConfirmDeleteId(a.id)}
+                >
+                  ✕
+                </Button>
+              )}
+            </>
           )}
-          <Button variant="ghost" onClick={() => void openApp(a.id)}>
-            View
-          </Button>
         </div>
       ),
     },
diff --git a/src/renderer/lib/wordDiff.test.ts b/src/renderer/lib/wordDiff.test.ts
new file mode 100644
index 0000000..2fa87ec
--- /dev/null
+++ b/src/renderer/lib/wordDiff.test.ts
@@ -0,0 +1,51 @@
+import { describe, it, expect } from 'vitest';
+import { wordDiff, type DiffSegment } from './wordDiff';
+
+const text = (segs: DiffSegment[], ops: string[]) =>
+  segs
+    .filter((s) => ops.includes(s.op))
+    .map((s) => s.text)
+    .join('');
+
+describe('wordDiff', () => {
+  it('marks identical text as one same segment per side', () => {
+    const d = wordDiff('led the team', 'led the team')!;
+    expect(d.base).toEqual([{ op: 'same', text: 'led the team ' }]);
+    expect(d.revised).toEqual([{ op: 'same', text: 'led the team ' }]);
+  });
+
+  it('marks a replacement as del (base) + add (revised) between same runs', () => {
+    const d = wordDiff('cut latency 20% at Acme', 'cut latency 40% at Acme')!;
+    expect(d.base.map((s) => s.op)).toEqual(['same', 'del', 'same']);
+    expect(text(d.base, ['del']).trim()).toBe('20%');
+    expect(d.revised.map((s) => s.op)).toEqual(['same', 'add', 'same']);
+    expect(text(d.revised, ['add']).trim()).toBe('40%');
+  });
+
+  it('handles pure additions and pure deletions', () => {
+    const add = wordDiff('built APIs', 'built scalable APIs')!;
+    expect(text(add.revised, ['add']).trim()).toBe('scalable');
+    expect(add.base.every((s) => s.op === 'same')).toBe(true);
+
+    const del = wordDiff('built scalable APIs', 'built APIs')!;
+    expect(text(del.base, ['del']).trim()).toBe('scalable');
+    expect(del.revised.every((s) => s.op === 'same')).toBe(true);
+  });
+
+  it('preserves newlines so paragraph structure survives rendering', () => {
+    const d = wordDiff('line one\nline two', 'line one\nline two')!;
+    expect(d.base[0].text).toContain('\n');
+    expect(text(d.base, ['same'])).toBe('line one \nline two ');
+  });
+
+  it('reconstructs each side fully from its segments (no lost words)', () => {
+    const d = wordDiff('a b c d', 'a x c y d z')!;
+    expect(text(d.base, ['same', 'del'])).toBe('a b c d ');
+    expect(text(d.revised, ['same', 'add'])).toBe('a x c y d z ');
+  });
+
+  it('returns null for inputs too large to diff (caller falls back)', () => {
+    const huge = 'word '.repeat(2100);
+    expect(wordDiff(huge, huge)).toBeNull();
+  });
+});
diff --git a/src/renderer/lib/wordDiff.ts b/src/renderer/lib/wordDiff.ts
new file mode 100644
index 0000000..ec8152b
--- /dev/null
+++ b/src/renderer/lib/wordDiff.ts
@@ -0,0 +1,80 @@
+// Dependency-free word-level diff (classic LCS) for the base-vs-tailored resume
+// comparison. Tokenizes into words + newlines so paragraph structure survives; each
+// side gets its own segment stream (base: same+del, revised: same+add) ready to
+// render side-by-side with highlights.
+
+export type DiffOp = 'same' | 'add' | 'del';
+export interface DiffSegment {
+  op: DiffOp;
+  text: string;
+}
+
+/** O(n·m) DP guard — beyond this the caller falls back to a plain side-by-side. */
+const MAX_CELLS = 4_000_000;
+
+function tokenize(text: string): string[] {
+  return text.match(/\n|\S+/g) ?? [];
+}
+
+/** Rendered form of a token: words carry a trailing space, newlines stay literal —
+ *  so concatenated segments read correctly inside a whitespace-pre-wrap container. */
+function rendered(token: string): string {
+  return token === '\n' ? '\n' : `${token} `;
+}
+
+function push(segs: DiffSegment[], op: DiffOp, token: string): void {
+  const text = rendered(token);
+  const last = segs[segs.length - 1];
+  if (last && last.op === op) last.text += text;
+  else segs.push({ op, text });
+}
+
+/**
+ * Word-level diff of two texts. Returns one segment stream per side (base marks
+ * deletions, revised marks additions; shared words are 'same' on both), or null
+ * when the inputs are too large to diff responsively.
+ */
+export function wordDiff(
+  base: string,
+  revised: string,
+): { base: DiffSegment[]; revised: DiffSegment[] } | null {
+  const a = tokenize(base);
+  const b = tokenize(revised);
+  const n = a.length;
+  const m = b.length;
+  if ((n + 1) * (m + 1) > MAX_CELLS) return null;
+
+  // LCS lengths, bottom-up. Values fit Uint16: max LCS = min(n,m) ≤ √MAX_CELLS ≈ 2000.
+  const w = m + 1;
+  const dp = new Uint16Array((n + 1) * w);
+  for (let i = n - 1; i >= 0; i--) {
+    for (let j = m - 1; j >= 0; j--) {
+      dp[i * w + j] =
+        a[i] === b[j]
+          ? dp[(i + 1) * w + j + 1] + 1
+          : Math.max(dp[(i + 1) * w + j], dp[i * w + j + 1]);
+    }
+  }
+
+  const baseSegs: DiffSegment[] = [];
+  const revisedSegs: DiffSegment[] = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) {
+      push(baseSegs, 'same', a[i]);
+      push(revisedSegs, 'same', b[j]);
+      i++;
+      j++;
+    } else if (dp[(i + 1) * w + j] >= dp[i * w + j + 1]) {
+      push(baseSegs, 'del', a[i]);
+      i++;
+    } else {
+      push(revisedSegs, 'add', b[j]);
+      j++;
+    }
+  }
+  while (i < n) push(baseSegs, 'del', a[i++]);
+  while (j < m) push(revisedSegs, 'add', b[j++]);
+  return { base: baseSegs, revised: revisedSegs };
+}

From 6b0e6131c1d2586e04831b2589ed4ad40a69d2b0 Mon Sep 17 00:00:00 2001
From: tpikachu <sjkunai@outlook.com>
Date: Thu, 2 Jul 2026 18:11:15 -0500
Subject: [PATCH 6/6] release: v1.3.0
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Package Tailor Resume into a versioned release: tailor a base resume × JD into an
ATS-friendly resume + grounded application answers, download as PDF, saved as
searchable Applications, per-row Start interview grounded in the TAILORED resume
+ JD, base-vs-tailored comparison, and smart profile reuse. Adds
changelog/1.3.0.md (drives APP_VERSION + in-app What's New) and bumps
package.json to 1.3.0.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 changelog/1.3.0.md | 40 ++++++++++++++++++++++++++++++++++++++++
 package.json       |  2 +-
 2 files changed, 41 insertions(+), 1 deletion(-)
 create mode 100644 changelog/1.3.0.md

diff --git a/changelog/1.3.0.md b/changelog/1.3.0.md
new file mode 100644
index 0000000..bc31ec5
--- /dev/null
+++ b/changelog/1.3.0.md
@@ -0,0 +1,40 @@
+# 1.3.0 — 2026-07-02
+
+This release closes the loop from **application to interview**: tailor your resume to a
+job, download it, apply — then interview against *exactly the resume you submitted*.
+
+## Added
+
+- **Tailor Resume.** A new page that turns your resume + a job description into a
+  complete application:
+  - Pick a **profile or upload/paste a resume** (PDF / DOCX / TXT / MD) as the base.
+  - Add the **job description** — paste it, upload a file, or fetch it from the posting URL.
+  - Optionally paste the **application questions** (one per line).
+  - One click produces an **ATS-friendly tailored resume** — reworded, reordered, and
+    keyword-matched to the JD, but grounded strictly in your real resume (nothing is ever
+    invented) — plus **grounded answers** to every application question.
+
+- **Download as PDF.** The tailored resume exports as a clean, single-column, standard-font
+  PDF built for ATS parsers — saved wherever you choose.
+
+- **Applications.** Every tailoring is saved as “*name* - *job title* at *company*” (the
+  title and company are read from the JD) in a dense, searchable table, newest first.
+
+- **Interview with your tailored resume.** **Start interview** on any application launches
+  a live session grounded in that application’s *tailored* resume + JD — the Cue Card
+  answers from what you actually submitted, not your generic base resume. Your notes and
+  STAR stories still apply.
+
+- **Compare with base.** See exactly what changed: a side-by-side view highlights what was
+  removed from your base resume and what was added or rewritten for the job.
+
+- **Smart profile reuse.** Uploading a resume creates a real, reusable profile — and
+  tailoring the same resume against more jobs reuses it (parsed once, no duplicates).
+
+## Under the hood
+
+- The tailoring call runs on the full-strength model (it writes your actual application
+  document), and nothing is persisted unless it succeeds. Indexing failures are recoverable
+  in-app via **Re-index**. Applications can be deleted from the row or the detail view —
+  guarded so you can’t delete the one a live interview is using. Every increment was
+  adversarially reviewed before merge; the unit-test suite grows to 137.
diff --git a/package.json b/package.json
index 2e4cd80..c92efc8 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "ai-interview-assistant",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "BrainCue Copilot — desktop AI interview copilot (Electron + React + OpenAI). Local-first data, BYO OpenAI key.",
   "author": "tpikachu",
   "license": "MIT",