careermate 0.0.7 → 0.0.8

package/packages/core/src/summary.ts

@@ -18,6 +18,10 @@ import {
   interviewRepo,
   fitRepo,
   activityRepo,
+  skillRepo,
+  experienceRepo,
+  projectRepo,
+  timelineRepo,
 } from '@careermate/db';
 import { getOnboardingStatus } from './onboarding.ts';
 
@@ -160,3 +164,195 @@ export function getHomeSummary(now: Date = new Date()): HomeSummary {
 export function listRecentActivity(limit = 20): ActivityRecord[] {
   return activityRepo.recent(limit);
 }
+
+/* ----------------------------------------------------------- action digest */
+
+// Follow-up is the #1 thing trackers drop (community research): applications go
+// stale and the user forgets to nudge. The dashboard Home already surfaces this,
+// but the AI agent — the primary interface — couldn't see it. getActionDigest
+// exposes the same "what needs my attention now" intelligence to MCP, broadened
+// past 'applied' to the other waiting states (post-pass scheduling, post-interview
+// result). Read-only; thresholds are advisory nudges, not hard rules.
+const POST_PASS_STALE_DAYS = 7; // document_passed → interview scheduling wait
+const POST_INTERVIEW_STALE_DAYS = 7; // interview → result wait
+
+export interface FollowupItem {
+  job: JobRecord;
+  status: ApplicationStatus;
+  status_label: string;
+  days_since: number;
+  reason: string;
+}
+
+export interface ActionDigest {
+  /** Server's today (YYYY-MM-DD) — the AI can't reliably know the current date. */
+  today: string;
+  followups: FollowupItem[];
+  deadlines: { job: JobRecord; status: ApplicationStatus; status_label: string; days_left: number }[];
+  interview_todo: { job: JobRecord; status_label: string }[];
+}
+
+/**
+ * "What needs attention now" for the AI agent: stale applications awaiting a
+ * response (so the user can decide whether to follow up), upcoming/overdue
+ * deadlines, and passed stages still missing interview prep. All read-only.
+ */
+export function getActionDigest(now: Date = new Date()): ActionDigest {
+  const applications = applicationRepo.list();
+  const jobs = jobRepo.list();
+  const statusByJob = new Map(applications.map((a) => [a.job_id, a]));
+
+  const followups: FollowupItem[] = [];
+  for (const a of applications) {
+    const job = jobRepo.get(a.job_id);
+    if (!job) continue;
+    if (a.status === 'applied') {
+      const days = daysSinceTimestamp(a.applied_at, now);
+      if (days != null && days >= FOLLOWUP_STALE_DAYS)
+        followups.push({ job, status: a.status, status_label: APPLICATION_STATUS_LABELS[a.status], days_since: days, reason: `지원 후 ${days}일째 응답 없음 — 정중한 후속 문의를 고려할 시점` });
+    } else if (a.status === 'document_passed') {
+      const days = daysSinceTimestamp(a.updated_at, now);
+      if (days != null && days >= POST_PASS_STALE_DAYS)
+        followups.push({ job, status: a.status, status_label: APPLICATION_STATUS_LABELS[a.status], days_since: days, reason: `서류 합격 후 ${days}일째 면접 일정 대기` });
+    } else if (a.status === 'interview') {
+      const days = daysSinceTimestamp(a.updated_at, now);
+      if (days != null && days >= POST_INTERVIEW_STALE_DAYS)
+        followups.push({ job, status: a.status, status_label: APPLICATION_STATUS_LABELS[a.status], days_since: days, reason: `면접 후 ${days}일째 결과 대기` });
+    }
+  }
+  followups.sort((a, b) => b.days_since - a.days_since);
+
+  const deadlines = jobs
+    .map((job) => {
+      const status = statusByJob.get(job.id)?.status ?? 'draft';
+      if (!DEADLINE_ACTIONABLE.includes(status)) return null;
+      const days_left = daysUntilDate(job.deadline, now);
+      if (days_left == null || days_left > DEADLINE_SOON_DAYS) return null;
+      return { job, status, status_label: APPLICATION_STATUS_LABELS[status], days_left };
+    })
+    .filter((x): x is { job: JobRecord; status: ApplicationStatus; status_label: string; days_left: number } => x !== null)
+    .sort((a, b) => a.days_left - b.days_left);
+
+  const interview_todo = applications
+    .filter((a) => INTERVIEW_UNLOCK_STATUSES.includes(a.status) && !interviewRepo.getByJob(a.job_id))
+    .map((a) => {
+      const job = jobRepo.get(a.job_id);
+      return job ? { job, status_label: APPLICATION_STATUS_LABELS[a.status] } : null;
+    })
+    .filter((x): x is { job: JobRecord; status_label: string } => x !== null);
+
+  const today = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
+  return { today, followups, deadlines, interview_todo };
+}
+
+/* ---------------------------------------------------------- job pre-screen */
+
+// "Should I even bother reading this JD?" — community research U3: ~70% of postings
+// prove unsuitable after reading. This is a CHEAP, DETERMINISTIC keyword-overlap
+// signal (same philosophy as charcount: count, don't judge). The real fit analysis
+// is still the AI's job via save_fit_analysis — this only pre-filters by which job
+// keywords the user's stored skills/tech already cover.
+
+const normToken = (s: string): string =>
+  s.toLowerCase().trim().replace(/^[.,/()\s]+|[.,/()\s]+$/g, '');
+
+export interface JobPrescreen {
+  job_id: string;
+  job_keywords: string[];
+  matched: string[];
+  missing: string[];
+  /** matched / total keywords (0..1); null when the job has no keywords to screen. */
+  coverage: number | null;
+  user_skill_count: number;
+}
+
+export function prescreenJob(jobId: string): JobPrescreen | null {
+  const job = jobRepo.get(jobId);
+  if (!job) return null;
+  const userTokens = new Set<string>();
+  for (const s of skillRepo.list()) if (s.name) userTokens.add(normToken(s.name));
+  for (const e of experienceRepo.list()) for (const t of e.tech ?? []) userTokens.add(normToken(t));
+  for (const p of projectRepo.list()) for (const t of p.tech ?? []) userTokens.add(normToken(t));
+  userTokens.delete('');
+
+  const keywords = (job.keywords ?? []).filter((k) => k && k.trim());
+  const matched: string[] = [];
+  const missing: string[] = [];
+  for (const kw of keywords) {
+    const n = normToken(kw);
+    const hit =
+      userTokens.has(n) ||
+      // substring match only for tokens ≥3 chars (avoid "c"/"r" matching everything).
+      (n.length >= 3 && [...userTokens].some((u) => u.length >= 3 && (u.includes(n) || n.includes(u))));
+    (hit ? matched : missing).push(kw);
+  }
+  const coverage = keywords.length ? matched.length / keywords.length : null;
+  return { job_id: jobId, job_keywords: keywords, matched, missing, coverage, user_skill_count: userTokens.size };
+}
+
+/* ----------------------------------------------------------- pipeline stats */
+
+// Application analytics (community U1: "what's my response rate?"). A TRUE
+// ever-reached funnel, not a current-status snapshot: status transitions are
+// logged to the timeline (application_status_changed events), so a job currently
+// 'rejected' still counts toward the furthest stage it reached. Descriptive only
+// — with small N these rates are not predictive; the tool surfaces that caveat.
+const PROGRESSION: ApplicationStatus[] = ['applied', 'document_passed', 'interview', 'final_passed'];
+
+export interface PipelineStats {
+  total: number;
+  /** Current-status snapshot (where each application sits right now). */
+  by_status: { status: ApplicationStatus; label: string; count: number }[];
+  /** Ever-reached counts (reconstructed from the status-change timeline). */
+  funnel: { applied: number; document_passed: number; interview: number; final_passed: number };
+  /** Pass-through rates relative to "ever applied" (percent, 1 d.p.); null when denominator is 0. */
+  rates: { document_pass: number | null; interview: number | null; offer: number | null };
+  outcomes: { final_passed: number; rejected: number; in_progress: number; on_hold: number };
+  note: string;
+}
+
+export function getPipelineStats(): PipelineStats {
+  const applications = applicationRepo.list();
+  const by_status = (Object.keys(APPLICATION_STATUS_LABELS) as ApplicationStatus[]).map((status) => ({
+    status,
+    label: APPLICATION_STATUS_LABELS[status],
+    count: applications.filter((a) => a.status === status).length,
+  }));
+
+  let appliedN = 0, docN = 0, intN = 0, offerN = 0;
+  for (const a of applications) {
+    const reached = new Set<string>([a.status]);
+    if (a.applied_at) reached.add('applied');
+    for (const e of timelineRepo.listByJob(a.job_id)) {
+      if (e.type !== 'application_status_changed') continue;
+      const p = (e.payload ?? {}) as { status?: string; from_status?: string };
+      if (p.status) reached.add(p.status);
+      if (p.from_status) reached.add(p.from_status);
+    }
+    let maxStage = -1;
+    for (const s of reached) maxStage = Math.max(maxStage, PROGRESSION.indexOf(s as ApplicationStatus));
+    if (maxStage >= 0) appliedN++;
+    if (maxStage >= 1) docN++;
+    if (maxStage >= 2) intN++;
+    if (maxStage >= 3) offerN++;
+  }
+
+  const pct = (n: number, d: number): number | null => (d > 0 ? Math.round((n / d) * 1000) / 10 : null);
+  const cur = (s: ApplicationStatus) => applications.filter((a) => a.status === s).length;
+
+  return {
+    total: applications.length,
+    by_status,
+    funnel: { applied: appliedN, document_passed: docN, interview: intN, final_passed: offerN },
+    rates: { document_pass: pct(docN, appliedN), interview: pct(intN, appliedN), offer: pct(offerN, appliedN) },
+    outcomes: {
+      final_passed: cur('final_passed'),
+      rejected: cur('rejected'),
+      in_progress: cur('applied') + cur('document_passed') + cur('interview'),
+      on_hold: cur('on_hold'),
+    },
+    note:
+      '단계별 도달 깔때기는 상태 변경 이력(타임라인)으로 복원한 실측치입니다(현재 rejected여도 거쳐간 최고 단계까지 집계). ' +
+      '비율은 설명용이며 표본이 작으면 예측력이 낮습니다 — 추세 참고로만 쓰세요.',
+  };
+}

package/packages/core/src/verify/charcount.ts

@@ -0,0 +1,87 @@
+/**
+ * Deterministic character counting for Korean cover letters — the thing a chatbot
+ * cannot do reliably. Korean 문항형 자소서 grade on per-question length limits, and
+ * the counting rule (with-space / no-space / byte) varies by company; getting it
+ * wrong is the single most common disqualification. Pure, LLM-free.
+ */
+
+export type CountMode = 'with_space' | 'no_space' | 'byte';
+
+export interface CharCounts {
+  /** Code points incl. all whitespace. Uses [...text] so surrogate pairs (emoji) count as 1. */
+  withSpace: number;
+  /** Code points with every whitespace char (space/tab/newline) removed. */
+  noSpace: number;
+  /**
+   * UTF-8 byte length. NOTE: some legacy Korean forms count 2 bytes per Hangul
+   * syllable (EUC-KR/KS X 1001); modern web forms and most "byte" limits today are
+   * UTF-8 (3 bytes per Hangul). We report UTF-8 — the AI should confirm the posting's
+   * convention when a byte limit is given.
+   */
+  byte: number;
+}
+
+export interface CharLimitCheck {
+  mode: CountMode;
+  /** The count under the chosen mode. */
+  count: number;
+  min?: number;
+  max?: number;
+  /** 'no_limit' when neither min nor max is given. */
+  status: 'under' | 'ok' | 'over' | 'no_limit';
+  /** over: count−max ; under: min−count ; otherwise undefined. */
+  delta?: number;
+}
+
+const utf8Bytes = (text: string): number => {
+  // Avoid a Node Buffer dependency in this pure module — count UTF-8 bytes directly.
+  let bytes = 0;
+  for (const ch of text) {
+    const cp = ch.codePointAt(0)!;
+    if (cp <= 0x7f) bytes += 1;
+    else if (cp <= 0x7ff) bytes += 2;
+    else if (cp <= 0xffff) bytes += 3;
+    else bytes += 4;
+  }
+  return bytes;
+};
+
+/** Count a string three ways. Deterministic, encoding-explicit. */
+export function countChars(text: string): CharCounts {
+  const cps = [...text];
+  return {
+    withSpace: cps.length,
+    noSpace: cps.filter((c) => !/\s/.test(c)).length,
+    byte: utf8Bytes(text),
+  };
+}
+
+/** Pick the count for a mode (default with_space — AGENTS.md: 미지정 시 공백포함). */
+export function countForMode(text: string, mode: CountMode = 'with_space'): number {
+  const c = countChars(text);
+  return mode === 'no_space' ? c.noSpace : mode === 'byte' ? c.byte : c.withSpace;
+}
+
+/**
+ * Check a text against an optional min/max under one counting mode. Advisory —
+ * the caller decides what to do with `over`/`under` (this never throws or blocks).
+ */
+export function checkCharLimit(
+  text: string,
+  opts: { min?: number; max?: number; mode?: CountMode } = {},
+): CharLimitCheck {
+  const mode = opts.mode ?? 'with_space';
+  const count = countForMode(text, mode);
+  const hasMin = typeof opts.min === 'number';
+  const hasMax = typeof opts.max === 'number';
+  if (!hasMin && !hasMax) {
+    return { mode, count, status: 'no_limit' };
+  }
+  if (hasMax && count > opts.max!) {
+    return { mode, count, min: opts.min, max: opts.max, status: 'over', delta: count - opts.max! };
+  }
+  if (hasMin && count < opts.min!) {
+    return { mode, count, min: opts.min, max: opts.max, status: 'under', delta: opts.min! - count };
+  }
+  return { mode, count, min: opts.min, max: opts.max, status: 'ok' };
+}

package/packages/core/src/verify/index.ts

@@ -8,4 +8,5 @@
  */
 export * from './normalize.ts';
 export * from './lexicons.ts';
+export * from './charcount.ts';
 export * from './lint.ts';

package/packages/core/src/verify/lint.ts

@@ -24,6 +24,7 @@ import {
   type NumberToken,
 } from './normalize.ts';
 import { STYLE_LEXICONS, countHits } from './lexicons.ts';
+import { countChars, type CharCounts } from './charcount.ts';
 
 export type Severity = 'critical' | 'warn' | 'info';
 
@@ -66,7 +67,10 @@ export interface ProvenanceResult {
 
 export interface LintReport {
   kind: 'cover_letter' | 'fit' | 'interview' | 'resume';
+  /** Normalized code-point length (kept for backward compat). For form length use charCounts. */
   charCount: number;
+  /** Deterministic counts on the RAW text (what a submission form counts), three Korean conventions. */
+  charCounts: CharCounts;
   /** Advisory style signals (never block). */
   signals: Signal[];
   provenance: ProvenanceResult;
@@ -225,6 +229,7 @@ export function lintArtifact(
   return {
     kind,
     charCount: [...norm].length,
+    charCounts: countChars(text),
     signals,
     provenance,
     blocking,

package/packages/db/src/repositories.ts

@@ -64,6 +64,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 +96,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 +656,9 @@ 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, []),
     created_at: r.created_at,
     updated_at: r.updated_at,
   };
@@ -674,7 +691,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=?,updated_at=? WHERE id=?`,
       ).run(
         m.company,
         m.position,
@@ -686,6 +703,9 @@ export const jobRepo = {
         toJson(m.keywords ?? []),
         m.deadline ?? null,
         m.source ?? null,
+        m.company_overview ?? null,
+        m.talent_profile ?? null,
+        toJson(m.core_values ?? []),
         ts,
         existing.id,
       );
@@ -693,8 +713,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,created_at,updated_at)
+       VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`,
     ).run(
       newJobId,
       input.company,
@@ -707,6 +727,9 @@ export const jobRepo = {
       toJson(input.keywords ?? []),
       input.deadline ?? null,
       input.source ?? null,
+      input.company_overview ?? null,
+      input.talent_profile ?? null,
+      toJson(input.core_values ?? []),
       ts,
       ts,
     );
@@ -872,6 +895,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 +905,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 +927,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 +947,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 +955,7 @@ export const interviewRepo = {
       toJson(input.star_guides ?? []),
       input.self_introduction ?? null,
       input.notes ?? null,
+      toJson(input.debrief ?? {}),
       ts,
       ts,
     );

package/packages/db/src/schema.ts

@@ -300,6 +300,35 @@ 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 '{}';
+  `,
 ];
 
 export function migrate(db: DatabaseSync): { from: number; to: number } {

package/packages/exporters/src/docx.ts

@@ -0,0 +1,165 @@
+/**
+ * Markdown → .docx renderer.
+ *
+ * The other exporters already produce a small, well-known Markdown dialect
+ * (headings `#`…`####`, `- ` bullets, `**label**: value` rows, `[text](url)`
+ * links, `**bold**`, `_italic_`, `---` rules). Rather than re-derive structure
+ * from records per document type, we render THAT dialect to a Word document —
+ * exactly mirroring how `html.ts` turns the same Markdown into print HTML. One
+ * faithful, ATS-safe single-column layout; no decorative template.
+ *
+ * Binary output is a `Uint8Array` (the OOXML zip). Callers stream/write it as-is.
+ */
+import {
+  Document,
+  ExternalHyperlink,
+  HeadingLevel,
+  Packer,
+  Paragraph,
+  TextRun,
+} from 'docx';
+
+const HEADING_BY_LEVEL = [
+  HeadingLevel.HEADING_1,
+  HeadingLevel.HEADING_2,
+  HeadingLevel.HEADING_3,
+  HeadingLevel.HEADING_4,
+] as const;
+
+/**
+ * XML 1.0 forbids these control chars even as numeric references; the `docx`
+ * lib writes run text verbatim into document.xml, so a single one makes the
+ * whole .docx not well-formed and Word refuses to open it. Tab (0x09) and
+ * newline (0x0A) are valid and preserved. Strip everything else in the C0 set.
+ */
+const XML_INVALID_RE = /[\x00-\x08\x0B\x0C\x0E-\x1F]/g;
+const xmlSafe = (s: string): string => s.replace(XML_INVALID_RE, '');
+
+const ALNUM_RE = /[\p{L}\p{N}]/u;
+/** Link-scheme allowlist — mirrors html.ts renderInline so the docx path can't
+ *  emit javascript:/file:// hyperlinks that the HTML path neutralizes. */
+const SAFE_LINK_RE = /^(https?:|mailto:|#|\/)/i;
+
+/** Inline tokens: **bold**, _italic_, [text](url). Order-preserving, non-nesting. */
+const INLINE_RE = /(\*\*([^*]+)\*\*|_([^_]+)_|\[([^\]]+)\]\(([^)]+)\))/g;
+
+function inlineRuns(text: string): (TextRun | ExternalHyperlink)[] {
+  const src = xmlSafe(text);
+  const out: (TextRun | ExternalHyperlink)[] = [];
+  let last = 0;
+  for (const m of src.matchAll(INLINE_RE)) {
+    const idx = m.index ?? 0;
+    if (idx > last) out.push(new TextRun(src.slice(last, idx)));
+    if (m[2] !== undefined) {
+      out.push(new TextRun({ text: m[2], bold: true }));
+    } else if (m[3] !== undefined) {
+      // CommonMark intraword-underscore rule: `_` is emphasis only when flanked
+      // by non-alphanumerics, so snake_case / env-vars / file_paths
+      // (read_write_latency, API_KEY) are kept literal instead of being mangled.
+      const before = idx > 0 ? src[idx - 1] : '';
+      const after = src[idx + m[0].length] ?? '';
+      if (ALNUM_RE.test(before) || ALNUM_RE.test(after)) {
+        out.push(new TextRun(m[0])); // not emphasis — emit underscores literally
+      } else {
+        out.push(new TextRun({ text: m[3], italics: true }));
+      }
+    } else if (m[4] !== undefined) {
+      // [text](url) — a real Word hyperlink so it survives ATS text extraction.
+      const link = (m[5] ?? '').trim();
+      if (SAFE_LINK_RE.test(link)) {
+        out.push(
+          new ExternalHyperlink({
+            children: [new TextRun({ text: m[4], style: 'Hyperlink' })],
+            link,
+          }),
+        );
+      } else {
+        // Disallowed scheme (javascript:/file:/data:) → plain text, mirroring html.ts.
+        out.push(new TextRun(m[4]));
+      }
+    }
+    last = idx + m[0].length;
+  }
+  if (last < src.length) out.push(new TextRun(src.slice(last)));
+  return out.length ? out : [new TextRun('')];
+}
+
+/** Parse our Markdown dialect (blocks split on blank lines) into docx paragraphs. */
+function markdownToParagraphs(markdown: string): Paragraph[] {
+  const paras: Paragraph[] = [];
+  const lines = markdown.replace(/\r\n/g, '\n').split('\n');
+
+  for (const raw of lines) {
+    const line = raw.trimEnd();
+    if (line.trim() === '') continue; // blank lines: spacing comes from paragraph config
+
+    // Horizontal rule → a thin bottom border on an empty paragraph.
+    if (/^---+$/.test(line.trim())) {
+      paras.push(
+        new Paragraph({
+          border: { bottom: { style: 'single', size: 6, space: 1, color: 'CCCCCC' } },
+          spacing: { after: 160 },
+          children: [new TextRun('')],
+        }),
+      );
+      continue;
+    }
+
+    // ATX heading.
+    const h = /^(#{1,4})\s+(.*)$/.exec(line);
+    if (h) {
+      const level = h[1].length - 1;
+      paras.push(
+        new Paragraph({
+          heading: HEADING_BY_LEVEL[level],
+          spacing: { before: level === 0 ? 0 : 200, after: 80 },
+          children: inlineRuns(h[2]),
+        }),
+      );
+      continue;
+    }
+
+    // Bullet (-, *, + — match the markdown dialect html.ts accepts).
+    const b = /^[-*+]\s+(.*)$/.exec(line);
+    if (b) {
+      paras.push(
+        new Paragraph({ bullet: { level: 0 }, spacing: { after: 40 }, children: inlineRuns(b[1]) }),
+      );
+      continue;
+    }
+
+    paras.push(new Paragraph({ spacing: { after: 120 }, children: inlineRuns(line) }));
+  }
+
+  return paras;
+}
+
+const DOCX_FONT = '맑은 고딕'; // Malgun Gothic — ships with Windows, renders Korean + Latin cleanly.
+
+/**
+ * Render a title + our Markdown body to a .docx byte array (single-column,
+ * ATS-friendly). The leading `# title` in the body is rendered as Heading 1, so
+ * we don't duplicate the title here.
+ */
+export async function markdownToDocx(_title: string, markdown: string): Promise<Uint8Array> {
+  const doc = new Document({
+    styles: {
+      default: {
+        document: { run: { font: DOCX_FONT, size: 22 } }, // 11pt
+      },
+    },
+    sections: [
+      {
+        properties: {
+          page: { margin: { top: 1134, bottom: 1134, left: 1134, right: 1134 } }, // 2cm
+        },
+        children: markdownToParagraphs(markdown),
+      },
+    ],
+  });
+  // Packer.toBuffer returns a Node Buffer (a Uint8Array subclass) in Node.
+  return Packer.toBuffer(doc);
+}
+
+export const DOCX_MIME =
+  'application/vnd.openxmlformats-officedocument.wordprocessingml.document';