careermate 0.0.9 → 0.0.10

package/packages/core/src/reuse-insights.ts

@@ -0,0 +1,126 @@
+import { coverLetterRepo, experienceRepo, projectRepo, jobRepo } from '@careermate/db';
+
+export interface ReuseReference {
+  kind: 'experience' | 'project';
+  entity_id: string;
+  label: string;
+  cover_letters: Array<{ id: string; title: string; job_id: string | null; company: string | null; position: string | null }>;
+  reuse_count: number;
+}
+
+export interface DiffLine {
+  type: 'equal' | 'add' | 'remove';
+  text: string;
+}
+
+function containsNormalized(content: string, needle: string): boolean {
+  const normalize = (s: string) => s.toLowerCase().replace(/\s+/g, ' ').trim();
+  const n = normalize(needle);
+  return n.length >= 2 && normalize(content).includes(n);
+}
+
+export function getExperienceReuseMap(): ReuseReference[] {
+  const letters = coverLetterRepo.list().map((letter) => coverLetterRepo.get(letter.id, true)!).filter(Boolean);
+  const jobs = new Map(jobRepo.list().map((job) => [job.id, job]));
+  const refs: ReuseReference[] = [];
+
+  for (const exp of experienceRepo.list()) {
+    const needles = [exp.company, exp.role].filter((v): v is string => !!v && v.trim().length >= 2);
+    const matches = letters.filter((letter) => {
+      const body = letter.current_content ?? '';
+      return needles.some((needle) => containsNormalized(body, needle));
+    });
+    refs.push({
+      kind: 'experience',
+      entity_id: exp.id,
+      label: [exp.company, exp.role].filter(Boolean).join(' · '),
+      cover_letters: matches.map((letter) => {
+        const job = letter.job_id ? jobs.get(letter.job_id) : null;
+        return {
+          id: letter.id,
+          title: letter.title,
+          job_id: letter.job_id,
+          company: job?.company ?? null,
+          position: job?.position ?? null,
+        };
+      }),
+      reuse_count: matches.length,
+    });
+  }
+
+  for (const project of projectRepo.list()) {
+    const matches = letters.filter((letter) => containsNormalized(letter.current_content ?? '', project.name));
+    refs.push({
+      kind: 'project',
+      entity_id: project.id,
+      label: project.name,
+      cover_letters: matches.map((letter) => {
+        const job = letter.job_id ? jobs.get(letter.job_id) : null;
+        return {
+          id: letter.id,
+          title: letter.title,
+          job_id: letter.job_id,
+          company: job?.company ?? null,
+          position: job?.position ?? null,
+        };
+      }),
+      reuse_count: matches.length,
+    });
+  }
+
+  return refs.sort((a, b) => b.reuse_count - a.reuse_count || a.label.localeCompare(b.label));
+}
+
+export function diffText(before: string, after: string): DiffLine[] {
+  const a = before.replace(/\r\n/g, '\n').split('\n');
+  const b = after.replace(/\r\n/g, '\n').split('\n');
+  const rows = a.length + 1;
+  const cols = b.length + 1;
+  const dp = Array.from({ length: rows }, () => new Uint32Array(cols));
+
+  for (let i = a.length - 1; i >= 0; i--) {
+    for (let j = b.length - 1; j >= 0; j--) {
+      dp[i]![j] = a[i] === b[j] ? dp[i + 1]![j + 1]! + 1 : Math.max(dp[i + 1]![j]!, dp[i]![j + 1]!);
+    }
+  }
+
+  const result: DiffLine[] = [];
+  let i = 0;
+  let j = 0;
+  while (i < a.length && j < b.length) {
+    if (a[i] === b[j]) {
+      result.push({ type: 'equal', text: a[i]! });
+      i++;
+      j++;
+    } else if (dp[i + 1]![j]! >= dp[i]![j + 1]!) {
+      result.push({ type: 'remove', text: a[i]! });
+      i++;
+    } else {
+      result.push({ type: 'add', text: b[j]! });
+      j++;
+    }
+  }
+  while (i < a.length) result.push({ type: 'remove', text: a[i++]! });
+  while (j < b.length) result.push({ type: 'add', text: b[j++]! });
+  return result;
+}
+
+export function diffCoverLetterVersions(coverLetterId: string, beforeVersionId: string, afterVersionId: string) {
+  const letter = coverLetterRepo.get(coverLetterId, true);
+  if (!letter?.versions) return null;
+  const before = letter.versions.find((version) => version.id === beforeVersionId);
+  const after = letter.versions.find((version) => version.id === afterVersionId);
+  if (!before || !after) return null;
+  const lines = diffText(before.content, after.content);
+  return {
+    cover_letter_id: coverLetterId,
+    before: { id: before.id, version_no: before.version_no, source: before.source, created_at: before.created_at },
+    after: { id: after.id, version_no: after.version_no, source: after.source, created_at: after.created_at },
+    summary: {
+      added: lines.filter((line) => line.type === 'add').length,
+      removed: lines.filter((line) => line.type === 'remove').length,
+      unchanged: lines.filter((line) => line.type === 'equal').length,
+    },
+    lines,
+  };
+}

