careermate 0.0.9 → 0.0.12

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,9 @@ 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 * from './job-search.ts';
 export { migrate, MIGRATIONS } from './schema.ts';
 export {
   profileRepo,

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

@@ -0,0 +1,145 @@
+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 REFERENCES jobs(id) ON DELETE CASCADE,
+      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);
+    DROP TRIGGER IF EXISTS trg_interview_retrospectives_delete_job;
+  `);
+}
+
+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/job-search.ts

@@ -0,0 +1,100 @@
+import { getDb, tx } from './connection.ts';
+
+/**
+ * Job-search state, in real tables (not `_meta`) so backup, export and reset cover it:
+ *  - job_search_seen: first/last sighting of each posting search_jobs returned, keyed by
+ *    (source, external_id). Wanted/Jumpit lists carry no posting date, so "posted since"
+ *    for them falls back to first_seen_at. Only board ids and dates, never content.
+ *  - job_search_preferences: the saved conditions search_jobs uses when called without
+ *    its own keyword/category (single row).
+ */
+function ensureTables(): void {
+  getDb().exec(`
+    CREATE TABLE IF NOT EXISTS job_search_seen (
+      source TEXT NOT NULL,
+      external_id TEXT NOT NULL,
+      first_seen_at TEXT NOT NULL,
+      last_seen_at TEXT NOT NULL,
+      PRIMARY KEY (source, external_id)
+    );
+    CREATE TABLE IF NOT EXISTS job_search_preferences (
+      id INTEGER PRIMARY KEY CHECK (id = 1),
+      keyword TEXT NOT NULL DEFAULT '',
+      remember_categories TEXT NOT NULL DEFAULT '[]',
+      saramin_categories TEXT NOT NULL DEFAULT '[]',
+      updated_at TEXT NOT NULL
+    );
+  `);
+}
+
+/** A posting not returned by any search for this long is forgotten (and counts as new if it reappears). */
+const FORGET_AFTER_DAYS = 120;
+
+/** Record the given postings as seen today and return each one's first-seen date (YYYY-MM-DD), keyed "source:external_id". */
+export function markJobsSeen(items: { source: string; external_id: string }[], today: string): Map<string, string> {
+  const seen = new Map<string, string>();
+  if (!items.length) return seen;
+  const db = getDb();
+  const upsert = db.prepare(
+    `INSERT INTO job_search_seen (source, external_id, first_seen_at, last_seen_at) VALUES (?, ?, ?, ?)
+     ON CONFLICT(source, external_id) DO UPDATE SET last_seen_at = excluded.last_seen_at
+     RETURNING first_seen_at`,
+  );
+  tx(() => {
+    for (const it of items) {
+      const row = upsert.get(it.source, it.external_id, today, today) as { first_seen_at: string } | undefined;
+      seen.set(`${it.source}:${it.external_id}`, row?.first_seen_at ?? today);
+    }
+    db.prepare(`DELETE FROM job_search_seen WHERE last_seen_at < date(?, ?)`).run(today, `-${FORGET_AFTER_DAYS} days`);
+  });
+  return seen;
+}
+
+export interface JobSearchPreferences {
+  keyword: string;
+  remember_categories: string[];
+  saramin_categories: string[];
+  updated_at: string | null;
+}
+
+function parseList(value: unknown): string[] {
+  try {
+    const parsed = JSON.parse(String(value));
+    return Array.isArray(parsed) ? parsed.filter((v) => typeof v === 'string') : [];
+  } catch {
+    return [];
+  }
+}
+
+export function getJobSearchPreferences(): JobSearchPreferences {
+  const row = getDb().prepare(`SELECT * FROM job_search_preferences WHERE id = 1`).get() as
+    | Record<string, unknown>
+    | undefined;
+  return {
+    keyword: typeof row?.keyword === 'string' ? row.keyword : '',
+    remember_categories: parseList(row?.remember_categories ?? '[]'),
+    saramin_categories: parseList(row?.saramin_categories ?? '[]'),
+    updated_at: typeof row?.updated_at === 'string' ? row.updated_at : null,
+  };
+}
+
+/** Only the given fields change; an empty string/array clears that field. */
+export function setJobSearchPreferences(
+  prefs: Partial<Omit<JobSearchPreferences, 'updated_at'>>,
+): JobSearchPreferences {
+  const next = { ...getJobSearchPreferences(), ...prefs, updated_at: new Date().toISOString() };
+  getDb()
+    .prepare(
+      `INSERT INTO job_search_preferences (id, keyword, remember_categories, saramin_categories, updated_at)
+       VALUES (1, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET keyword = excluded.keyword, remember_categories = excluded.remember_categories,
+         saramin_categories = excluded.saramin_categories, updated_at = excluded.updated_at`,
+    )
+    .run(next.keyword, JSON.stringify(next.remember_categories), JSON.stringify(next.saramin_categories), next.updated_at);
+  return next;
+}
+
+// Backup import accepts only tables that already exist, so create these when @careermate/db
+// loads (same as provenance.ts): a backup from a machine that has searched must restore on a
+// fresh install that never has.
+ensureTables();

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/db/src/repositories.ts

@@ -758,6 +758,7 @@ export const jobRepo = {
       db.prepare(`DELETE FROM fit_analyses WHERE job_id=?`).run(id);
       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 interview_retrospectives 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).