careermate 0.0.6 → 0.0.8

package/packages/core/src/jobsearch.ts

@@ -0,0 +1,186 @@
+/**
+ * Job search import — pull postings from key-free public job-board endpoints by
+ * keyword, so the AI can offer real listings the user can save into CareerMate.
+ *
+ * Scope & boundaries (deliberate):
+ *  - INBOUND only. We fetch publicly visible postings; we send only the search
+ *    keyword, never the user's stored data. (Privacy = no user data leaves; this
+ *    does not violate it.)
+ *  - No WAF bypass, no auth keys. These providers' own frontends call these JSON
+ *    endpoints unauthenticated; a plain fetch suffices. We do NOT bundle a
+ *    scraper/anti-bot evasion (that's the legally dangerous part — see
+ *    .claude/work/research/research_0004). Sites requiring keys (Saramin oapi,
+ *    고용24) or that forbid it in robots.txt (JobKorea search) are excluded here.
+ *  - Read-only w.r.t. the DB. This returns candidates; the AI shows them and the
+ *    user picks which to save via save_job_posting (no auto-dumping into the DB).
+ *
+ * Providers are unofficial public endpoints — if a response shape changes, only
+ * the affected provider's parser needs updating (others keep working).
+ */
+
+export interface JobSearchResult {
+  /** Provider id, e.g. 'wanted' | 'jumpit'. */
+  source: string;
+  company: string;
+  position: string;
+  /** Canonical posting URL the user can open. */
+  url: string;
+  location?: string;
+  /** Required experience, human-readable (e.g. '신입', '5~20년'). */
+  experience?: string;
+  /** Tech stack / tags when the provider exposes them. */
+  keywords?: string[];
+  /** Application deadline as YYYY-MM-DD when known. */
+  deadline?: string;
+  /** Provider-native id (for dedup / detail fetch). */
+  external_id: string;
+}
+
+export interface ProviderOutcome {
+  source: string;
+  ok: boolean;
+  count: number;
+  error?: string;
+}
+
+export interface JobSearchResponse {
+  query: string;
+  results: JobSearchResult[];
+  providers: ProviderOutcome[];
+}
+
+export interface JobSearchOptions {
+  /** Which providers to query. Defaults to all registered. */
+  sources?: string[];
+  /** Max results per provider (1–50). Default 10. */
+  limit?: number;
+  /** Per-request timeout in ms. Default 10000. */
+  timeoutMs?: number;
+}
+
+const UA =
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36';
+
+/** Slice an ISO timestamp / date string to YYYY-MM-DD; undefined if not a date. */
+function toYmd(v: unknown): string | undefined {
+  if (typeof v !== 'string' || v.length < 10) return undefined;
+  const m = v.match(/^(\d{4}-\d{2}-\d{2})/);
+  return m ? m[1] : undefined;
+}
+
+async function getJson(url: string, timeoutMs: number): Promise<any> {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, {
+      headers: { accept: 'application/json', 'user-agent': UA, 'accept-language': 'ko,en;q=0.8' },
+      signal: ctrl.signal,
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    return await res.json();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+interface Provider {
+  id: string;
+  label: string;
+  search(query: string, limit: number, timeoutMs: number): Promise<JobSearchResult[]>;
+}
+
+/** Wanted (wanted.co.kr) — public v4 jobs JSON, no auth. IT/startup roles. */
+const wanted: Provider = {
+  id: 'wanted',
+  label: '원티드',
+  async search(query, limit, timeoutMs) {
+    const url =
+      `https://www.wanted.co.kr/api/v4/jobs?country=kr&locations=all&years=-1` +
+      `&job_sort=job.latest_order&limit=${limit}&offset=0&query=${encodeURIComponent(query)}`;
+    const j = await getJson(url, timeoutMs);
+    const rows: any[] = Array.isArray(j?.data) ? j.data : [];
+    return rows.map((r) => {
+      const annual =
+        r.annual_from || r.annual_to
+          ? `${r.annual_from ?? 0}~${r.annual_to ?? '?'}년`
+          : undefined;
+      return {
+        source: 'wanted',
+        company: r.company?.name ?? '',
+        position: r.position ?? '',
+        url: `https://www.wanted.co.kr/wd/${r.id}`,
+        location: r.address?.location ?? r.address?.full_location ?? undefined,
+        experience: annual,
+        deadline: toYmd(r.due_time),
+        external_id: String(r.id),
+      } as JobSearchResult;
+    });
+  },
+};
+
+/** Jumpit (jumpit.co.kr) — public positions JSON, no auth. Dev roles, tech stacks. */
+const jumpit: Provider = {
+  id: 'jumpit',
+  label: '점핏',
+  async search(query, limit, timeoutMs) {
+    const url =
+      `https://api.jumpit.co.kr/api/positions?sort=rsp_rate&page=1&keyword=${encodeURIComponent(query)}`;
+    const j = await getJson(url, timeoutMs);
+    const rows: any[] = Array.isArray(j?.result?.positions) ? j.result.positions : [];
+    return rows.slice(0, limit).map((p) => ({
+      source: 'jumpit',
+      company: p.companyName ?? '',
+      position: p.title ?? '',
+      url: `https://www.jumpit.co.kr/position/${p.id}`,
+      location: Array.isArray(p.locations) ? p.locations[0] : undefined,
+      experience: p.newcomer
+        ? '신입'
+        : p.minCareer != null
+          ? `${p.minCareer}~${p.maxCareer ?? p.minCareer}년`
+          : undefined,
+      keywords: Array.isArray(p.techStacks) ? p.techStacks : undefined,
+      deadline: toYmd(p.closedAt),
+      external_id: String(p.id),
+    } as JobSearchResult));
+  },
+};
+
+const PROVIDERS: Provider[] = [wanted, jumpit];
+
+/** Registered provider ids (key-free, no WAF bypass). */
+export const JOB_SEARCH_SOURCES = PROVIDERS.map((p) => p.id);
+
+/**
+ * Search key-free public job boards by keyword. Each provider runs independently;
+ * one failing (network/timeout/shape change) does not sink the others. Results
+ * are returned for the AI to present — saving is a separate explicit step.
+ */
+export async function searchJobs(query: string, opts: JobSearchOptions = {}): Promise<JobSearchResponse> {
+  const q = (query ?? '').trim();
+  if (!q) return { query: '', results: [], providers: [] };
+  const limit = Math.min(50, Math.max(1, opts.limit ?? 10));
+  const timeoutMs = opts.timeoutMs ?? 10000;
+  const chosen = opts.sources?.length
+    ? PROVIDERS.filter((p) => opts.sources!.includes(p.id))
+    : PROVIDERS;
+
+  const settled = await Promise.all(
+    chosen.map(async (p): Promise<{ outcome: ProviderOutcome; results: JobSearchResult[] }> => {
+      try {
+        const results = await p.search(q, limit, timeoutMs);
+        return { outcome: { source: p.id, ok: true, count: results.length }, results };
+      } catch (e) {
+        return {
+          outcome: { source: p.id, ok: false, count: 0, error: e instanceof Error ? e.message : String(e) },
+          results: [],
+        };
+      }
+    }),
+  );
+
+  return {
+    query: q,
+    results: settled.flatMap((s) => s.results),
+    providers: settled.map((s) => s.outcome),
+  };
+}

package/packages/core/src/services.ts

@@ -78,6 +78,22 @@ export function collectVerifyCorpus(jobId?: string | null): VerifyCorpus {
   for (const s of skillRepo.list()) {
     structured.push([s.name, s.level, s.years != null ? `${s.years}년` : ''].filter(Boolean).join(' '));
   }
+  // Profile credentials (학점·어학·자격·수상) — so a cited GPA/score (3.8, TOEIC 920)
+  // traces to stored data and isn't hard-blocked as fabricated. Structured-only ⇒ advisory.
+  // Provenance matching is unit-keyed, and a purely numeric score is cited both bare
+  // ("920") and with the 점 counter ("920점"); emit both forms so neither false-fires.
+  const scoreForms = (s?: string): string =>
+    s && /^\d+(\.\d+)?$/.test(s.trim()) ? `${s.trim()} ${s.trim()}점` : (s ?? '');
+  const prof = profileRepo.get();
+  if (prof) {
+    for (const ed of prof.education) {
+      const gpa = ed.gpa ? `학점 ${ed.gpa}${ed.gpa_scale ? `/${ed.gpa_scale}` : ''}` : '';
+      structured.push([ed.school, ed.degree, ed.major, gpa, ed.status].filter(Boolean).join(' '));
+    }
+    for (const c of prof.certifications) structured.push([c.name, c.issuer, scoreForms(c.score)].filter(Boolean).join(' '));
+    for (const l of prof.language_scores) structured.push(`${l.test} ${scoreForms(l.score)}`);
+    for (const a of prof.awards) structured.push([a.title, a.issuer, a.description].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 };
@@ -280,7 +296,11 @@ export function saveCoverLetterVersion(input: CoverLetterVersionInput & { force?
   const { coverLetter, version } = coverLetterRepo.addVersion({
     cover_letter_id: input.cover_letter_id,
     title: input.title,
-    job_id: input.job_id ?? null,
+    // Pass job_id through verbatim — do NOT coerce undefined→null here. addVersion
+    // treats `undefined` as "leave the link alone" and `null` as "clear it"; the old
+    // `?? null` wiped a cover letter's job link whenever a new version was saved
+    // without re-specifying job_id (e.g. editing an existing letter).
+    job_id: input.job_id,
     content: input.content,
     note: input.note,
     source: input.source ?? 'ai',
@@ -295,7 +315,9 @@ export function saveCoverLetterVersion(input: CoverLetterVersionInput & { force?
   }
   activityRepo.log(
     'cover_letter_version_saved',
-    `${coverLetter.title} 자기소개서 v${version.version_no}를 저장했습니다.`,
+    // Title already names the document (often ends in "자기소개서") — don't append the
+    // word again or it doubles ("…자기소개서 자기소개서 v2"). Title + version is enough.
+    `${coverLetter.title} v${version.version_no}를 저장했습니다.`,
     'cover_letter',
     coverLetter.id,
   );

package/packages/core/src/summary.ts

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

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

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

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

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

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

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