package/packages/db/src/connection.ts

@@ -19,7 +19,8 @@ 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.
+ * rest. A failure is intentionally surfaced: copying only the live main SQLite
+ * file while WAL is active can produce a stale or incomplete snapshot.
  */
 export function vacuumInto(db: DatabaseSync, destPath: string): void {
   if (/[\0\n\r]/.test(destPath)) throw new Error('backup path not safe for SQL literal');
@@ -28,10 +29,9 @@ export function vacuumInto(db: DatabaseSync, destPath: string): void {
 
 /**
  * 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).
+ * the user's only copy, so a schema upgrade must not proceed without a restore
+ * point. Operators may explicitly opt out for emergency recovery with
+ * CAREERMATE_ALLOW_UNBACKED_MIGRATION=1.
  */
 function preMigrationBackup(db: DatabaseSync): void {
   try {
@@ -48,11 +48,9 @@ function preMigrationBackup(db: DatabaseSync): void {
     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
-    }
+    // Never fall back to copying only the main file while WAL is active. If a
+    // consistent snapshot cannot be created, the migration must not start.
+    vacuumInto(db, dest);
 
     // Prune old snapshots (ISO stamp in the name → lexicographic sort == time sort).
     // fs.unlinkSync only — rmSync hard-crashes on Node 25/Windows.
@@ -70,9 +68,17 @@ function preMigrationBackup(db: DatabaseSync): void {
       }
     }
   } catch (err) {
-    // stderr only — stdout is the MCP transport channel.
-    console.error(
-      `[careermate] 업그레이드 전 자동 백업 실패(마이그레이션은 계속 진행): ${err instanceof Error ? err.message : String(err)}`,
+    const reason = err instanceof Error ? err.message : String(err);
+    if (process.env.CAREERMATE_ALLOW_UNBACKED_MIGRATION === '1') {
+      console.error(
+        `[careermate] 업그레이드 전 자동 백업 실패 — 명시적 우회로 마이그레이션을 계속합니다: ${reason}`,
+      );
+      return;
+    }
+    throw new Error(
+      `데이터베이스 업그레이드 전 백업을 만들지 못해 시작을 중단했습니다. ` +
+        `데이터 위치를 확인하고 다시 시도하세요. 긴급 복구 시에만 ` +
+        `CAREERMATE_ALLOW_UNBACKED_MIGRATION=1을 설정할 수 있습니다. 원인: ${reason}`,
     );
   }
 }
@@ -80,13 +86,22 @@ function preMigrationBackup(db: DatabaseSync): void {
 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;
+  try {
+    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;
+  } catch (err) {
+    try {
+      db.close();
+    } catch {
+      /* best-effort */
+    }
+    throw err;
+  }
 }
 
 export function closeDb(): void {
@@ -99,19 +114,24 @@ export function closeDb(): void {
 let _inTx = false;
 
 /**
- * Run `fn` inside a single transaction so multi-statement writes are atomic:
- * any thrown error rolls back every statement instead of leaving a half-written
- * row. node:sqlite has no transaction() helper, so we drive BEGIN/COMMIT/ROLLBACK
- * directly. Re-entrant: a nested tx() call joins the outer transaction (SQLite
- * has no nested transactions), so only the outermost call commits or rolls back.
+ * Run `fn` inside a single synchronous transaction so multi-statement writes are
+ * atomic. Promise-returning callbacks are rejected because committing before an
+ * async callback settles would silently break transaction guarantees.
  */
 export function tx<T>(fn: () => T): T {
-  if (_inTx) return fn();
+  if (_inTx) {
+    const nested = fn();
+    if (nested instanceof Promise) throw new TypeError('tx() does not accept async callbacks');
+    return nested;
+  }
   const db = getDb();
   db.exec('BEGIN');
   _inTx = true;
   try {
     const result = fn();
+    if (result instanceof Promise) {
+      throw new TypeError('tx() does not accept async callbacks');
+    }
     db.exec('COMMIT');
     return result;
   } catch (err) {

package/packages/db/src/index.ts

@@ -7,6 +7,8 @@ export * from './paths.ts';
 export * from './runtime.ts';
 export * from './connection.ts';
 export * from './settings.ts';
+export * from './provenance.ts';
+export * from './interview-retrospectives.ts';
 export { migrate, MIGRATIONS } from './schema.ts';
 export {
   profileRepo,

package/packages/db/src/interview-retrospectives.ts

@@ -0,0 +1,149 @@
+import { getDb } from './connection.ts';
+
+export interface InterviewRetrospective {
+  id: string;
+  job_id: string;
+  interview_round: string | null;
+  occurred_at: string | null;
+  questions: string[];
+  strong_answers: string[];
+  weak_answers: string[];
+  follow_up_actions: string[];
+  notes: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+function ensureTable(): void {
+  getDb().exec(`
+    CREATE TABLE IF NOT EXISTS interview_retrospectives (
+      id TEXT PRIMARY KEY,
+      job_id TEXT NOT NULL,
+      interview_round TEXT,
+      occurred_at TEXT,
+      questions TEXT NOT NULL DEFAULT '[]',
+      strong_answers TEXT NOT NULL DEFAULT '[]',
+      weak_answers TEXT NOT NULL DEFAULT '[]',
+      follow_up_actions TEXT NOT NULL DEFAULT '[]',
+      notes TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_interview_retrospectives_job
+      ON interview_retrospectives(job_id, occurred_at DESC, updated_at DESC);
+    CREATE TRIGGER IF NOT EXISTS trg_interview_retrospectives_delete_job
+      AFTER DELETE ON jobs
+      BEGIN
+        DELETE FROM interview_retrospectives WHERE job_id = OLD.id;
+      END;
+  `);
+}
+
+function parseList(value: unknown): string[] {
+  if (typeof value !== 'string') return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === 'string') : [];
+  } catch {
+    return [];
+  }
+}
+
+function map(row: any): InterviewRetrospective {
+  return {
+    id: row.id,
+    job_id: row.job_id,
+    interview_round: row.interview_round,
+    occurred_at: row.occurred_at,
+    questions: parseList(row.questions),
+    strong_answers: parseList(row.strong_answers),
+    weak_answers: parseList(row.weak_answers),
+    follow_up_actions: parseList(row.follow_up_actions),
+    notes: row.notes,
+    created_at: row.created_at,
+    updated_at: row.updated_at,
+  };
+}
+
+function id(): string {
+  return `retro_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+}
+
+export const interviewRetrospectiveRepo = {
+  listAll(limit = 100): InterviewRetrospective[] {
+    ensureTable();
+    const safeLimit = Math.max(1, Math.min(500, Math.floor(limit)));
+    return (
+      getDb()
+        .prepare(`SELECT * FROM interview_retrospectives ORDER BY occurred_at DESC, updated_at DESC LIMIT ?`)
+        .all(safeLimit) as any[]
+    ).map(map);
+  },
+
+  listByJob(jobId: string): InterviewRetrospective[] {
+    ensureTable();
+    return (
+      getDb()
+        .prepare(`SELECT * FROM interview_retrospectives WHERE job_id = ? ORDER BY occurred_at DESC, updated_at DESC`)
+        .all(jobId) as any[]
+    ).map(map);
+  },
+
+  save(input: {
+    id?: string;
+    job_id: string;
+    interview_round?: string | null;
+    occurred_at?: string | null;
+    questions?: string[];
+    strong_answers?: string[];
+    weak_answers?: string[];
+    follow_up_actions?: string[];
+    notes?: string | null;
+  }): InterviewRetrospective {
+    ensureTable();
+    const now = new Date().toISOString();
+    const recordId = input.id ?? id();
+    const existing = getDb().prepare(`SELECT * FROM interview_retrospectives WHERE id = ?`).get(recordId) as any;
+    getDb()
+      .prepare(`
+        INSERT INTO interview_retrospectives (
+          id, job_id, interview_round, occurred_at, questions, strong_answers,
+          weak_answers, follow_up_actions, notes, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET
+          job_id = excluded.job_id,
+          interview_round = excluded.interview_round,
+          occurred_at = excluded.occurred_at,
+          questions = excluded.questions,
+          strong_answers = excluded.strong_answers,
+          weak_answers = excluded.weak_answers,
+          follow_up_actions = excluded.follow_up_actions,
+          notes = excluded.notes,
+          updated_at = excluded.updated_at
+      `)
+      .run(
+        recordId,
+        input.job_id,
+        input.interview_round ?? existing?.interview_round ?? null,
+        input.occurred_at ?? existing?.occurred_at ?? null,
+        JSON.stringify(input.questions ?? parseList(existing?.questions)),
+        JSON.stringify(input.strong_answers ?? parseList(existing?.strong_answers)),
+        JSON.stringify(input.weak_answers ?? parseList(existing?.weak_answers)),
+        JSON.stringify(input.follow_up_actions ?? parseList(existing?.follow_up_actions)),
+        input.notes ?? existing?.notes ?? null,
+        existing?.created_at ?? now,
+        now,
+      );
+    return map(getDb().prepare(`SELECT * FROM interview_retrospectives WHERE id = ?`).get(recordId));
+  },
+
+  remove(retrospectiveId: string): boolean {
+    ensureTable();
+    return getDb().prepare(`DELETE FROM interview_retrospectives WHERE id = ?`).run(retrospectiveId).changes > 0;
+  },
+};
+
+// Keep the table available before settings import/export enumerates sqlite_master.
+// This also installs the job-deletion cleanup trigger for databases created before
+// interview retrospectives were introduced.
+ensureTable();

package/packages/db/src/provenance.ts

@@ -0,0 +1,125 @@
+import { getDb } from './connection.ts';
+
+export type ProvenanceSource = 'human' | 'ai' | 'import' | 'document';
+
+export interface EntityProvenance {
+  entity_type: string;
+  entity_id: string;
+  source: ProvenanceSource;
+  source_document_id: string | null;
+  source_excerpt: string | null;
+  verified_by_human: boolean;
+  verified_at: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+function ensureTable(): void {
+  getDb().exec(`
+    CREATE TABLE IF NOT EXISTS entity_provenance (
+      entity_type TEXT NOT NULL,
+      entity_id TEXT NOT NULL,
+      source TEXT NOT NULL CHECK(source IN ('human','ai','import','document')),
+      source_document_id TEXT,
+      source_excerpt TEXT,
+      verified_by_human INTEGER NOT NULL DEFAULT 0,
+      verified_at TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY(entity_type, entity_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_entity_provenance_verified
+      ON entity_provenance(verified_by_human, updated_at DESC);
+  `);
+}
+
+function map(row: any): EntityProvenance {
+  return {
+    entity_type: row.entity_type,
+    entity_id: row.entity_id,
+    source: row.source,
+    source_document_id: row.source_document_id,
+    source_excerpt: row.source_excerpt,
+    verified_by_human: Number(row.verified_by_human) === 1,
+    verified_at: row.verified_at,
+    created_at: row.created_at,
+    updated_at: row.updated_at,
+  };
+}
+
+export const provenanceRepo = {
+  get(entityType: string, entityId: string): EntityProvenance | null {
+    ensureTable();
+    const row = getDb()
+      .prepare(`SELECT * FROM entity_provenance WHERE entity_type = ? AND entity_id = ?`)
+      .get(entityType, entityId);
+    return row ? map(row) : null;
+  },
+
+  listUnverified(): EntityProvenance[] {
+    ensureTable();
+    return (
+      getDb()
+        .prepare(`SELECT * FROM entity_provenance WHERE verified_by_human = 0 ORDER BY updated_at DESC`)
+        .all() as any[]
+    ).map(map);
+  },
+
+  save(input: {
+    entity_type: string;
+    entity_id: string;
+    source: ProvenanceSource;
+    source_document_id?: string | null;
+    source_excerpt?: string | null;
+    verified_by_human?: boolean;
+  }): EntityProvenance {
+    ensureTable();
+    const existing = this.get(input.entity_type, input.entity_id);
+    const now = new Date().toISOString();
+    const verified = input.verified_by_human ?? existing?.verified_by_human ?? input.source === 'human';
+    const verifiedAt = verified ? existing?.verified_at ?? now : null;
+    getDb()
+      .prepare(`
+        INSERT INTO entity_provenance (
+          entity_type, entity_id, source, source_document_id, source_excerpt,
+          verified_by_human, verified_at, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(entity_type, entity_id) DO UPDATE SET
+          source = excluded.source,
+          source_document_id = excluded.source_document_id,
+          source_excerpt = excluded.source_excerpt,
+          verified_by_human = excluded.verified_by_human,
+          verified_at = excluded.verified_at,
+          updated_at = excluded.updated_at
+      `)
+      .run(
+        input.entity_type,
+        input.entity_id,
+        input.source,
+        input.source_document_id ?? existing?.source_document_id ?? null,
+        input.source_excerpt ?? existing?.source_excerpt ?? null,
+        verified ? 1 : 0,
+        verifiedAt,
+        existing?.created_at ?? now,
+        now,
+      );
+    return this.get(input.entity_type, input.entity_id)!;
+  },
+
+  setHumanVerified(entityType: string, entityId: string, verified: boolean): EntityProvenance {
+    const existing = this.get(entityType, entityId);
+    return this.save({
+      entity_type: entityType,
+      entity_id: entityId,
+      source: existing?.source ?? 'human',
+      source_document_id: existing?.source_document_id,
+      source_excerpt: existing?.source_excerpt,
+      verified_by_human: verified,
+    });
+  },
+};
+
+// Backup import discovers allowed tables from sqlite_master before any provenance
+// endpoint is called. Create this sidecar table when @careermate/db loads so a
+// backup made on another machine is accepted on a completely fresh installation.
+ensureTable();

package/packages/prompts/src/system.ts

@@ -1,67 +1,24 @@
 /**
- * @careermate/prompts — system.ts
+ * Global MCP operating rules.
  *
- * CAREERMATE_SYSTEM_PROMPT teaches an AI assistant (ChatGPT / Claude / Gemini)
- * HOW to behave as a good CareerMate operator. CareerMate itself contains no LLM;
- * the user's own AI does all reading, analysis, and writing through MCP tools.
- *
- * Written in Korean: it is read both by Korean users and by the AI on their behalf.
+ * Keep this prompt intentionally short. Detailed sequencing belongs in
+ * get_workflow_guide/context responses so clients do not receive duplicated or
+ * conflicting routing instructions on every turn.
  */
-
-export const CAREERMATE_SYSTEM_PROMPT = `당신은 사용자의 'CareerMate' 커리어 비서입니다.
-
-CareerMate는 사용자의 컴퓨터에서 동작하는 로컬 커리어 관리 도구이며, MCP(툴 호출)를 통해 사용자의 프로필·이력서·자기소개서·지원 공고·지원 현황 데이터를 읽고 씁니다. CareerMate 안에는 별도의 AI가 없습니다. 모든 분석·작성·요약은 '당신'(사용자의 AI)이 MCP 툴을 호출해 수행합니다.
-
-# 핵심 행동 원칙
-
-1. 항상 맥락을 먼저 불러옵니다.
-   - 공고를 분석하거나 자기소개서를 쓰기 전에는 반드시 \`get_application_context\`를 먼저 호출하세요. 이 한 번의 호출로 프로필, 대표 이력서, 경력(experiences), 프로젝트(projects), 스킬(skills), 기존 자기소개서, 최근 지원 현황, 대상 공고(job_id 전달 시), 이전 적합도 분석, 같은 회사/직무 관련 기록, 그리고 사용자의 글쓰기 선호(선호 문체 preferred_tone + 강조 포인트 emphasis_points)를 한꺼번에 받습니다.
-   - 일반적인 상태 확인이 필요하면 \`get_onboarding_status\`, \`get_profile\`, \`get_resumes\`, \`get_cover_letters\`, \`list_recent_activity\` 등 읽기 툴을 적극 사용하세요.
-   - 기억에 의존하지 말고, 매 작업 시작 시 실제 데이터를 다시 불러오세요.
-
-2. 결과는 반드시 다시 저장합니다.
-   - 분석·작성한 내용은 머릿속이나 대화창에만 남기지 말고 해당 저장 툴로 CareerMate에 기록하세요: 공고는 \`save_job_posting\`, 적합도 분석은 \`save_fit_analysis\`, 자기소개서 버전은 \`save_cover_letter_version\`, 경력기술서는 \`add_resume\`(kind=career_description), 면접 준비는 \`save_interview_prep\`, 상태 변경은 \`update_application_status\`.
-   - 여러 문서를 한 번에 요청받아도 각 문서는 각자의 저장 툴로 따로 저장하세요. 경력기술서와 자기소개서를 한 턴에 함께 만들었더라도 한 저장 호출의 본문에 다른 문서를 이어붙이지 마세요(경력기술서=\`add_resume\` kind=career_description, 자기소개서=\`save_cover_letter_version\`로 각각 분리 저장).
-   - 저장 후에는 무엇이 저장되었는지 사용자에게 간단히 알려주세요.
-
-3. 데이터를 지어내지 않습니다.
-   - 프로필·경력·성과·수치·회사명 등은 사용자가 제공했거나 CareerMate에 저장된 것만 사용하세요. 불확실하면 추측하지 말고 사용자에게 물어보세요.
-   - 자기소개서에 검증되지 않은 경험이나 과장된 성과를 넣지 마세요. 빈칸이 있으면 "이 부분은 확인이 필요합니다"라고 표시하고 사용자에게 확인을 요청하세요.
-
-4. 로컬-퍼스트 / 프라이버시를 존중합니다.
-   - 모든 데이터는 사용자의 컴퓨터에만 저장됩니다. 데이터를 외부로 보내거나 다른 용도로 쓰지 마세요.
-   - 민감 정보(연락처, 주소 등)는 꼭 필요한 작업에만 사용하고 불필요하게 노출하지 마세요.
-
-5. 자기소개서는 작성 전 확인을 받습니다.
-   - 자기소개서나 경력기술서를 새로 쓰거나 크게 고치기 전에, 어떤 공고/직무를 대상으로 어떤 톤과 강조점으로 쓸지 사용자에게 먼저 확인하세요.
-   - 작성 후에는 \`save_cover_letter_version\`으로 버전을 저장하고, 변경 요약을 \`note\`에 남기세요. 사용자가 원하면 \`export_cover_letter\`로 내보내세요.
-
-6. 사용자에게는 사용자의 언어로 쉽게 알립니다.
-   - **응답 언어 = 사용자의 언어.** 사용자가 한국어로 말하면 한국어로, 영어 등 다른 언어로 말하면 그 언어로 답합니다. 이 지침·도구 응답·플레이북이 한국어로 적혀 있어도 그대로 복사하지 말고 사용자 언어로 옮겨 전달하세요(사실·수치·고유명사는 보존).
-   - "MCP", "툴 호출", "job_id" 같은 기술 용어는 사용자에게 직접 노출하지 마세요. "공고를 저장했어요", "적합도를 분석했어요"처럼 일상적인 표현으로 진행 상황을 알리세요.
-   - 도구 응답에 \`user_message\`가 있으면 사용자에게 보고할 때 그 내용을 우선 활용하되, 사용자가 한국어가 아닌 언어로 대화하면 한국어 원문을 그대로 복사하지 말고 사용자 언어로 옮겨 전달하세요. \`id\`, \`job_id\`, \`cover_letter_id\`, \`workflow_id\`, JSON 원문, 도구 이름은 내부 작업용으로만 쓰고 사용자에게 그대로 복사하지 마세요.
-   - 도구 응답에 \`suggested_next_action\`이 있으면 다음 행동을 강요하지 말고 선택지로 제안하세요.
-   - 무엇을 했고, 무엇을 알게 되었고, 다음에 무엇을 할 수 있는지 짧고 명확하게 전달하세요.
-
-7. 다음 단계를 먼저 제안합니다.
-   - 작업이 끝나면 자연스러운 다음 행동을 제안하세요. 예: 공고 분석 후 → "이 공고에 맞춘 자기소개서를 써드릴까요?", 경력기술서 저장 후 → "이 공고에 맞춰 자기소개서도 정리할까요?", 자기소개서 저장 후 → "지원 상태를 '지원 완료'로 바꿀까요?", 상태가 '서류 합격'이 되면 → "면접 준비를 도와드릴까요?".
-   - 공고 분석 후에는 곧장 자기소개서를 쓰지 말고, 반드시 선택지를 보여주세요: "1. 네, 이 공고에 맞춘 자기소개서를 써줘" / "2. 아니요, 분석만 저장해줘". 사용자가 1번을 고른 경우에만 자기소개서 작성 흐름으로 이어갑니다.
-   - \`get_onboarding_status\`의 next_steps나 \`open_dashboard\`/\`open_application\`을 활용해 사용자를 다음 행동으로 안내하세요.
-
-8. 업데이트 요청은 명확하게 처리합니다.
-   - 사용자가 "최신이야?", "업데이트 있어?"처럼 확인만 요청하면 \`check_for_update\`를 호출하고 결과를 쉬운 말로 알려주세요.
-   - 사용자가 "업데이트해줘", "CareerMate 업데이트해줘", "최신으로 올려줘"처럼 적용을 명시하면 \`update_careermate\`를 바로 호출하세요. 이 도구가 최신 버전 확인도 함께 합니다.
-   - 업데이트 성공 후에는 적용하려면 AI 앱 또는 MCP 연결을 재시작해야 한다고 안내하세요. 사용자 커리어 데이터는 로컬에 보존되고, npm에는 공개 버전 정보 확인/설치 요청만 나갑니다.
-
-9. 글은 AI 티 안 나게 씁니다.
-   - 자기소개서·자기 PR·지원 메일 등 사람이 쓴 듯한 글을 작성하기 직전에는 \`get_writing_style_guide\`를 호출해 글쓰기 규칙을 가져오고 그대로 적용하세요.
-   - 번역투, "열정을 가지고/귀사의 발전에 기여" 같은 클리셰, 기계적 병렬(첫째·둘째·셋째), 상투적 연결어, 균일한 문장 리듬을 피하고 담백하고 구체적으로 씁니다. 단, 사실·수치·고유명사는 절대 바꾸거나 지어내지 않습니다. 이 AI-tell 목록은 한국어 글 기준이며, 다른 언어로 쓸 때는 같은 원리를 그 언어의 자연스러운 관습으로 적용합니다(산출물 언어·관행은 대상 공고·시장을 따름).
-
-10. 전문가 절차로 만들고, 저장 전 당신이 자가검증합니다.
-   - 공고 분석·자소서·경력기술서·면접 자료처럼 사용자 대면 결과를 만들기 전에는, 즉답하지 말고 \`get_workflow_guide\`(workflow_id 지정)를 먼저 호출해 그 작업의 전문가 실행 절차(EOP)와 적용할 플레이북·검증기 순서를 받으세요. 이어 \`get_playbook\`으로 도메인 지식을 받아 작성하고, save로 저장하기 직전 \`get_verifier\`로 검증 루브릭을 받아 **당신이 직접** 점검·수정한 뒤 저장합니다.
-   - CareerMate는 슬롭 밀도·키워드 매칭처럼 셀 수 있는 항목만 보조로 돕고, 의미 판단(이 글이 질문에 답하는가·톤이 맞는가)은 당신이 합니다. 사실·수치·고유명사는 그대로 보존합니다.
-
-# 작업 방식 요약
-- 읽기(get_*) → 분석/작성 → 저장(save_*/update_*) → 사용자에게 쉬운 말로 보고 → 다음 단계 제안.
-- 8가지 지원 상태: 작성 중(draft), 지원 예정(planned), 지원 완료(applied), 서류 합격(document_passed), 면접 진행(interview), 최종 합격(final_passed), 불합격(rejected), 보류(on_hold).
-- 의심스러우면 멈추고 묻습니다. 사용자의 커리어가 걸린 일이므로 정확함이 속도보다 중요합니다.`;
+export const CAREERMATE_SYSTEM_PROMPT = `당신은 사용자의 CareerMate 커리어 비서입니다. CareerMate는 사용자의 로컬 데이터베이스와 문서 저장소이며, 분석과 작성은 연결된 AI가 수행합니다.
+
+# 불변 규칙
+1. 작업에 필요한 사용자·공고 컨텍스트만 먼저 조회합니다. 전체 데이터를 습관적으로 불러오지 않습니다.
+2. 회사, 역할, 기술, 기간, 수치, 성과를 만들거나 과장하지 않습니다. 공고 요구사항을 사용자 경험처럼 쓰지 않습니다.
+3. 사용자 확인 사실, AI가 구조화한 미확인 정보, AI의 추정을 명확히 구분합니다.
+4. 저장 전 사실·수치·기간·개인 기여·문서 간 일관성을 검증합니다. 불확실한 내용은 문장에 넣지 말고 최대 3~5개의 구체적인 확인 질문으로 반환합니다.
+5. 결과물에는 사용한 근거, 미확인 항목, 위험 또는 경고를 함께 반환합니다. 수치는 확인된 구조화 데이터나 source excerpt가 있을 때만 사용합니다.
+6. 서로 다른 문서는 각 전용 저장 도구를 사용합니다. 사용자가 저장을 요청하지 않았거나 초안 검토만 요청한 경우 임의로 저장하지 않습니다.
+7. 삭제·초기화·복원·덮어쓰기·업데이트처럼 데이터나 실행 환경을 바꾸는 작업은 영향과 대상을 설명하고 사용자의 명시적 확인 후 실행합니다.
+8. 외부 통신이 필요한 기능은 로컬 작업과 구분해 알립니다. 저장된 커리어 원문이나 개인정보를 외부로 보내지 않습니다.
+9. 사용자 언어와 대상 문서의 언어를 유지합니다. 내부 ID, 도구 이름, 원시 JSON, 로컬 경로, SQL 및 스택 추적을 사용자에게 노출하지 않습니다.
+10. 구체 절차와 다음 도구는 get_workflow_guide 또는 현재 context 응답의 recommended route를 따릅니다. 같은 조회·검증 도구를 이유 없이 반복 호출하지 않습니다.
+11. 이력서·자기소개서·면접 답변은 사용자가 실제 면접에서 설명 가능한 수준으로 작성하며, 팀 성과와 개인 기여를 구분합니다.
+12. 글은 화려함보다 구체성·사실성·가독성을 우선합니다. 번역투, 클리셰, 키워드 도배, 균일한 AI 문체를 피하되 사실은 바꾸지 않습니다.
+
+사용자에게는 무엇을 확인했고 무엇이 미확인인지 짧고 명확하게 설명합니다.`;

package/tsconfig.json

@@ -13,17 +13,16 @@
     "forceConsistentCasingInFileNames": true,
     "allowImportingTsExtensions": true,
     "noEmit": true,
-    "baseUrl": ".",
     "paths": {
-      "@careermate/shared": ["packages/shared/src/index.ts"],
-      "@careermate/db": ["packages/db/src/index.ts"],
-      "@careermate/core": ["packages/core/src/index.ts"],
-      "@careermate/mcp-tools": ["packages/mcp-tools/src/index.ts"],
-      "@careermate/exporters": ["packages/exporters/src/index.ts"],
-      "@careermate/parsers": ["packages/parsers/src/index.ts"],
-      "@careermate/prompts": ["packages/prompts/src/index.ts"],
-      "@careermate/workflows": ["packages/workflows/src/index.ts"],
-      "@careermate/knowledge": ["packages/knowledge/src/index.ts"]
+      "@careermate/shared": ["./packages/shared/src/index.ts"],
+      "@careermate/db": ["./packages/db/src/index.ts"],
+      "@careermate/core": ["./packages/core/src/index.ts"],
+      "@careermate/mcp-tools": ["./packages/mcp-tools/src/index.ts"],
+      "@careermate/exporters": ["./packages/exporters/src/index.ts"],
+      "@careermate/parsers": ["./packages/parsers/src/index.ts"],
+      "@careermate/prompts": ["./packages/prompts/src/index.ts"],
+      "@careermate/workflows": ["./packages/workflows/src/index.ts"],
+      "@careermate/knowledge": ["./packages/knowledge/src/index.ts"]
     }
   },
   "include": ["packages/**/*.ts", "apps/**/*.ts", "scripts/**/*.ts"],