careermate 0.0.1

package/packages/shared/src/build-info.ts

@@ -0,0 +1,22 @@
+/**
+ * Build-time constants injected by esbuild's `define` in the dist bundle
+ * (scripts/build-dist.mjs): `__APP_VERSION__` = package.json version, and
+ * `__BUNDLED__` = true inside the bundle. Under tsx/source runs they're
+ * undefined, so the `typeof` guards fall back to dev defaults.
+ *
+ * Single source of truth so this idiom isn't copy-pasted across every
+ * entrypoint (mcp/web/doctor) and package.
+ *
+ * MUST stay dependency-free and side-effect-free: @careermate/shared re-exports
+ * it, so every shared consumer evaluates this module at import time. The
+ * injected tokens are only ever read inside `typeof` guards (never bare), so
+ * evaluation can't throw even where the define isn't applied.
+ */
+declare const __APP_VERSION__: string | undefined;
+declare const __BUNDLED__: boolean | undefined;
+
+/** App version: package.json version in the bundle, `0.0.0-dev` under source/tsx. */
+export const APP_VERSION: string = typeof __APP_VERSION__ !== 'undefined' ? __APP_VERSION__ : '0.0.0-dev';
+
+/** True only when running from the esbuild dist bundle (vs tsx source). */
+export const BUNDLED: boolean = typeof __BUNDLED__ !== 'undefined' && __BUNDLED__;

package/packages/shared/src/enums.ts

