careermate 0.0.7 → 0.0.9

package/packages/db/src/connection.ts

@@ -4,18 +4,86 @@
  * Both the web server and the MCP server import this. SQLite with WAL handles
  * the two-process concurrency (dashboard editing + AI writing) cleanly.
  */
+import fs from 'node:fs';
+import path from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
-import { getDbPath } from './paths.ts';
-import { migrate } from './schema.ts';
+import { getBackupsDir, getDbPath } from './paths.ts';
+import { migrate, MIGRATIONS } from './schema.ts';
 
 let _db: DatabaseSync | null = null;
 
+/** How many automatic pre-migration snapshots to keep (newest first). */
+const PRE_MIGRATE_KEEP = 5;
+
+/**
+ * `VACUUM INTO` a destination path, with the guard both backup callers need. The
+ * data dir can be set via env, so `destPath` isn't fully trusted: reject NUL/newline
+ * (can't be embedded safely in the SQL string literal) and single-quote-escape the
+ * rest. Throws on an unsafe path so the caller can fall back to fs.copyFileSync.
+ */
+export function vacuumInto(db: DatabaseSync, destPath: string): void {
+  if (/[\0\n\r]/.test(destPath)) throw new Error('backup path not safe for SQL literal');
+  db.exec(`VACUUM INTO '${destPath.replace(/'/g, "''")}'`);
+}
+
+/**
+ * Snapshot the DB into backups/ right before a schema upgrade runs. The DB is
+ * the user's only copy, so even though each migration is transactional, a bad
+ * migration shipped in an update must never be able to destroy data without a
+ * restore point. Best-effort: a failed backup logs to stderr but does not block
+ * boot (blocking would take both the dashboard and the MCP server down).
+ */
+function preMigrationBackup(db: DatabaseSync): void {
+  try {
+    const hasMeta = db
+      .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='_meta'`)
+      .get();
+    if (!hasMeta) return; // fresh file — nothing to protect yet
+    const row = db.prepare(`SELECT value FROM _meta WHERE key = 'schema_version'`).get() as
+      | { value: string }
+      | undefined;
+    const from = row ? Number(row.value) : 0;
+    if (from === 0 || from >= MIGRATIONS.length) return; // fresh, current, or newer — no upgrade will run
+
+    const dir = getBackupsDir();
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const dest = path.join(dir, `pre-migrate-v${from}-${stamp}.sqlite`);
+    try {
+      vacuumInto(db, dest);
+    } catch {
+      fs.copyFileSync(getDbPath(), dest); // WAL is checkpointed on close; copy is a coarse fallback
+    }
+
+    // Prune old snapshots (ISO stamp in the name → lexicographic sort == time sort).
+    // fs.unlinkSync only — rmSync hard-crashes on Node 25/Windows.
+    const stale = fs
+      .readdirSync(dir)
+      .filter((f) => f.startsWith('pre-migrate-') && f.endsWith('.sqlite'))
+      .sort()
+      .reverse()
+      .slice(PRE_MIGRATE_KEEP);
+    for (const f of stale) {
+      try {
+        fs.unlinkSync(path.join(dir, f));
+      } catch {
+        /* best-effort */
+      }
+    }
+  } catch (err) {
+    // stderr only — stdout is the MCP transport channel.
+    console.error(
+      `[careermate] 업그레이드 전 자동 백업 실패(마이그레이션은 계속 진행): ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+}
+
 export function getDb(): DatabaseSync {
   if (_db) return _db;
   const db = new DatabaseSync(getDbPath());
   db.exec('PRAGMA journal_mode = WAL;');
   db.exec('PRAGMA foreign_keys = ON;');
   db.exec('PRAGMA busy_timeout = 5000;');
+  preMigrationBackup(db);
   migrate(db);
   _db = db;
   return db;

package/packages/db/src/index.ts

@@ -19,6 +19,7 @@ export {
   fitRepo,
   applicationRepo,
   interviewRepo,
+  offerRepo,
   activityRepo,
   timelineRepo,
   getEntityCounts,

package/packages/db/src/repositories.ts

@@ -21,11 +21,14 @@ import {
   type CoverLetterVersionRecord,
   type JobInput,
   type JobRecord,
+  type OfferInput,
+  type OfferRecord,
   type FitAnalysisInput,
   type FitAnalysisRecord,
   type ApplicationInput,
   type ApplicationRecord,
   type ApplicationStatus,
+  type RejectedStage,
   type InterviewPrepInput,
   type InterviewPrepRecord,
   type ActivityRecord,
@@ -64,6 +67,10 @@ function mapProfile(r: any): ProfileRecord {
     preferred_tone: r.preferred_tone,
     emphasis_points: fromJson(r.emphasis_points, []),
     links: fromJson(r.links, []),
+    education: fromJson(r.education, []),
+    certifications: fromJson(r.certifications, []),
+    language_scores: fromJson(r.language_scores, []),
+    awards: fromJson(r.awards, []),
     created_at: r.created_at,
     updated_at: r.updated_at,
   };
@@ -92,21 +99,31 @@ export const profileRepo = {
       preferred_tone: input.preferred_tone ?? existing?.preferred_tone ?? null,
       emphasis_points: input.emphasis_points ?? existing?.emphasis_points ?? [],
       links: input.links ?? existing?.links ?? [],
+      education: input.education ?? existing?.education ?? [],
+      certifications: input.certifications ?? existing?.certifications ?? [],
+      language_scores: input.language_scores ?? existing?.language_scores ?? [],
+      awards: input.awards ?? existing?.awards ?? [],
       created_at: existing?.created_at ?? ts,
       updated_at: ts,
     };
     db.prepare(
-      `INSERT INTO profile (id,name,email,phone,location,headline,summary,desired_roles,desired_conditions,preferred_tone,emphasis_points,links,created_at,updated_at)
-       VALUES (@id,@name,@email,@phone,@location,@headline,@summary,@desired_roles,@desired_conditions,@preferred_tone,@emphasis_points,@links,@created_at,@updated_at)
+      `INSERT INTO profile (id,name,email,phone,location,headline,summary,desired_roles,desired_conditions,preferred_tone,emphasis_points,links,education,certifications,language_scores,awards,created_at,updated_at)
+       VALUES (@id,@name,@email,@phone,@location,@headline,@summary,@desired_roles,@desired_conditions,@preferred_tone,@emphasis_points,@links,@education,@certifications,@language_scores,@awards,@created_at,@updated_at)
        ON CONFLICT(id) DO UPDATE SET
          name=@name,email=@email,phone=@phone,location=@location,headline=@headline,summary=@summary,
          desired_roles=@desired_roles,desired_conditions=@desired_conditions,preferred_tone=@preferred_tone,
-         emphasis_points=@emphasis_points,links=@links,updated_at=@updated_at`,
+         emphasis_points=@emphasis_points,links=@links,
+         education=@education,certifications=@certifications,language_scores=@language_scores,awards=@awards,
+         updated_at=@updated_at`,
     ).run({
       ...merged,
       desired_roles: toJson(merged.desired_roles),
       emphasis_points: toJson(merged.emphasis_points),
       links: toJson(merged.links),
+      education: toJson(merged.education),
+      certifications: toJson(merged.certifications),
+      language_scores: toJson(merged.language_scores),
+      awards: toJson(merged.awards),
     });
     return merged;
   },
@@ -642,6 +659,12 @@ function mapJob(r: any): JobRecord {
     keywords: fromJson(r.keywords, []),
     deadline: r.deadline,
     source: r.source,
+    company_overview: r.company_overview ?? null,
+    talent_profile: r.talent_profile ?? null,
+    core_values: fromJson(r.core_values, []),
+    reputation: r.reputation ?? null,
+    questions: fromJson(r.questions, []),
+    schedule: fromJson(r.schedule, []),
     created_at: r.created_at,
     updated_at: r.updated_at,
   };
@@ -674,7 +697,7 @@ export const jobRepo = {
     if (existing) {
       const m = { ...existing, ...input } as JobRecord;
       db.prepare(
-        `UPDATE jobs SET company=?,position=?,url=?,location=?,employment_type=?,description=?,requirements=?,keywords=?,deadline=?,source=?,updated_at=? WHERE id=?`,
+        `UPDATE jobs SET company=?,position=?,url=?,location=?,employment_type=?,description=?,requirements=?,keywords=?,deadline=?,source=?,company_overview=?,talent_profile=?,core_values=?,reputation=?,questions=?,schedule=?,updated_at=? WHERE id=?`,
       ).run(
         m.company,
         m.position,
@@ -686,6 +709,15 @@ export const jobRepo = {
         toJson(m.keywords ?? []),
         m.deadline ?? null,
         m.source ?? null,
+        m.company_overview ?? null,
+        m.talent_profile ?? null,
+        toJson(m.core_values ?? []),
+        m.reputation ?? null,
+        // questions omitted from input → m keeps existing.questions (preserved);
+        // provided → replaced. Same merge semantics as the other JSON fields.
+        toJson(m.questions ?? []),
+        // schedule follows the same preserve-on-omit merge (v11 전형 일정).
+        toJson(m.schedule ?? []),
         ts,
         existing.id,
       );
@@ -693,8 +725,8 @@ export const jobRepo = {
     }
     const newJobId = id ?? newId('job_');
     db.prepare(
-      `INSERT INTO jobs (id,company,position,url,location,employment_type,description,requirements,keywords,deadline,source,created_at,updated_at)
-       VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)`,
+      `INSERT INTO jobs (id,company,position,url,location,employment_type,description,requirements,keywords,deadline,source,company_overview,talent_profile,core_values,reputation,questions,schedule,created_at,updated_at)
+       VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`,
     ).run(
       newJobId,
       input.company,
@@ -707,6 +739,12 @@ export const jobRepo = {
       toJson(input.keywords ?? []),
       input.deadline ?? null,
       input.source ?? null,
+      input.company_overview ?? null,
+      input.talent_profile ?? null,
+      toJson(input.core_values ?? []),
+      input.reputation ?? null,
+      toJson(input.questions ?? []),
+      toJson(input.schedule ?? []),
       ts,
       ts,
     );
@@ -721,6 +759,9 @@ export const jobRepo = {
       db.prepare(`DELETE FROM applications WHERE job_id=?`).run(id);
       db.prepare(`DELETE FROM interview_preps WHERE job_id=?`).run(id);
       db.prepare(`DELETE FROM application_timeline_events WHERE job_id=?`).run(id);
+      // offers has ON DELETE CASCADE, but delete explicitly like the siblings above
+      // (consistent pattern + safe even if PRAGMA foreign_keys is ever off).
+      db.prepare(`DELETE FROM offers WHERE job_id=?`).run(id);
       return db.prepare(`DELETE FROM jobs WHERE id=?`).run(id).changes > 0;
     });
   },
@@ -804,6 +845,8 @@ function mapApplication(r: any): ApplicationRecord {
     cover_letter_id: r.cover_letter_id,
     applied_at: r.applied_at,
     notes: r.notes,
+    // 탈락 회고: 탈락이 아니거나 미기록이면 NULL(v10 이전 DB는 컬럼이 없어 undefined → null 정규화).
+    rejected_stage: r.rejected_stage ?? null,
     created_at: r.created_at,
     updated_at: r.updated_at,
   };
@@ -846,25 +889,39 @@ export const applicationRepo = {
     // A status change through upsert must respect the same lifecycle gate as setStatus.
     if (input.status && input.status !== app.status) assertStatusTransition(app.status, input.status);
     const m = { ...app, ...input } as ApplicationRecord;
+    // rejected_stage is only meaningful while status is 'rejected' (same invariant as
+    // setStatus): clear it on any transition back out, preserve it when staying
+    // rejected. ApplicationInput carries no rejected_stage, so m keeps the stored value.
+    const rejectedStageValue = m.status === 'rejected' ? m.rejected_stage ?? null : null;
     getDb()
       .prepare(
-        `UPDATE applications SET status=?,resume_id=?,cover_letter_id=?,applied_at=?,notes=?,updated_at=? WHERE id=?`,
+        `UPDATE applications SET status=?,resume_id=?,cover_letter_id=?,applied_at=?,notes=?,rejected_stage=?,updated_at=? WHERE id=?`,
       )
       // Coerce undefined → null: node:sqlite rejects undefined bindings, and a
       // caller that spreads explicit `undefined` fields (e.g. updateApplicationStatus
       // with a doc-less submission) would otherwise crash here mid-write.
-      .run(m.status, m.resume_id ?? null, m.cover_letter_id ?? null, m.applied_at ?? null, m.notes ?? null, now(), app.id);
+      .run(m.status, m.resume_id ?? null, m.cover_letter_id ?? null, m.applied_at ?? null, m.notes ?? null, rejectedStageValue, now(), app.id);
     return this.get(app.id)!;
   },
-  setStatus(jobId: string, status: ApplicationStatus, note?: string): ApplicationRecord {
+  setStatus(
+    jobId: string,
+    status: ApplicationStatus,
+    note?: string,
+    rejectedStage?: RejectedStage,
+  ): ApplicationRecord {
     const app = this.ensure(jobId);
     assertStatusTransition(app.status, status);
     const appliedAt =
       status === 'applied' && !app.applied_at ? now() : app.applied_at;
     const notes = note ? [app.notes, note].filter(Boolean).join('\n') : app.notes;
+    // 탈락 회고: 'rejected'일 때만 단계를 저장한다. 명시 값이 오면 갱신하고, 없으면 기존 값을
+    // 보존해(같은 rejected에 메모만 추가하는 등) 이미 남긴 회고를 지우지 않는다. rejected에서 다른
+    // 상태로 되살아나면 NULL로 초기화한다(정합성 — 탈락이 아닌데 단계가 남아 있으면 안 됨).
+    const rejectedStageValue =
+      status === 'rejected' ? rejectedStage ?? app.rejected_stage ?? null : null;
     getDb()
-      .prepare(`UPDATE applications SET status=?, applied_at=?, notes=?, updated_at=? WHERE id=?`)
-      .run(status, appliedAt, notes, now(), app.id);
+      .prepare(`UPDATE applications SET status=?, applied_at=?, notes=?, rejected_stage=?, updated_at=? WHERE id=?`)
+      .run(status, appliedAt, notes, rejectedStageValue, now(), app.id);
     return this.get(app.id)!;
   },
 };
@@ -872,6 +929,9 @@ export const applicationRepo = {
 /* --------------------------------------------------------- Interview preps */
 
 function mapInterviewPrep(r: any): InterviewPrepRecord {
+  // debrief defaults to '{}' at the DB level; surface an empty debrief as null so
+  // consumers can treat "no debrief yet" uniformly.
+  const debrief = fromJson(r.debrief, null);
   return {
     id: r.id,
     job_id: r.job_id,
@@ -879,6 +939,7 @@ function mapInterviewPrep(r: any): InterviewPrepRecord {
     star_guides: fromJson(r.star_guides, []),
     self_introduction: r.self_introduction,
     notes: r.notes,
+    debrief: debrief && Object.keys(debrief).length ? debrief : null,
     created_at: r.created_at,
     updated_at: r.updated_at,
   };
@@ -900,13 +961,19 @@ export const interviewRepo = {
     const ts = now();
     if (existing) {
       const m = { ...existing, ...input } as InterviewPrepRecord;
+      // Debrief is shallow-merged (not replaced) so a later partial debrief save
+      // doesn't wipe earlier fields; prep (pre) and debrief (post) coexist per job.
+      const mergedDebrief = input.debrief
+        ? { ...(existing.debrief ?? {}), ...input.debrief }
+        : existing.debrief;
       db.prepare(
-        `UPDATE interview_preps SET questions=?,star_guides=?,self_introduction=?,notes=?,updated_at=? WHERE id=?`,
+        `UPDATE interview_preps SET questions=?,star_guides=?,self_introduction=?,notes=?,debrief=?,updated_at=? WHERE id=?`,
       ).run(
         toJson(m.questions ?? []),
         toJson(m.star_guides ?? []),
         m.self_introduction ?? null,
         m.notes ?? null,
+        toJson(mergedDebrief ?? {}),
         ts,
         existing.id,
       );
@@ -914,7 +981,7 @@ export const interviewRepo = {
     }
     const id = newId('itv_');
     db.prepare(
-      `INSERT INTO interview_preps (id,job_id,questions,star_guides,self_introduction,notes,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?)`,
+      `INSERT INTO interview_preps (id,job_id,questions,star_guides,self_introduction,notes,debrief,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?)`,
     ).run(
       id,
       input.job_id,
@@ -922,6 +989,7 @@ export const interviewRepo = {
       toJson(input.star_guides ?? []),
       input.self_introduction ?? null,
       input.notes ?? null,
+      toJson(input.debrief ?? {}),
       ts,
       ts,
     );
@@ -1001,6 +1069,102 @@ export const timelineRepo = {
   },
 };
 
+/* -------------------------------------------------------------------- Offers */
+
+function mapOffer(r: any): OfferRecord {
+  const base = r.base_salary ?? null;
+  const bonus = r.bonus_amount ?? null;
+  const welfare = r.welfare_amount ?? null;
+  // Annual cash estimate = base + bonus + welfare (signing is one-time → excluded).
+  // null when no numeric cash piece was provided (can't estimate).
+  const hasAny = base != null || bonus != null || welfare != null;
+  const total = hasAny ? (base ?? 0) + (bonus ?? 0) + (welfare ?? 0) : null;
+  return {
+    id: r.id,
+    job_id: r.job_id,
+    offer_status: r.offer_status ?? 'open',
+    base_salary: base,
+    bonus_amount: bonus,
+    welfare_amount: welfare,
+    signing_amount: r.signing_amount ?? null,
+    equity_note: r.equity_note ?? null,
+    comp_note: r.comp_note ?? null,
+    work_arrangement: r.work_arrangement ?? null,
+    contract_type: r.contract_type ?? null,
+    accept_deadline: r.accept_deadline ?? null,
+    ai_score: r.ai_score ?? null,
+    verdict: r.verdict ?? null,
+    notes: r.notes ?? null,
+    total_comp_annual_est: total,
+    created_at: r.created_at,
+    updated_at: r.updated_at,
+  };
+}
+
+export const offerRepo = {
+  getByJob(jobId: string): OfferRecord | null {
+    const r = getDb().prepare(`SELECT * FROM offers WHERE job_id=?`).get(jobId);
+    return r ? mapOffer(r) : null;
+  },
+  list(): OfferRecord[] {
+    return (getDb().prepare(`SELECT * FROM offers ORDER BY ai_score IS NULL, ai_score DESC, updated_at DESC`).all() as any[]).map(mapOffer);
+  },
+  /** Upsert by job_id (one offer per job). Missing fields are preserved on update (partial-safe). */
+  save(input: OfferInput): OfferRecord {
+    const db = getDb();
+    const existing = this.getByJob(input.job_id);
+    const ts = now();
+    const n = (v: number | undefined, prev: number | null | undefined) => (v ?? prev ?? null);
+    const s = (v: string | undefined, prev: string | null | undefined) => (v ?? prev ?? null);
+    if (existing) {
+      db.prepare(
+        `UPDATE offers SET offer_status=?,base_salary=?,bonus_amount=?,welfare_amount=?,signing_amount=?,equity_note=?,comp_note=?,work_arrangement=?,contract_type=?,accept_deadline=?,ai_score=?,verdict=?,notes=?,updated_at=? WHERE id=?`,
+      ).run(
+        input.offer_status ?? existing.offer_status,
+        n(input.base_salary, existing.base_salary),
+        n(input.bonus_amount, existing.bonus_amount),
+        n(input.welfare_amount, existing.welfare_amount),
+        n(input.signing_amount, existing.signing_amount),
+        s(input.equity_note, existing.equity_note),
+        s(input.comp_note, existing.comp_note),
+        s(input.work_arrangement, existing.work_arrangement),
+        s(input.contract_type, existing.contract_type),
+        s(input.accept_deadline, existing.accept_deadline),
+        n(input.ai_score, existing.ai_score),
+        s(input.verdict, existing.verdict),
+        s(input.notes, existing.notes),
+        ts,
+        existing.id,
+      );
+      return this.getByJob(input.job_id)!;
+    }
+    const id = newId('ofr_');
+    db.prepare(
+      `INSERT INTO offers (id,job_id,offer_status,base_salary,bonus_amount,welfare_amount,signing_amount,equity_note,comp_note,work_arrangement,contract_type,accept_deadline,ai_score,verdict,notes,created_at,updated_at)
+       VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`,
+    ).run(
+      id,
+      input.job_id,
+      input.offer_status ?? 'open',
+      input.base_salary ?? null,
+      input.bonus_amount ?? null,
+      input.welfare_amount ?? null,
+      input.signing_amount ?? null,
+      input.equity_note ?? null,
+      input.comp_note ?? null,
+      input.work_arrangement ?? null,
+      input.contract_type ?? null,
+      input.accept_deadline ?? null,
+      input.ai_score ?? null,
+      input.verdict ?? null,
+      input.notes ?? null,
+      ts,
+      ts,
+    );
+    return this.getByJob(input.job_id)!;
+  },
+};
+
 /* ------------------------------------------------------------------ Counts */
 
 /**
@@ -1024,6 +1188,7 @@ export function getEntityCounts(): Record<string, number> {
     'applications',
     'interview_preps',
     'application_timeline_events',
+    'offers',
   ]);
   const c = (t: string): number => {
     if (!ALLOWED_TABLES.has(t)) throw new Error(`getEntityCounts: 허용되지 않은 테이블 이름: ${t}`);
@@ -1040,5 +1205,6 @@ export function getEntityCounts(): Record<string, number> {
     applications: c('applications'),
     interview_preps: c('interview_preps'),
     application_timeline_events: c('application_timeline_events'),
+    offers: c('offers'),
   };
 }

package/packages/db/src/schema.ts

@@ -5,6 +5,16 @@
  * in `_meta`. Applying is idempotent and safe to run on every process start, so
  * both the web server and the MCP server can call `migrate()` on boot and share
  * the same database file without coordination.
+ *
+ * Crash safety (this DB is the user's only copy):
+ *  - Each migration runs in its own transaction and `schema_version` is stamped
+ *    inside that same transaction, so a step either fully applies (including its
+ *    version bump) or fully rolls back — a process death mid-upgrade can never
+ *    leave "applied but unrecorded" work that re-throws on the next boot.
+ *  - `ALTER TABLE … ADD COLUMN` statements are skipped when the column already
+ *    exists (SQLite has no IF NOT EXISTS for columns), so a DB damaged by the
+ *    pre-hardening runner self-heals instead of crash-looping on boot.
+ *  - A DB stamped by a NEWER CareerMate is left untouched (never stamped down).
  */
 import type { DatabaseSync } from 'node:sqlite';
 
@@ -300,6 +310,96 @@ export const MIGRATIONS: string[] = [
 
   CREATE INDEX IF NOT EXISTS idx_timeline_job ON application_timeline_events(job_id, occurred_at ASC);
   `,
+
+  // v4 — structured quantitative credentials on the profile (학력·자격증·어학점수·수상).
+  // Stored as JSON arrays in TEXT columns (same pattern as profile.links), so the AI
+  // can cite exact values (GPA, TOEIC 920) without re-asking or hallucinating, and
+  // they feed the verify corpus. ALTER ADD COLUMN is non-destructive and idempotent
+  // across the ordered migration runner.
+  `
+  ALTER TABLE profile ADD COLUMN education TEXT NOT NULL DEFAULT '[]';
+  ALTER TABLE profile ADD COLUMN certifications TEXT NOT NULL DEFAULT '[]';
+  ALTER TABLE profile ADD COLUMN language_scores TEXT NOT NULL DEFAULT '[]';
+  ALTER TABLE profile ADD COLUMN awards TEXT NOT NULL DEFAULT '[]';
+  `,
+
+  // v5 — company research on the job posting (사업개요·인재상·핵심가치). Korea-centric: cover
+  // letters and interview prep align to a company's 인재상/핵심가치, so store it where the AI
+  // already reads it (the job context) rather than a separate entity. Additive ALTER, idempotent.
+  `
+  ALTER TABLE jobs ADD COLUMN company_overview TEXT;
+  ALTER TABLE jobs ADD COLUMN talent_profile TEXT;
+  ALTER TABLE jobs ADD COLUMN core_values TEXT NOT NULL DEFAULT '[]';
+  `,
+
+  // v6 — post-interview debrief on interview_preps (받은 질문·잘된 점·개선점·다음 라운드 포커스·
+  // 체감 분위기). Closes the loop: prep is pre-interview, debrief is post-interview, but both belong
+  // to the same per-job entity, so store as one JSON column rather than a new table. Additive ALTER,
+  // idempotent. Feeds next-round prep and consistency (lessons carry into later interviews).
+  `
+  ALTER TABLE interview_preps ADD COLUMN debrief TEXT NOT NULL DEFAULT '{}';
+  `,
+
+  // v7 — offer comparison (한국 총보상 필드) + company reputation research field on jobs.
+  // offers: one per job (UNIQUE job_id, mirrors interview_preps). Cash pieces are numeric (만원) so
+  // the server can deterministically sum an annual estimate; equity/other stay free-text (comp is
+  // messy). ai_score/verdict are written by the connected AI at save time (no LLM here) and rendered
+  // by the dashboard, so it never needs to call an LLM. jobs.reputation: AI-researched company
+  // reputation summary (same pattern as company_overview) — feeds offer verdicts + offer-evaluation.
+  `
+  CREATE TABLE IF NOT EXISTS offers (
+    id TEXT PRIMARY KEY,
+    job_id TEXT NOT NULL UNIQUE REFERENCES jobs(id) ON DELETE CASCADE,
+    base_salary INTEGER,
+    bonus_amount INTEGER,
+    welfare_amount INTEGER,
+    signing_amount INTEGER,
+    equity_note TEXT,
+    comp_note TEXT,
+    work_arrangement TEXT,
+    contract_type TEXT,
+    accept_deadline TEXT,
+    ai_score INTEGER,
+    verdict TEXT,
+    notes TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_offers_job ON offers(job_id);
+  ALTER TABLE jobs ADD COLUMN reputation TEXT;
+  `,
+
+  // v8 — offer lifecycle status. 지원 상태(전형 깔때기 = 회사의 프로세스)와 직교하는
+  // "내 응답" 축: open(진행)/accepted(수락)/declined(거절). declined여도 행을 지우지
+  // 않는다 — 조건(연봉·처우) 히스토리는 다음 협상의 자산이라, 대시보드가 접힌
+  // '지난 오퍼'로 강등해 보여줄 뿐이다. Additive ALTER (runner가 멱등 처리).
+  `
+  ALTER TABLE offers ADD COLUMN offer_status TEXT NOT NULL DEFAULT 'open';
+  `,
+
+  // v9 — 한국 문항형 자소서: 회사가 지정한 문항·글자수를 공고에 구조화 보관. 한국 자소서는
+  // 회사별 문항형(항목·글자수 제한)이 지배적이라, AI가 문항별로 답변을 쓰고 글자수를 점검할 때
+  // 참조할 원본을 공고 옆에 둔다(별도 엔티티가 아니라 job 컨텍스트에 함께 실린다). JSON 배열을
+  // TEXT에 저장(다른 JSON 필드와 동일). Additive ALTER (runner가 멱등 처리).
+  `
+  ALTER TABLE jobs ADD COLUMN questions TEXT NOT NULL DEFAULT '[]';
+  `,
+
+  // v10 — 탈락 회고: 어느 전형 단계에서 떨어졌는지 자가 기록. 탈락 사유를 고지하는 기업은 6%뿐이고
+  // 지원자 83%가 알고 싶어하므로, 이 자가 기록이 "서류는 붙는데 면접에서 떨어진다" 같은 패턴을 로컬
+  // 데이터로 드러내는 유일한 신호다. 탈락이 아니거나 미기록이면 NULL. Additive ALTER (runner가 멱등 처리).
+  `
+  ALTER TABLE applications ADD COLUMN rejected_stage TEXT;
+  `,
+
+  // v11 — 전형 일정: 서류마감→인적성·AI역검→1·2차 면접→발표로 이어지는 단계별 날짜를 공고에
+  // 구조화 보관. 일정을 jobs에 두는 이유: 서류마감(deadline)이 이미 jobs에 있고, save_job_posting
+  // 업서트를 그대로 재사용해 도구 신설 없이 갱신할 수 있다. 면접초대 메일·발표 공지를 사용자가
+  // 붙여넣으면 AI가 날짜를 추출해 저장하고, 서버가 D-day·같은 날짜 충돌을 결정론으로 계산한다.
+  // JSON 배열을 TEXT에 저장(다른 JSON 필드와 동일). Additive ALTER (runner가 멱등 처리).
+  `
+  ALTER TABLE jobs ADD COLUMN schedule TEXT NOT NULL DEFAULT '[]';
+  `,
 ];
 
 export function migrate(db: DatabaseSync): { from: number; to: number } {
@@ -309,16 +409,77 @@ export function migrate(db: DatabaseSync): { from: number; to: number } {
     | undefined;
   const from = row ? Number(row.value) : 0;
 
+  // DB stamped by a newer CareerMate than this code: leave it alone. Stamping it
+  // back down would make the newer app re-run migrations it already applied.
+  if (from >= MIGRATIONS.length) return { from, to: from };
+
   for (let v = from; v < MIGRATIONS.length; v++) {
-    db.exec(MIGRATIONS[v]!);
+    applyMigration(db, v);
+  }
+  return { from, to: MIGRATIONS.length };
+}
+
+function stampVersion(db: DatabaseSync, version: number): void {
+  db.prepare(
+    `INSERT INTO _meta (key, value) VALUES ('schema_version', ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`,
+  ).run(String(version));
+}
+
+function columnExists(db: DatabaseSync, table: string, column: string): boolean {
+  const rows = db
+    .prepare(`PRAGMA table_info("${table.replaceAll('"', '""')}")`)
+    .all() as Array<{ name: string }>;
+  return rows.some((r) => r.name === column);
+}
+
+// Migrations that manage their own BEGIN/COMMIT, by zero-based index into MIGRATIONS.
+// Only v2 (index 1) does: its FK rebuild toggles PRAGMA foreign_keys, a no-op inside
+// an open transaction, so the runner must NOT wrap it. Register any future
+// self-transactional migration here (a plain `sql.includes('BEGIN;')` sniff would
+// misfire if a normal migration ever contained the substring, e.g. in a comment).
+const SELF_TRANSACTIONAL_MIGRATIONS = new Set<number>([1]);
+
+// Style contract for column-adding migrations: every `ALTER TABLE <t> ADD COLUMN <c>
+// …;` MUST be a single statement on its own line so this regex can find it and the
+// idempotent-runner can drop it when the column already exists. A multi-column or
+// inline-with-other-DDL ALTER would slip past skipExistingColumns and crash a
+// partial-migration re-run. scripts/test-migrate.ts guards this with a count check
+// (loose ALTER…ADD COLUMN scan === strict per-line matches). Keep new ALTERs one-per-line.
+const ALTER_ADD_COLUMN_RE = /^[ \t]*ALTER TABLE\s+(\w+)\s+ADD COLUMN\s+(\w+)[^;]*;[ \t]*$/gm;
+export { ALTER_ADD_COLUMN_RE };
+
+/** Drop ADD COLUMN statements whose column already exists (idempotent re-run). */
+function skipExistingColumns(db: DatabaseSync, sql: string): string {
+  return sql.replace(ALTER_ADD_COLUMN_RE, (stmt, table: string, column: string) =>
+    columnExists(db, table, column) ? '' : stmt,
+  );
+}
+
+function applyMigration(db: DatabaseSync, v: number): void {
+  const sql = MIGRATIONS[v]!;
+
+  if (SELF_TRANSACTIONAL_MIGRATIONS.has(v)) {
+    // Self-transactional migration (v2 toggles PRAGMA foreign_keys, which is a
+    // no-op inside an open transaction, so it must manage BEGIN/COMMIT itself).
+    // Stamp right after; if the process dies in the tiny window between the two
+    // statements, re-running the rebuild is safe (it copies the data again).
+    db.exec(sql);
+    stampVersion(db, v + 1);
+    return;
   }
 
-  const to = MIGRATIONS.length;
-  if (to !== from) {
-    db.prepare(
-      `INSERT INTO _meta (key, value) VALUES ('schema_version', ?)
-       ON CONFLICT(key) DO UPDATE SET value = excluded.value`,
-    ).run(String(to));
+  db.exec('BEGIN');
+  try {
+    db.exec(skipExistingColumns(db, sql));
+    stampVersion(db, v + 1);
+    db.exec('COMMIT');
+  } catch (err) {
+    try {
+      db.exec('ROLLBACK');
+    } catch {
+      /* surface the original error */
+    }
+    throw err;
   }
-  return { from, to };
 }