careermate 0.0.1 → 0.0.2

package/packages/core/src/services.ts

@@ -41,7 +41,50 @@ import {
   projectRepo,
   skillRepo,
   activityRepo,
+  getVerifyStrict,
 } from '@careermate/db';
+import { lintArtifact, type VerifyCorpus, type LintReport } from './verify/index.ts';
+
+/**
+ * Collect the user's stored facts (zero-ai) in THREE separate scopes so the
+ * verify engine can tier a claim's provenance:
+ *  - documents:  the user's actual résumé/document TEXT (excl. AI-generated docs)
+ *                — the strongest "user provided this" anchor → full support.
+ *  - structured: experiences/projects/skills. CareerMate is MCP-first and the AI
+ *                is the sole writer of these, so a number that lives ONLY here
+ *                (and not in the document text) can't be verified → advisory.
+ *                This de-silences the "fabricate a record then cite it" bypass.
+ *  - job:        the posting (can't license an applicant's performance claim).
+ */
+export function collectVerifyCorpus(jobId?: string | null): VerifyCorpus {
+  const documents: string[] = [];
+  for (const d of documentRepo.list()) {
+    if (d.source !== 'ai') documents.push(d.content); // exclude AI-written docs
+  }
+  const structured: string[] = [];
+  for (const e of experienceRepo.list()) {
+    structured.push([e.company, e.role, e.description, ...(e.achievements ?? []), ...(e.tech ?? [])].filter(Boolean).join('\n'));
+  }
+  for (const p of projectRepo.list()) {
+    structured.push([p.name, p.description, ...(p.highlights ?? []), ...(p.tech ?? [])].filter(Boolean).join('\n'));
+  }
+  for (const s of skillRepo.list()) {
+    structured.push([s.name, s.level, s.years != null ? `${s.years}년` : ''].filter(Boolean).join(' '));
+  }
+  const job = jobId ? jobRepo.get(jobId) : null;
+  const jobText = job ? [job.description, ...(job.requirements ?? []), ...(job.keywords ?? [])].filter(Boolean).join('\n') : '';
+  return { documents: documents.join('\n'), structured: structured.join('\n'), job: jobText };
+}
+
+/**
+ * Read-only preview of the deterministic cover-letter checks (no save).
+ * `strict` overrides the persisted mode for this one call (one-shot strict).
+ */
+export function previewCoverLetter(text: string, jobId?: string | null, strict?: boolean): LintReport {
+  return lintArtifact('cover_letter', text, collectVerifyCorpus(jobId), {
+    strict: strict ?? getVerifyStrict(),
+  });
+}
 
 /* ----------------------------------------------------------------- Profile */
 