@@ -0,0 +1,142 @@
+/**
+ * CareerMate — shared enums and human-facing labels.
+ *
+ * These value sets are the single source of truth for both the MCP server
+ * (used by ChatGPT/Claude/Gemini) and the local web dashboard. Labels are in
+ * Korean because the primary audience is Korean job seekers; codes are stable
+ * machine values that must never change once persisted.
+ */
+
+/** Application lifecycle. Drives the Applications board in the dashboard. */
+export const APPLICATION_STATUSES = [
+  'draft', // 작성 중
+  'planned', // 지원 예정
+  'applied', // 지원 완료
+  'document_passed', // 서류 합격
+  'interview', // 면접 진행
+  'final_passed', // 최종 합격
+  'rejected', // 불합격
+  'on_hold', // 보류
+] as const;
+
+export type ApplicationStatus = (typeof APPLICATION_STATUSES)[number];
+
+export const APPLICATION_STATUS_LABELS: Record<ApplicationStatus, string> = {
+  draft: '작성 중',
+  planned: '지원 예정',
+  applied: '지원 완료',
+  document_passed: '서류 합격',
+  interview: '면접 진행',
+  final_passed: '최종 합격',
+  rejected: '불합격',
+  on_hold: '보류',
+};
+
+/** Ordered columns for the kanban-style Applications board. */
+export const APPLICATION_BOARD_ORDER: ApplicationStatus[] = [
+  'draft',
+  'planned',
+  'applied',
+  'document_passed',
+  'interview',
+  'final_passed',
+  'on_hold',
+  'rejected',
+];
+
+/** Reaching this status unlocks interview-prep prompting in the workflow. */
+export const INTERVIEW_UNLOCK_STATUSES: ApplicationStatus[] = [
+  'document_passed',
+  'interview',
+  'final_passed',
+];
+
+/**
+ * Allowed application-status transitions (server-enforced lifecycle).
+ *
+ * Design note: CareerMate lets the user's AI record where an application *really*
+ * is, so `draft` (the initial, untracked state) may jump to ANY real-world stage.
+ * Once an application is being tracked, it may move forward, be corrected
+ * backward among active stages, be parked (`on_hold`) or closed (`rejected`) from
+ * anywhere, and be reopened/resumed from those terminal states. The one move we
+ * forbid is regressing an *active* application back to `draft` ("untracked"),
+ * which would silently drop its lifecycle history. The hard spec invariant
+ * (interview prep requires `document_passed`+) is enforced separately at the
+ * service layer via {@link INTERVIEW_UNLOCK_STATUSES}.
+ */
+export const ALLOWED_STATUS_TRANSITIONS: Record<ApplicationStatus, ApplicationStatus[]> = {
+  draft: ['planned', 'applied', 'document_passed', 'interview', 'final_passed', 'rejected', 'on_hold'],
+  planned: ['applied', 'document_passed', 'interview', 'final_passed', 'rejected', 'on_hold'],
+  applied: ['planned', 'document_passed', 'interview', 'final_passed', 'rejected', 'on_hold'],
+  document_passed: ['planned', 'applied', 'interview', 'final_passed', 'rejected', 'on_hold'],
+  interview: ['planned', 'applied', 'document_passed', 'final_passed', 'rejected', 'on_hold'],
+  final_passed: ['document_passed', 'interview', 'rejected', 'on_hold'],
+  rejected: ['draft', 'planned', 'applied', 'document_passed', 'interview', 'final_passed', 'on_hold'],
+  on_hold: ['draft', 'planned', 'applied', 'document_passed', 'interview', 'final_passed', 'rejected'],
+};
+
+/** Whether moving from `from` to `to` is a permitted status transition (same→same is always allowed). */
+export function canTransitionStatus(from: ApplicationStatus, to: ApplicationStatus): boolean {
+  if (from === to) return true;
+  return ALLOWED_STATUS_TRANSITIONS[from]?.includes(to) ?? false;
+}
+
+/** Throw a clear, user-facing (Korean) error when a status transition is not allowed. */
+export function assertStatusTransition(from: ApplicationStatus, to: ApplicationStatus): void {
+  if (!canTransitionStatus(from, to)) {
+    throw new Error(
+      `'${APPLICATION_STATUS_LABELS[from]}'에서 '${APPLICATION_STATUS_LABELS[to]}'(으)로는 상태를 바꿀 수 없습니다.`,
+    );
+  }
+}
+
+/** Stored document kinds (resumes and career descriptions). Cover letters live in their own tables. */
+export const DOCUMENT_KINDS = ['resume', 'career_description', 'portfolio', 'other'] as const;
+export type DocumentKind = (typeof DOCUMENT_KINDS)[number];
+
+export const DOCUMENT_KIND_LABELS: Record<DocumentKind, string> = {
+  resume: '이력서',
+  career_description: '경력기술서',
+  portfolio: '포트폴리오',
+  other: '기타 문서',
+};
+
+/** Where a piece of content originated — used to show provenance and protect privacy. */
+export const CONTENT_SOURCES = ['manual', 'upload', 'ai', 'edit'] as const;
+export type ContentSource = (typeof CONTENT_SOURCES)[number];
+
+export const CONTENT_SOURCE_LABELS: Record<ContentSource, string> = {
+  manual: '직접 입력',
+  upload: '파일 업로드',
+  ai: 'AI 생성',
+  edit: '직접 수정',
+};
+
+/** Activity feed entry types (list_recent_activity). */
+export const ACTIVITY_TYPES = [
+  'profile_updated',
+  'resume_added',
+  'cover_letter_added',
+  'cover_letter_version_saved',
+  'job_saved',
+  'fit_analysis_saved',
+  'application_status_changed',
+  'interview_prep_saved',
+  'document_exported',
+] as const;
+export type ActivityType = (typeof ACTIVITY_TYPES)[number];
+
+/** Entity kinds referenced by activities and deep links. */
+export const ENTITY_TYPES = [
+  'profile',
+  'experience',
+  'project',
+  'skill',
+  'document',
+  'cover_letter',
+  'job',
+  'application',
+  'fit_analysis',
+  'interview_prep',
+] as const;
+export type EntityType = (typeof ENTITY_TYPES)[number];

package/packages/shared/src/index.ts

@@ -0,0 +1,19 @@
+/**
+ * @careermate/shared — single source of truth for types, enums, and zod schemas
+ * shared by the DB layer, core use-cases, HTTP API, and MCP server.
+ */
+export * from './enums.ts';
+export * from './schemas.ts';
+export { APP_VERSION, BUNDLED } from './build-info.ts';
+
+/** Short, URL-safe, sortable-ish id. Avoids a uuid dependency. */
+export function newId(prefix = ''): string {
+  const rnd = Math.random().toString(36).slice(2, 10);
+  const time = Date.now().toString(36);
+  return `${prefix}${time}${rnd}`;
+}
+
+/** Current timestamp as ISO-8601 string (stored verbatim in SQLite). */
+export function now(): string {
+  return new Date().toISOString();
+}