@@ -107,7 +150,23 @@ export function saveFitAnalysis(input: FitAnalysisInput): FitAnalysisRecord {
 
 /* ----------------------------------------------------------- Cover letters */
 
-export function saveCoverLetterVersion(input: CoverLetterVersionInput) {
+export function saveCoverLetterVersion(input: CoverLetterVersionInput & { force?: boolean; strict?: boolean }) {
+  // Deterministic save-gate: block suspected fabricated quantified claims (numbers
+  // that don't trace to the user's stored facts) unless the caller forces it.
+  // Style slop / job-sourced numbers are advisory only — they never block.
+  // Strict mode (persisted, or one-shot via input.strict) also blocks numbers
+  // backed only by structured records, not the user's résumé document.
+  const strict = input.strict ?? getVerifyStrict();
+  const verification = lintArtifact('cover_letter', input.content, collectVerifyCorpus(input.job_id), { strict });
+  const forced = verification.blocking.length > 0 && input.force === true;
+  if (verification.blocking.length > 0 && !forced) {
+    const detail = verification.blocking.map((b) => `${b.label}: ${b.detail}`).join('; ');
+    const strictHit = verification.blocking.some((b) => b.id === 'unverified_numbers_strict');
+    const tail = strictHit
+      ? `엄격 모드가 켜져 있어, 올린 이력서 본문에 없는 수치는 막힙니다. 이력서를 올리거나 엄격 모드를 끄거나, 의도한 값이면 force: true로 저장하세요.`
+      : `이 수치는 저장된 경력·이력서·프로젝트에 없습니다. 원본 데이터의 실제 수치로 고치거나, 의도한 값이 맞다면 먼저 경력/프로젝트에 그 수치를 추가한 뒤 다시 저장하세요(그대로 저장하려면 force: true).`;
+    throw new Error(`저장 전 자동 점검에서 막혔습니다 — ${detail}. ${tail}`);
+  }
   const { coverLetter, version } = coverLetterRepo.addVersion({
     cover_letter_id: input.cover_letter_id,
     title: input.title,
@@ -130,7 +189,7 @@ export function saveCoverLetterVersion(input: CoverLetterVersionInput) {
     'cover_letter',
     coverLetter.id,
   );
-  return { coverLetter, version };
+  return { coverLetter, version, verification, forced };
 }
 
 /* ------------------------------------------------- Application status flow */

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

@@ -0,0 +1,11 @@
+/**
+ * @careermate/core/verify — deterministic, LLM-free verification primitives.
+ *
+ * The "machine check, not self-grade" layer: number/fact provenance (hard gate
+ * for suspected fabrication) + Korean style lint (advisory). Pure functions; the
+ * corpus is collected from the DB by services.ts so the connected AI can never
+ * inject support values (zero-ai invariant).
+ */
+export * from './normalize.ts';
+export * from './lexicons.ts';
+export * from './lint.ts';

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

@@ -0,0 +1,149 @@
+/**
+ * Banned-pattern lexicons for the deterministic style lint (advisory only — never
+ * a hard gate). Sourced from the cover-letter (R2/R3/R11) and human-writing
+ * playbooks under docs/career-os/knowledge. Korean-first, because the real
+ * "AI-tell" in Korean is 번역투 *grammar*, not the English `delve` wordlist.
+ *
+ * Each entry: a stable id, a human label, and a compiled global regex. Patterns
+ * are literal alternations (no user input) → ReDoS-safe, compiled once.
+ */
+
+export interface Lexicon {
+  id: string;
+  label: string;
+  regex: RegExp;
+}
+
+const G = (src: string, flags = 'g') => new RegExp(src, flags);
+
+/** R2 — generic/cliché openers that make a letter swappable across companies. */
+export const GENERIC_OPENERS: Lexicon = {
+  id: 'generic_opener',
+  label: '제너릭·상투적 도입(회사명 바꿔도 말이 되는 시작)',
+  regex: G(
+    [
+      'i am writing to apply',
+      'i have always been passionate',
+      'as a recent graduate',
+      'to whom it may concern',
+      '지원하게 되었습니다',
+      '지원합니다',
+      '어릴 ?적부터',
+      '보며 자랐습니다',
+      '저는 .{0,10}한 사람입니다',
+      '평소 .{0,14}관심이 많아',
+      '항상 .{0,12}믿어',
+      '데이터의 힘을 믿',
+    ].join('|'),
+    'gi',
+  ),
+};
+
+/** R3 — empty self-describing adjectives / closers used without evidence. */
+export const EMPTY_ADJECTIVES: Lexicon = {
+  id: 'empty_adjective',
+  label: '증거 없는 평가형 형용사·자기서술',
+  regex: G(
+    [
+      '성실(하|한|함)',
+      '책임감이 강',
+      '열정(을 가지|적)',
+      '소통을 잘',
+      '커뮤니케이션이 원활',
+      '꼼꼼(하|한|함)',
+      '끈기(있|가)',
+      '헌신적',
+      '주도적인',
+      '성장하는 인재',
+      '라고 생각합니다',
+      '많은 것을 배웠',
+      '통해 성장',
+      '기여하고 싶',
+      '최선을 다',
+      '보탬이 되겠',
+      'team player',
+      'hard-?working',
+      'detail-?oriented',
+      'motivated',
+      'proactive',
+      'dedicated',
+      'diligent',
+    ].join('|'),
+    'gi',
+  ),
+};
+
+/** Cliché phrases — empty buzz that appears in any letter. */
+export const CLICHES: Lexicon = {
+  id: 'cliche',
+  label: 'AI 클리셰·공허한 상투어',
+  regex: G(
+    [
+      '급변하는 시대',
+      '4차 산업혁명',
+      '끊임없는 노력',
+      '귀사의 발전에 기여',
+      '귀사',
+      '소통과 협업',
+      '글로벌 인재',
+      '무한한 가능성',
+      '한 단계 더 성장',
+    ].join('|'),
+  ),
+};
+
+/** 번역투 — translationese grammar; the real Korean AI-tell that vf-human-voice missed. */
+export const TRANSLATIONESE: Lexicon = {
+  id: 'translationese',
+  label: '번역투 문법(영어 직역체)',
+  regex: G(
+    [
+      '에 대한',
+      '을 통해',
+      '를 통해',
+      '에 있어서',
+      '라는 점에서',
+      '가지고 있습니다',
+      '되어졌',
+      '되어집니다',
+      '함으로써',
+      '에 다름 아니',
+      '진행하였습니다',
+    ].join('|'),
+  ),
+};
+
+/** Hype adverbs/adjectives — drop and let verbs/nouns carry. */
+export const HYPE: Lexicon = {
+  id: 'hype',
+  label: '과장 수식어',
+  regex: G(['매우', '정말로', '탁월(한|하게)', '성공적으로', '완벽(한|하게)', '엄청난', '획기적'].join('|')),
+};
+
+/** R11 — blind-hiring guardrail: job-irrelevant personal info (NCS 공정채용). */
+export const BLIND_PII: Lexicon = {
+  id: 'blind_pii',
+  label: '블라인드 채용 위반 소지(직무무관 개인정보)',
+  regex: G(['\\d{2,3}\\s?세', '사진\\s?첨부', '가족관계', '본적', '출신지', '생년월일'].join('|')),
+};
+
+/** All advisory style lexicons, in display order. */
+export const STYLE_LEXICONS: Lexicon[] = [
+  GENERIC_OPENERS,
+  EMPTY_ADJECTIVES,
+  CLICHES,
+  TRANSLATIONESE,
+  HYPE,
+  BLIND_PII,
+];
+
+/** Count regex hits in already-normalized text, returning bounded snippets. */
+export function countHits(lex: Lexicon, text: string, maxHits = 8): { count: number; hits: string[] } {
+  const hits: string[] = [];
+  let count = 0;
+  for (const m of text.matchAll(lex.regex)) {
+    count++;
+    if (hits.length < maxHits) hits.push(m[0].trim());
+  }
+  return { count, hits };
+}

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

@@ -0,0 +1,248 @@
+/**
+ * Deterministic verify engine — the "machine check, not self-grade" layer.
+ *
+ * NO LLM. NO DB. Pure functions over (output text, stored corpus). The caller
+ * (services.ts) collects the corpus from the DB so the AI can't inject support
+ * values (zero-ai). Two jobs:
+ *
+ *  1. Number/fact provenance (the hard gate): every refutable quantified claim
+ *     in the output must be *supported* — present in, or server-derivable from,
+ *     the user's stored facts (same segment + same unit only). Unsupported
+ *     high-risk numbers = suspected fabrication → block unless force.
+ *  2. Style lint (advisory only): slop / 번역투 / generic openers / blind-PII.
+ *
+ * Source-scope rule (Codex review): a job posting's numbers must NOT support an
+ * applicant's *performance* claim ("5년 이상" in the JD can't license "5년 경험").
+ * Applicant claims are supported only by the applicant corpus; numbers that only
+ * match the job corpus are surfaced as an advisory, never as clean support.
+ */
+import {
+  extractNumbers,
+  buildCorpus,
+  normalizeText,
+  type Corpus,
+  type NumberToken,
+} from './normalize.ts';
+import { STYLE_LEXICONS, countHits } from './lexicons.ts';
+
+export type Severity = 'critical' | 'warn' | 'info';
+
+export interface Signal {
+  id: string;
+  label: string;
+  severity: Severity;
+  count: number;
+  hits: string[];
+}
+
+export interface UnsupportedNumber {
+  raw: string;
+  value: number;
+  unit: string;
+  /**
+   * 'fabricated'      — matches nothing the user stored (blocking).
+   * 'structured_only' — only in a structured record (experience/project/skill),
+   *                     NOT in the user's actual résumé/document text. The AI is
+   *                     the sole writer of structured records, so this can't be
+   *                     verified → advisory, surfaced (de-silences the
+   *                     fabricate-a-record-then-cite-it bypass).
+   * 'job_only'        — only in the job posting (don't claim as your own).
+   */
+  reason: 'fabricated' | 'structured_only' | 'job_only';
+}
+
+export interface ProvenanceResult {
+  /** Count of risk-bearing (refutable) numbers checked. */
+  checked: number;
+  /** Traced to the user's actual résumé/document text (or derivable from it). */
+  supported: number;
+  /** Explained by nothing the user stored → suspected fabrication (blocking). */
+  fabricated: UnsupportedNumber[];
+  /** Only in a structured record, not in the résumé text → advisory (verify). */
+  unverified: UnsupportedNumber[];
+  /** Only in the job posting → advisory (don't claim as your own). */
+  jobSourced: UnsupportedNumber[];
+}
+
+export interface LintReport {
+  kind: 'cover_letter' | 'fit' | 'interview' | 'resume';
+  charCount: number;
+  /** Advisory style signals (never block). */
+  signals: Signal[];
+  provenance: ProvenanceResult;
+  /** Hard-gate violations (block save unless force). Empty = nothing to block. */
+  blocking: { id: string; label: string; detail: string }[];
+  /** Whether a stored corpus existed to verify against (else provenance is N/A). */
+  corpusAvailable: boolean;
+  /** Whether strict provenance mode was applied (structured-only numbers block). */
+  strict: boolean;
+  disclaimer: string;
+}
+
+export interface LintOptions {
+  /**
+   * Strict provenance: also block numbers that live ONLY in structured records
+   * (not the user's résumé document). Opt-in — raises "advisory" to "blocking".
+   */
+  strict?: boolean;
+}
+
+const within = (a: number, b: number) => Math.abs(a - b) <= Math.max(0.5, 0.02 * Math.max(Math.abs(a), Math.abs(b)));
+const approx = (a: number, b: number) => Math.abs(a - b) <= Math.max(0.5, 0.01 * Math.max(Math.abs(a), Math.abs(b)));
+
+/**
+ * Is `token` explained by the corpus — literally/rounded (same unit, anywhere),
+ * or by a bounded same-segment + same-unit derivation? Percent claims may be
+ * derived from a single same-unit pair within one segment (ratio / % change).
+ */
+function isExplained(token: NumberToken, corpus: Corpus): boolean {
+  const v = token.value;
+  // 1) literal / rounding membership, unit-aware.
+  for (const s of corpus.byUnit.get(token.unit) ?? []) if (within(v, s)) return true;
+  // 2) sum / difference of two same-unit numbers within ONE segment.
+  for (const seg of corpus.segments) {
+    const vals = seg.get(token.unit);
+    if (vals && vals.length >= 2) {
+      for (let i = 0; i < vals.length; i++)
+        for (let j = 0; j < vals.length; j++) {
+          if (i === j) continue;
+          if (approx(v, vals[i] - vals[j]) || approx(v, vals[i] + vals[j])) return true;
+        }
+    }
+  }
+  // 3) percentages: ratio / %-change of a same-unit pair within one segment.
+  if (token.unit === '%') {
+    for (const seg of corpus.segments) {
+      for (const [u, vals] of seg) {
+        if (u === '%' || vals.length < 2) continue;
+        for (let i = 0; i < vals.length; i++)
+          for (let j = 0; j < vals.length; j++) {
+            if (i === j) continue;
+            const a = vals[i];
+            const b = vals[j];
+            if (b !== 0 && (approx(v, (a / b) * 100) || approx(v, ((a - b) / b) * 100) || approx(v, ((a - b) / a) * 100)))
+              return true;
+            if (a + b !== 0 && approx(v, (a / (a + b)) * 100)) return true;
+          }
+      }
+    }
+  }
+  return false;
+}
+
+export interface VerifyCorpus {
+  /** The user's actual résumé/document TEXT (the strongest "user-provided" anchor). */
+  documents: string;
+  /** Structured records (experiences/projects/skills) — AI-writable, so only advisory. */
+  structured: string;
+  /** Job posting text (description + requirements + keywords). */
+  job: string;
+}
+
+/**
+ * Number/fact provenance over three SEPARATE scopes (zero-ai). A claim's number
+ * is `supported` only if it traces to the user's actual document text; if it
+ * only traces to a structured record it is `unverified` (advisory — the AI could
+ * have written that record); job-only numbers are advisory; anything matching
+ * nothing is `fabricated` (blocking).
+ */
+export function analyzeProvenance(outputText: string, corpus: VerifyCorpus): ProvenanceResult {
+  const documents = buildCorpus(corpus.documents);
+  const structured = buildCorpus(corpus.structured);
+  const job = buildCorpus(corpus.job);
+  const nums: NumberToken[] = extractNumbers(outputText).filter((n) => n.risk);
+  const res: ProvenanceResult = { checked: nums.length, supported: 0, fabricated: [], unverified: [], jobSourced: [] };
+  for (const n of nums) {
+    const tok = { raw: n.raw, value: n.value, unit: n.unit };
+    if (isExplained(n, documents)) res.supported++;
+    else if (isExplained(n, structured)) res.unverified.push({ ...tok, reason: 'structured_only' });
+    else if (isExplained(n, job)) res.jobSourced.push({ ...tok, reason: 'job_only' });
+    else res.fabricated.push({ ...tok, reason: 'fabricated' });
+  }
+  return res;
+}
+
+/** Advisory style signals over normalized text. */
+export function styleSignals(text: string): Signal[] {
+  const t = normalizeText(text);
+  const signals: Signal[] = [];
+  for (const lex of STYLE_LEXICONS) {
+    const { count, hits } = countHits(lex, t);
+    if (count > 0) {
+      const severity: Severity =
+        lex.id === 'blind_pii' || lex.id === 'generic_opener' ? 'warn' : 'info';
+      signals.push({ id: lex.id, label: lex.label, severity, count, hits });
+    }
+  }
+  return signals;
+}
+
+const DISCLAIMER =
+  '이 점검은 LLM 없이 셀 수 있는 것만 봅니다(숫자 출처·문체 신호). 통과=합격이 아니며, ' +
+  '사실·동문서답·의미 판단은 당신(AI)이 직접 해야 합니다.';
+
+/**
+ * Full lint for a cover letter / fit analysis. `corpus.applicant` empty ⇒ nothing
+ * to verify against ⇒ provenance reported but never blocking.
+ */
+export function lintArtifact(
+  kind: LintReport['kind'],
+  text: string,
+  corpus: VerifyCorpus,
+  opts: LintOptions = {},
+): LintReport {
+  const norm = normalizeText(text);
+  const corpusAvailable = (corpus.documents + corpus.structured).trim().length > 0;
+  const provenance = analyzeProvenance(text, corpus);
+  const signals = styleSignals(text);
+  const strict = !!opts.strict;
+
+  const blocking: LintReport['blocking'] = [];
+  if (corpusAvailable && kind === 'cover_letter') {
+    // Always block suspected fabrication (numbers tracing to nothing).
+    if (provenance.fabricated.length > 0) {
+      blocking.push({
+        id: 'fabricated_numbers',
+        label: '근거 없는 수치(저장된 경력·이력서에 없음)',
+        detail: provenance.fabricated.map((f) => f.raw).join(', '),
+      });
+    }
+    // Strict mode: also block numbers backed only by structured records, not by
+    // the user's actual résumé document ("back your claims with your résumé").
+    if (strict && provenance.unverified.length > 0) {
+      blocking.push({
+        id: 'unverified_numbers_strict',
+        label: '엄격 모드: 이력서 본문에 근거 없는 수치(구조화 경력/프로젝트 항목에만 있음)',
+        detail: provenance.unverified.map((u) => u.raw).join(', '),
+      });
+    }
+  }
+
+  return {
+    kind,
+    charCount: [...norm].length,
+    signals,
+    provenance,
+    blocking,
+    corpusAvailable,
+    strict,
+    disclaimer: DISCLAIMER,
+  };
+}
+
+/** One-line Korean summary for the tool/text response. */
+export function summarizeReport(r: LintReport): string {
+  const parts: string[] = [];
+  if (r.blocking.length)
+    parts.push(`⛔ 저장 차단: ${r.blocking.map((b) => `${b.label}(${b.detail})`).join('; ')}`);
+  if (r.provenance.unverified.length)
+    parts.push(
+      `미확인 수치 ${r.provenance.unverified.length}개(${r.provenance.unverified.map((u) => u.raw).join(', ')}) — 이력서 본문엔 없고 구조화 경력/프로젝트 항목에만 있음, 사실인지 확인`,
+    );
+  if (r.provenance.jobSourced.length)
+    parts.push(`공고 출처 수치 ${r.provenance.jobSourced.length}개(본인 성과로 쓰지 않았는지 확인)`);
+  const adv = r.signals.filter((s) => s.count > 0);
+  if (adv.length) parts.push('문체 신호: ' + adv.map((s) => `${s.label.split('(')[0]}×${s.count}`).join(', '));
+  if (!parts.length) parts.push('자동 점검 통과(셀 수 있는 항목 기준). 의미 판단은 직접 확인하세요.');
+  return parts.join(' · ');
+}

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

@@ -0,0 +1,112 @@
+/**
+ * Deterministic text normalization + number extraction for the verify engine.
+ *
+ * NO LLM. Pure functions. Everything here runs identically on the stored corpus
+ * and on the AI's output so a number/fact "match" can't be dodged with
+ * fullwidth digits, zero-width joiners, or Korean 조사 suffixes.
+ *
+ * Hardening folded in from a Codex (gpt-5.5) adversarial review:
+ *  - NFKC + zero-width strip + fullwidth-digit fold on BOTH sides.
+ *  - "supported" (literal OR server-derivable) instead of "literally present".
+ *  - Derivation restricted to the SAME segment + SAME unit (no spurious
+ *    5 = 12 − 7 across unrelated sentences).
+ *  - Korean magnitude + trailing unit (`8만 건` → 80000 건, `1.2억` → money).
+ */
+
+const ZERO_WIDTH = /[​-‍⁠]/g;
+
+/** NFKC fold (folds ５→5, ％→%, ㈜→(주)…) + strip zero-width chars. */
+export function normalizeText(s: string): string {
+  return (s ?? '').normalize('NFKC').replace(ZERO_WIDTH, '');
+}
+
+const MAGNITUDE: Record<string, number> = { '억': 1e8, '만': 1e4, '천': 1e3 };
+
+/** Units that mark a *refutable quantified claim* (gate-eligible when unsupported). */
+export const RISK_UNITS = new Set([
+  '%', '배', '원', '건', '명', '점', '위', '년차', '년', '개월', '주', '시간', '회', '개',
+]);
+
+export interface NumberToken {
+  /** Original surface form (post-normalize), e.g. "8만 건", "12건", "250%". */
+  raw: string;
+  /** Scaled numeric value for comparison (8만 → 80000, 1.2억 → 120000000, 250% → 250). */
+  value: number;
+  /** Normalized unit ('%','원','건','년',…) or '' when bare. */
+  unit: string;
+  /** True when this looks like a refutable quantified claim (gate-eligible). */
+  risk: boolean;
+}
+
+// digits (commas/decimals) + optional Korean magnitude (억/만/천) + optional unit.
+// Trailing 조사 ("12건을", "5년차로") falls outside the match automatically.
+const NUM_RE =
+  /(\d{1,3}(?:,\d{3})+|\d+)(?:\.(\d+))?\s*(억|만|천)?\s*(원|%p|％|%|퍼센트|배|건|명|점|위|년차|개월|년|시간|주|회|개)?/g;
+
+const YEAR_RE = /^(?:19|20)\d{2}$/;
+
+function normUnit(u: string): string {
+  if (u === '％' || u === '퍼센트' || u === '%p') return '%';
+  return u;
+}
+
+/** Extract comparable number tokens from text. Pure, deterministic. */
+export function extractNumbers(text: string): NumberToken[] {
+  const t = normalizeText(text);
+  const out: NumberToken[] = [];
+  for (const m of t.matchAll(NUM_RE)) {
+    const intPart = m[1].replace(/,/g, '');
+    const frac = m[2] ? '.' + m[2] : '';
+    const base = Number(intPart + frac);
+    if (!Number.isFinite(base)) continue;
+    const mag = m[3] ?? '';
+    let unit = normUnit(m[4] ?? '');
+    // Year-like 4-digit numbers are dates, not claims ("2024", "2024년"); "7년" kept.
+    if (!mag && (!unit || unit === '년') && YEAR_RE.test(intPart) && !frac) continue;
+    const scale = MAGNITUDE[mag] ?? 1;
+    const value = base * scale;
+    // magnitude with no trailing unit ⇒ money (원); "8만 건" keeps 건.
+    if (mag && !unit) unit = '원';
+    const surface = m[0].trim();
+    if (!surface) continue;
+    const risk = RISK_UNITS.has(unit) || (!unit && value >= 1000) || (!!mag && !unit);
+    out.push({ raw: surface, value, unit, risk });
+  }
+  return out;
+}
+
+/** Split text into segments (sentence / line / bullet) for same-segment derivation. */
+export function splitSegments(text: string): string[] {
+  return normalizeText(text)
+    .split(/[\n.。!?！？·••]|(?:\s-\s)/)
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+export interface Corpus {
+  /** unit → all values seen anywhere (for literal/rounding membership). */
+  byUnit: Map<string, number[]>;
+  /** per-segment: unit → values (for same-segment, same-unit derivation). */
+  segments: Array<Map<string, number[]>>;
+}
+
+function addToMap(map: Map<string, number[]>, unit: string, value: number): void {
+  const arr = map.get(unit);
+  if (arr) arr.push(value);
+  else map.set(unit, [value]);
+}
+
+/** Build a unit/segment-indexed corpus from raw text. */
+export function buildCorpus(text: string): Corpus {
+  const byUnit = new Map<string, number[]>();
+  const segments: Array<Map<string, number[]>> = [];
+  for (const seg of splitSegments(text)) {
+    const segMap = new Map<string, number[]>();
+    for (const n of extractNumbers(seg)) {
+      addToMap(byUnit, n.unit, n.value);
+      addToMap(segMap, n.unit, n.value);
+    }
+    if (segMap.size) segments.push(segMap);
+  }
+  return { byUnit, segments };
+}

package/packages/db/src/index.ts

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

package/packages/db/src/settings.ts

@@ -0,0 +1,41 @@
+/**
+ * App settings — small key/value preferences stored in the existing `_meta`
+ * table (created by migrate()). No schema migration needed, so this adds zero
+ * boot-time ALTER risk. Currently holds one flag: verify_strict.
+ */
+import { getDb } from './connection.ts';
+
+const SETTING_PREFIX = 'setting.';
+
+function getSetting(key: string): string | null {
+  const row = getDb()
+    .prepare(`SELECT value FROM _meta WHERE key = ?`)
+    .get(SETTING_PREFIX + key) as { value: string } | undefined;
+  return row ? row.value : null;
+}
+
+function setSetting(key: string, value: string): void {
+  getDb()
+    .prepare(
+      `INSERT INTO _meta (key, value) VALUES (?, ?)
+       ON CONFLICT(key) DO UPDATE SET value = excluded.value`,
+    )
+    .run(SETTING_PREFIX + key, value);
+}
+
+/**
+ * Strict provenance mode. When ON, the cover-letter gate also blocks numbers
+ * that live only in structured records (not the user's résumé document) — i.e.
+ * "back your claims with your actual résumé". OFF (default) only blocks numbers
+ * that trace to nothing. The user opts in via the dashboard toggle or by asking
+ * the AI ("엄격하게 봐줘"); the AI confirms before turning it ON, and must only
+ * turn it OFF on an explicit, unambiguous request (weakening the safety net).
+ */
+export function getVerifyStrict(): boolean {
+  return getSetting('verify_strict') === '1';
+}
+
+export function setVerifyStrict(on: boolean): boolean {
+  setSetting('verify_strict', on ? '1' : '0');
+  return on;
+}