package/packages/shared/src/schemas.ts

@@ -0,0 +1,453 @@
+/**
+ * CareerMate — zod schemas + inferred TypeScript types.
+ *
+ * Two layers per entity:
+ *  - `*Input`  : what the MCP tools / HTTP API accept from the AI or dashboard.
+ *  - `*Record` : the persisted shape returned from the DB (adds id + timestamps).
+ *
+ * JSON-ish nested fields (achievements, tech, strengths…) are stored as JSON
+ * text columns in SQLite and parsed back into arrays/objects by the repositories.
+ */
+import { z } from 'zod';
+import {
+  APPLICATION_STATUSES,
+  ACTIVITY_TYPES,
+  CONTENT_SOURCES,
+  DOCUMENT_KINDS,
+  ENTITY_TYPES,
+} from './enums.ts';
+
+const isoDateTime = z.string();
+const id = z.string();
+
+/**
+ * Reject script-capable URL schemes (javascript:, data:, vbscript:, file:, …)
+ * while allowing http(s), mailto, and scheme-less/relative links. Links are
+ * rendered as clickable anchors in the dashboard, so a `javascript:` URL stored
+ * here would otherwise execute when clicked (DOM-XSS). The dashboard also
+ * sanitizes href/src at render time (lib.js `safeUrl`); this is the write-time
+ * half of that defense-in-depth.
+ */
+function isSafeUrl(u: string): boolean {
+  const s = u.trim();
+  // An explicit scheme (text before the first ':') must be http(s) or mailto.
+  // Scheme-less values (relative paths, bare domains, #anchors) cannot execute.
+  return !/^[a-z][a-z0-9+.-]*:/i.test(s) || /^(https?:|mailto:)/i.test(s);
+}
+const UNSAFE_URL_MSG = 'javascript: 같은 위험한 링크는 사용할 수 없습니다. http(s) 링크를 사용하세요.';
+const MAX_URL = 2_000;
+const SafeUrl = z.string().min(1).max(MAX_URL).refine(isSafeUrl, { message: UNSAFE_URL_MSG });
+const SafeUrlOptional = z
+  .string()
+  .max(MAX_URL)
+  .optional()
+  .refine((u) => u == null || u === '' || isSafeUrl(u), { message: UNSAFE_URL_MSG });
+
+/**
+ * Length-bounded string helpers. MCP/HTTP inputs are otherwise unbounded, so a
+ * malicious or buggy client could send multi-MB strings to exhaust memory/disk.
+ * These caps are generous for real résumés/cover letters but reject abuse.
+ *  - LINE : single-line fields (names, titles, locations)
+ *  - NOTE : short multi-line fields (summaries, notes)
+ *  - BODY : full document bodies (resume / cover letter / job description)
+ *  - ITEM : one array element;  ITEMS : array length
+ */
+const MAX_LINE = 500;
+const MAX_NOTE = 10_000;
+const MAX_BODY = 200_000;
+const MAX_ITEM = 2_000;
+const MAX_ITEMS = 500;
+const EMPTY_MSG = '내용이 비어 있습니다(공백만으로는 저장할 수 없습니다).';
+
+/** Required single-line value: rejects whitespace-only, trims, bounds length. */
+const reqLine = z.string().trim().min(1).max(MAX_LINE);
+/** Optional single-line value (bounded). */
+const optLine = z.string().max(MAX_LINE).optional();
+/** Optional short multi-line note (bounded). */
+const optNote = z.string().max(MAX_NOTE).optional();
+/** Optional full document body (bounded). */
+const optBody = z.string().max(MAX_BODY).optional();
+/** Required full document body: bounded, rejects whitespace-only (no trim — preserve formatting). */
+const reqBody = z
+  .string()
+  .max(MAX_BODY)
+  .refine((s) => s.trim().length > 0, { message: EMPTY_MSG });
+/** Bounded array of bounded strings. */
+const strList = z.array(z.string().max(MAX_ITEM)).max(MAX_ITEMS);
+
+const baseRecord = {
+  id,
+  created_at: isoDateTime,
+  updated_at: isoDateTime,
+};
+
+/* ------------------------------------------------------------------ Profile */
+
+export const LinkSchema = z.object({
+  label: reqLine,
+  url: SafeUrl,
+});
+export type Link = z.infer<typeof LinkSchema>;
+
+export const ProfileInputSchema = z.object({
+  name: reqLine.optional(),
+  email: optLine,
+  phone: optLine,
+  location: optLine,
+  headline: z.string().max(MAX_LINE).optional().describe('한 줄 소개 / 직무 타이틀'),
+  summary: z.string().max(MAX_NOTE).optional().describe('자기소개 요약'),
+  desired_roles: strList.optional().describe('희망 직무'),
+  desired_conditions: z.string().max(MAX_NOTE).optional().describe('희망 근무 조건 (연봉, 지역, 근무형태 등)'),
+  preferred_tone: z.string().max(MAX_LINE).optional().describe('자기소개서 선호 문체 (예: 담백하고 구체적)'),
+  emphasis_points: strList.optional().describe('강조하고 싶은 핵심 포인트'),
+  links: z.array(LinkSchema).max(MAX_ITEMS).optional().describe('포트폴리오/깃허브/링크드인 등'),
+});
+export type ProfileInput = z.infer<typeof ProfileInputSchema>;
+
+export const ProfileRecordSchema = z.object({
+  ...baseRecord,
+  name: z.string().nullable(),
+  email: z.string().nullable(),
+  phone: z.string().nullable(),
+  location: z.string().nullable(),
+  headline: z.string().nullable(),
+  summary: z.string().nullable(),
+  desired_roles: z.array(z.string()),
+  desired_conditions: z.string().nullable(),
+  preferred_tone: z.string().nullable(),
+  emphasis_points: z.array(z.string()),
+  links: z.array(LinkSchema),
+});
+export type ProfileRecord = z.infer<typeof ProfileRecordSchema>;
+
+/* --------------------------------------------------------------- Experience */
+
+export const ExperienceInputSchema = z.object({
+  company: reqLine,
+  role: optLine,
+  employment_type: z.string().max(MAX_LINE).optional().describe('정규직/계약직/인턴/프리랜서 등'),
+  start_date: z.string().max(MAX_LINE).optional().describe('YYYY-MM 또는 YYYY-MM-DD'),
+  end_date: z.string().max(MAX_LINE).optional().describe('재직 중이면 비워두기'),
+  is_current: z.boolean().optional(),
+  description: optBody,
+  achievements: strList.optional().describe('성과/업적 (정량 지표 권장)'),
+  tech: strList.optional().describe('사용 기술/도구'),
+  order_index: z.number().optional(),
+});
+export type ExperienceInput = z.infer<typeof ExperienceInputSchema>;
+
+export const ExperienceRecordSchema = z.object({
+  ...baseRecord,
+  company: z.string(),
+  role: z.string().nullable(),
+  employment_type: z.string().nullable(),
+  start_date: z.string().nullable(),
+  end_date: z.string().nullable(),
+  is_current: z.boolean(),
+  description: z.string().nullable(),
+  achievements: z.array(z.string()),
+  tech: z.array(z.string()),
+  order_index: z.number(),
+});
+export type ExperienceRecord = z.infer<typeof ExperienceRecordSchema>;
+
+/* ------------------------------------------------------------------ Project */
+
+export const ProjectInputSchema = z.object({
+  name: reqLine,
+  role: optLine,
+  description: optBody,
+  highlights: strList.optional(),
+  tech: strList.optional(),
+  url: SafeUrlOptional,
+  start_date: optLine,
+  end_date: optLine,
+  order_index: z.number().optional(),
+});
+export type ProjectInput = z.infer<typeof ProjectInputSchema>;
+
+export const ProjectRecordSchema = z.object({
+  ...baseRecord,
+  name: z.string(),
+  role: z.string().nullable(),
+  description: z.string().nullable(),
+  highlights: z.array(z.string()),
+  tech: z.array(z.string()),
+  url: z.string().nullable(),
+  start_date: z.string().nullable(),
+  end_date: z.string().nullable(),
+  order_index: z.number(),
+});
+export type ProjectRecord = z.infer<typeof ProjectRecordSchema>;
+
+/* -------------------------------------------------------------------- Skill */
+
+export const SkillInputSchema = z.object({
+  name: reqLine,
+  category: z.string().max(MAX_LINE).optional().describe('언어/프레임워크/툴/소프트스킬 등'),
+  level: z.string().max(MAX_LINE).optional().describe('상/중/하 또는 자유 서술'),
+  years: z.number().optional(),
+  order_index: z.number().optional(),
+});
+export type SkillInput = z.infer<typeof SkillInputSchema>;
+
+export const SkillRecordSchema = z.object({
+  ...baseRecord,
+  name: z.string(),
+  category: z.string().nullable(),
+  level: z.string().nullable(),
+  years: z.number().nullable(),
+  order_index: z.number(),
+});
+export type SkillRecord = z.infer<typeof SkillRecordSchema>;
+
+/* ----------------------------------------------------------------- Document */
+
+export const DocumentInputSchema = z.object({
+  kind: z.enum(DOCUMENT_KINDS),
+  title: reqLine,
+  content: reqBody.describe('Markdown 또는 일반 텍스트 본문'),
+  source: z.enum(CONTENT_SOURCES).optional(),
+  is_primary: z.boolean().optional().describe('대표 문서 여부'),
+  tags: strList.optional(),
+});
+export type DocumentInput = z.infer<typeof DocumentInputSchema>;
+
+export const DocumentRecordSchema = z.object({
+  ...baseRecord,
+  kind: z.enum(DOCUMENT_KINDS),
+  title: z.string(),
+  content: z.string(),
+  source: z.enum(CONTENT_SOURCES),
+  is_primary: z.boolean(),
+  tags: z.array(z.string()),
+});
+export type DocumentRecord = z.infer<typeof DocumentRecordSchema>;
+
+/* -------------------------------------------------------------- CoverLetter */
+
+export const CoverLetterInputSchema = z.object({
+  title: reqLine,
+  job_id: optLine.describe('특정 공고에 연결할 경우'),
+  is_primary: z.boolean().optional(),
+  content: optBody.describe('초기 버전 본문 (있으면 v1로 저장)'),
+  source: z.enum(CONTENT_SOURCES).optional(),
+  note: optNote.describe('초기 버전 메모'),
+});
+export type CoverLetterInput = z.infer<typeof CoverLetterInputSchema>;
+
+export const CoverLetterVersionInputSchema = z.object({
+  cover_letter_id: optLine.describe('기존 자기소개서에 새 버전 추가 시'),
+  title: z.string().max(MAX_LINE).optional().describe('새 자기소개서를 만들 때 제목'),
+  job_id: optLine,
+  content: reqBody,
+  note: optNote.describe('이 버전의 변경 요약 (예: 지원동기 보강)'),
+  source: z.enum(CONTENT_SOURCES).optional(),
+  set_current: z.boolean().optional().describe('이 버전을 현재 버전으로 지정 (기본 true)'),
+});
+export type CoverLetterVersionInput = z.infer<typeof CoverLetterVersionInputSchema>;
+
+export const CoverLetterVersionRecordSchema = z.object({
+  id,
+  cover_letter_id: z.string(),
+  version_no: z.number(),
+  content: z.string(),
+  note: z.string().nullable(),
+  source: z.enum(CONTENT_SOURCES),
+  created_at: isoDateTime,
+});
+export type CoverLetterVersionRecord = z.infer<typeof CoverLetterVersionRecordSchema>;
+
+export const CoverLetterRecordSchema = z.object({
+  ...baseRecord,
+  title: z.string(),
+  job_id: z.string().nullable(),
+  is_primary: z.boolean(),
+  current_version_id: z.string().nullable(),
+  version_count: z.number(),
+  current_content: z.string().nullable(),
+  versions: z.array(CoverLetterVersionRecordSchema).optional(),
+});
+export type CoverLetterRecord = z.infer<typeof CoverLetterRecordSchema>;
+
+/* --------------------------------------------------------------------- Job */
+
+export const JobInputSchema = z.object({
+  company: reqLine,
+  position: reqLine.describe('직무/포지션명'),
+  url: SafeUrlOptional,
+  location: optLine,
+  employment_type: optLine,
+  description: optBody.describe('공고 원문 또는 정리된 텍스트'),
+  requirements: strList.optional().describe('자격요건/우대사항 핵심'),
+  keywords: strList.optional().describe('핵심 키워드'),
+  deadline: z.string().max(MAX_LINE).optional().describe('마감일 YYYY-MM-DD'),
+  source: z.string().max(MAX_LINE).optional().describe('출처 (사람인/원티드/직접 입력 등)'),
+});
+export type JobInput = z.infer<typeof JobInputSchema>;
+
+export const JobRecordSchema = z.object({
+  ...baseRecord,
+  company: z.string(),
+  position: z.string(),
+  url: z.string().nullable(),
+  location: z.string().nullable(),
+  employment_type: z.string().nullable(),
+  description: z.string().nullable(),
+  requirements: z.array(z.string()),
+  keywords: z.array(z.string()),
+  deadline: z.string().nullable(),
+  source: z.string().nullable(),
+});
+export type JobRecord = z.infer<typeof JobRecordSchema>;
+
+/* ------------------------------------------------------------- FitAnalysis */
+
+export const FitAnalysisInputSchema = z.object({
+  job_id: reqLine.describe('분석 대상 공고 ID'),
+  score: z.number().min(0).max(100).optional().describe('종합 적합도 0~100'),
+  summary: z.string().max(MAX_NOTE).optional().describe('한두 문단 요약'),
+  strengths: strList.optional().describe('강점 / 잘 맞는 부분'),
+  gaps: strList.optional().describe('부족한 부분 / 보완 필요'),
+  matched_keywords: strList.optional(),
+  missing_keywords: strList.optional(),
+  recommendations: strList.optional().describe('자기소개서/지원 전략 제안'),
+});
+export type FitAnalysisInput = z.infer<typeof FitAnalysisInputSchema>;
+
+export const FitAnalysisRecordSchema = z.object({
+  ...baseRecord,
+  job_id: z.string(),
+  score: z.number().nullable(),
+  summary: z.string().nullable(),
+  strengths: z.array(z.string()),
+  gaps: z.array(z.string()),
+  matched_keywords: z.array(z.string()),
+  missing_keywords: z.array(z.string()),
+  recommendations: z.array(z.string()),
+});
+export type FitAnalysisRecord = z.infer<typeof FitAnalysisRecordSchema>;
+
+/* ------------------------------------------------------------- Application */
+
+export const ApplicationInputSchema = z.object({
+  job_id: reqLine,
+  status: z.enum(APPLICATION_STATUSES).optional(),
+  resume_id: optLine,
+  cover_letter_id: optLine,
+  applied_at: optLine,
+  notes: optNote,
+});
+export type ApplicationInput = z.infer<typeof ApplicationInputSchema>;
+
+export const ApplicationStatusUpdateSchema = z.object({
+  job_id: optLine,
+  application_id: optLine,
+  status: z.enum(APPLICATION_STATUSES),
+  note: optNote.describe('상태 변경 사유/메모'),
+});
+export type ApplicationStatusUpdate = z.infer<typeof ApplicationStatusUpdateSchema>;
+
+export const ApplicationRecordSchema = z.object({
+  ...baseRecord,
+  job_id: z.string(),
+  status: z.enum(APPLICATION_STATUSES),
+  resume_id: z.string().nullable(),
+  cover_letter_id: z.string().nullable(),
+  applied_at: z.string().nullable(),
+  notes: z.string().nullable(),
+});
+export type ApplicationRecord = z.infer<typeof ApplicationRecordSchema>;
+
+/* ----------------------------------------------------------- InterviewPrep */
+
+export const StarGuideSchema = z.object({
+  question: z.string().max(MAX_NOTE),
+  situation: optNote,
+  task: optNote,
+  action: optNote,
+  result: optNote,
+});
+export type StarGuide = z.infer<typeof StarGuideSchema>;
+
+export const InterviewQuestionSchema = z.object({
+  question: z.string().max(MAX_NOTE),
+  intent: z.string().max(MAX_NOTE).optional().describe('질문 의도'),
+  followups: strList.optional().describe('예상 꼬리 질문'),
+  answer_outline: optBody.describe('답변 가이드/핵심 포인트'),
+});
+export type InterviewQuestion = z.infer<typeof InterviewQuestionSchema>;
+
+export const InterviewPrepInputSchema = z.object({
+  job_id: reqLine,
+  questions: z.array(InterviewQuestionSchema).max(MAX_ITEMS).optional(),
+  star_guides: z.array(StarGuideSchema).max(MAX_ITEMS).optional(),
+  self_introduction: optBody.describe('1분 자기소개 초안'),
+  notes: optNote.describe('면접 후기/메모'),
+});
+export type InterviewPrepInput = z.infer<typeof InterviewPrepInputSchema>;
+
+export const InterviewPrepRecordSchema = z.object({
+  ...baseRecord,
+  job_id: z.string(),
+  questions: z.array(InterviewQuestionSchema),
+  star_guides: z.array(StarGuideSchema),
+  self_introduction: z.string().nullable(),
+  notes: z.string().nullable(),
+});
+export type InterviewPrepRecord = z.infer<typeof InterviewPrepRecordSchema>;
+
+/* ----------------------------------------------------------------- Activity */
+
+export const ActivityRecordSchema = z.object({
+  id,
+  type: z.enum(ACTIVITY_TYPES),
+  entity_type: z.enum(ENTITY_TYPES).nullable(),
+  entity_id: z.string().nullable(),
+  summary: z.string(),
+  created_at: isoDateTime,
+});
+export type ActivityRecord = z.infer<typeof ActivityRecordSchema>;
+
+/* ----------------------------------------------------- Aggregates / context */
+
+export const OnboardingStatusSchema = z.object({
+  completed: z.boolean(),
+  has_profile: z.boolean(),
+  has_resume: z.boolean(),
+  has_cover_letter: z.boolean(),
+  has_experience: z.boolean(),
+  has_skills: z.boolean(),
+  has_job: z.boolean(),
+  profile_completeness: z.number().describe('0~100 프로필 완성도'),
+  next_steps: z.array(z.string()).describe('지금 해야 할 다음 단계 안내'),
+});
+export type OnboardingStatus = z.infer<typeof OnboardingStatusSchema>;
+
+/** The one-shot context bundle the AI pulls before analyzing a job or writing. */
+export const ApplicationContextSchema = z.object({
+  profile: ProfileRecordSchema.nullable(),
+  primary_resume: DocumentRecordSchema.nullable(),
+  resumes: z.array(DocumentRecordSchema),
+  experiences: z.array(ExperienceRecordSchema),
+  projects: z.array(ProjectRecordSchema),
+  skills: z.array(SkillRecordSchema),
+  cover_letters: z.array(CoverLetterRecordSchema),
+  recent_applications: z.array(ApplicationRecordSchema),
+  job: JobRecordSchema.nullable(),
+  fit_analysis: FitAnalysisRecordSchema.nullable(),
+  related_history: z
+    .array(
+      z.object({
+        job: JobRecordSchema,
+        application: ApplicationRecordSchema.nullable(),
+        fit_analysis: FitAnalysisRecordSchema.nullable(),
+      }),
+    )
+    .describe('같은 회사/직무 관련 이전 기록'),
+  writing_preferences: z.object({
+    preferred_tone: z.string().nullable(),
+    emphasis_points: z.array(z.string()),
+  }),
+});
+export type ApplicationContext = z.infer<typeof ApplicationContextSchema>;