careermate 0.0.13 → 0.0.15

package/dist/web.mjs

@@ -2106,7 +2106,7 @@ var init_some = __esm({
 });
 
 // node_modules/underscore/modules/contains.js
-function contains(obj2, item, fromIndex, guard) {
+function contains2(obj2, item, fromIndex, guard) {
   if (!isArrayLike_default(obj2)) obj2 = values(obj2);
   if (typeof fromIndex != "number" || guard) fromIndex = 0;
   return indexOf_default(obj2, item, fromIndex) >= 0;
@@ -2485,7 +2485,7 @@ var init_omit = __esm({
       } else {
         keys2 = map4(flatten(keys2, false, false), String);
         iteratee2 = function(value, key) {
-          return !contains(keys2, key);
+          return !contains2(keys2, key);
         };
       }
       return pick_default(obj2, iteratee2, context);
@@ -2575,7 +2575,7 @@ var init_difference = __esm({
     difference_default = restArguments(function(array2, rest2) {
       rest2 = flatten(rest2, true, true);
       return filter(array2, function(value) {
-        return !contains(rest2, value);
+        return !contains2(rest2, value);
       });
     });
   }
@@ -2610,11 +2610,11 @@ function uniq(array2, isSorted, iteratee2, context) {
       if (!i || seen !== computed) result2.push(value);
       seen = computed;
     } else if (iteratee2) {
-      if (!contains(seen, computed)) {
+      if (!contains2(seen, computed)) {
         seen.push(computed);
         result2.push(value);
       }
-    } else if (!contains(result2, value)) {
+    } else if (!contains2(result2, value)) {
       result2.push(value);
     }
   }
@@ -2650,10 +2650,10 @@ function intersection2(array2) {
   var argsLength = arguments.length;
   for (var i = 0, length = getLength_default(array2); i < length; i++) {
     var item = array2[i];
-    if (contains(result2, item)) continue;
+    if (contains2(result2, item)) continue;
     var j;
     for (j = 1; j < argsLength; j++) {
-      if (!contains(arguments[j], item)) break;
+      if (!contains2(arguments[j], item)) break;
     }
     if (j === argsLength) result2.push(item);
   }
@@ -2841,7 +2841,7 @@ __export(modules_exports, {
   compact: () => compact,
   compose: () => compose,
   constant: () => constant,
-  contains: () => contains,
+  contains: () => contains2,
   countBy: () => countBy_default,
   create: () => create,
   debounce: () => debounce,
@@ -2874,8 +2874,8 @@ __export(modules_exports, {
   has: () => has2,
   head: () => first,
   identity: () => identity,
-  include: () => contains,
-  includes: () => contains,
+  include: () => contains2,
+  includes: () => contains2,
   indexBy: () => indexBy_default,
   indexOf: () => indexOf_default,
   initial: () => initial,
@@ -3136,7 +3136,7 @@ __export(index_all_exports, {
   compact: () => compact,
   compose: () => compose,
   constant: () => constant,
-  contains: () => contains,
+  contains: () => contains2,
   countBy: () => countBy_default,
   create: () => create,
   debounce: () => debounce,
@@ -3169,8 +3169,8 @@ __export(index_all_exports, {
   has: () => has2,
   head: () => first,
   identity: () => identity,
-  include: () => contains,
-  includes: () => contains,
+  include: () => contains2,
+  includes: () => contains2,
   indexBy: () => indexBy_default,
   indexOf: () => indexOf_default,
   initial: () => initial,
@@ -40162,6 +40162,52 @@ function ensureTables() {
     );
   `);
 }
+var FORGET_AFTER_DAYS = 120;
+function markJobsSeen(items, today) {
+  const seen = /* @__PURE__ */ new Map();
+  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);
+      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;
+}
+function parseList2(value) {
+  try {
+    const parsed = JSON.parse(String(value));
+    return Array.isArray(parsed) ? parsed.filter((v) => typeof v === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function getJobSearchPreferences() {
+  const row = getDb().prepare(`SELECT * FROM job_search_preferences WHERE id = 1`).get();
+  return {
+    keyword: typeof row?.keyword === "string" ? row.keyword : "",
+    remember_categories: parseList2(row?.remember_categories ?? "[]"),
+    saramin_categories: parseList2(row?.saramin_categories ?? "[]"),
+    updated_at: typeof row?.updated_at === "string" ? row.updated_at : null
+  };
+}
+function setJobSearchPreferences(prefs) {
+  const next = { ...getJobSearchPreferences(), ...prefs, updated_at: (/* @__PURE__ */ 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;
+}
 ensureTables();
 
 // packages/shared/src/errors.ts
@@ -51551,13 +51597,13 @@ function _promise(Class2, innerType) {
 }
 // @__NO_SIDE_EFFECTS__
 function _custom(Class2, fn, _params) {
-  const norm2 = normalizeParams(_params);
-  norm2.abort ?? (norm2.abort = true);
+  const norm3 = normalizeParams(_params);
+  norm3.abort ?? (norm3.abort = true);
   const schema = new Class2({
     type: "custom",
     check: "custom",
     fn,
-    ...norm2
+    ...norm3
   });
   return schema;
 }
@@ -55283,7 +55329,7 @@ var ApplicationContextSchema = external_exports.object({
 });
 
 // packages/shared/src/build-info.ts
-var APP_VERSION = true ? "0.0.13" : "0.0.0-dev";
+var APP_VERSION = true ? "0.0.15" : "0.0.0-dev";
 var BUNDLED = true;
 
 // packages/shared/src/index.ts
@@ -56529,8 +56575,8 @@ function profileCompleteness(p) {
     experienceRepo.list().length > 0,
     skillRepo.list().length > 0
   ];
-  const score = Math.round(checks.filter(Boolean).length / checks.length * 100);
-  return score;
+  const score2 = Math.round(checks.filter(Boolean).length / checks.length * 100);
+  return score2;
 }
 function getOnboardingStatus() {
   const profile = profileRepo.get();
@@ -56886,7 +56932,7 @@ function styleSignals(text) {
 }
 var DISCLAIMER = "\uC774 \uC810\uAC80\uC740 LLM \uC5C6\uC774 \uC140 \uC218 \uC788\uB294 \uAC83\uB9CC \uBD05\uB2C8\uB2E4(\uC22B\uC790 \uCD9C\uCC98\xB7\uBB38\uCCB4 \uC2E0\uD638). \uD1B5\uACFC=\uD569\uACA9\uC774 \uC544\uB2C8\uBA70, \uC0AC\uC2E4\xB7\uB3D9\uBB38\uC11C\uB2F5\xB7\uC758\uBBF8 \uD310\uB2E8\uC740 \uB2F9\uC2E0(AI)\uC774 \uC9C1\uC811 \uD574\uC57C \uD569\uB2C8\uB2E4.";
 function lintArtifact(kind, text, corpus, opts = {}) {
-  const norm2 = normalizeText(text);
+  const norm3 = normalizeText(text);
   const corpusAvailable = (corpus.documents + corpus.structured).trim().length > 0;
   const provenance = analyzeProvenance(text, corpus);
   const signals = styleSignals(text);
@@ -56910,7 +56956,7 @@ function lintArtifact(kind, text, corpus, opts = {}) {
   }
   return {
     kind,
-    charCount: [...norm2].length,
+    charCount: [...norm3].length,
     charCounts: countChars(text),
     signals,
     provenance,
@@ -57403,6 +57449,54 @@ var SARAMIN_CATEGORIES = {
 };
 
 // packages/core/src/job-categories.ts
+var norm2 = (s) => s.toLowerCase().replace(/[\s·/(),&.\-]/g, "");
+function contains(hayRaw, needle) {
+  if (/^[a-z0-9]{1,3}$/.test(needle)) return new RegExp(`(?<![a-z0-9])${needle}(?![a-z0-9])`).test(hayRaw.toLowerCase());
+  return norm2(hayRaw).includes(needle);
+}
+function score(name, terms) {
+  const n = norm2(name);
+  if (n.length < 2) return 0;
+  let best = 0;
+  for (const term of terms) {
+    const t = norm2(term);
+    if (n === t) return 3;
+    if (contains(name, t)) best = Math.max(best, 2);
+    else if (contains(term, n)) best = Math.max(best, 1);
+    for (const word of term.split(/\s+/).map(norm2)) {
+      if (word.length < 2 || word === t) continue;
+      if (word === n) best = Math.max(best, 1);
+      else if (contains(name, word)) best = Math.max(best, 0.5);
+    }
+  }
+  return best;
+}
+function findJobCategories(query, limit = 20) {
+  const terms = (query ?? "").split(/[,\n]/).map((t) => t.trim()).filter((t) => norm2(t).length >= 2);
+  const remember2 = [];
+  for (const [group2, subs] of Object.entries(REMEMBER_CATEGORIES)) {
+    const gs = score(group2, terms);
+    if (gs) remember2.push({ v: group2, s: gs - 0.5 });
+    for (const sub of subs) {
+      const s = score(sub, terms);
+      if (s) remember2.push({ v: `${group2}>${sub}`, s });
+    }
+  }
+  const saramin2 = [];
+  for (const [group2, kinds] of Object.entries(SARAMIN_CATEGORIES)) {
+    for (const [kind, list] of Object.entries(kinds)) {
+      for (const [code, name] of list) {
+        const s = score(name, terms) - (kind === "\uC9C1\uBB34\xB7\uC9C1\uC5C5" ? 0 : 0.25);
+        if (s > 0) saramin2.push({ code, name, group: group2, kind, s });
+      }
+    }
+  }
+  return {
+    query,
+    remember: remember2.sort((a, b) => b.s - a.s).slice(0, limit).map((r) => r.v),
+    saramin: saramin2.sort((a, b) => b.s - a.s).slice(0, limit).map(({ s: _s, ...c }) => c)
+  };
+}
 function isRememberCategory(value) {
   const parts = value.split(">").map((s) => s.trim());
   if (parts.length > 2) return false;
@@ -57411,11 +57505,19 @@ function isRememberCategory(value) {
   return !!subs && (sub === void 0 || subs.includes(sub));
 }
 var saraminCodes;
+var saraminIndex = () => {
+  if (!saraminCodes) {
+    saraminCodes = /* @__PURE__ */ new Map();
+    for (const kinds of Object.values(SARAMIN_CATEGORIES))
+      for (const list of Object.values(kinds)) for (const [c, n] of list) if (!saraminCodes.has(c)) saraminCodes.set(c, n);
+  }
+  return saraminCodes;
+};
 function isSaraminCategory(code) {
-  saraminCodes ??= new Set(
-    Object.values(SARAMIN_CATEGORIES).flatMap((kinds) => Object.values(kinds).flatMap((list) => list.map(([c]) => c)))
-  );
-  return saraminCodes.has(code);
+  return saraminIndex().has(code);
+}
+function saraminCategoryName(code) {
+  return saraminIndex().get(code);
 }
 
 // packages/core/src/jobsearch.ts
@@ -57663,6 +57765,118 @@ var saramin = {
 };
 var PROVIDERS = [wanted, jumpit, remember, saramin];
 var JOB_SEARCH_SOURCES = PROVIDERS.map((p) => p.id);
+function providerError(e) {
+  if (e instanceof external_exports.ZodError) {
+    const first2 = e.issues[0];
+    return {
+      status: "degraded",
+      error: `provider response changed${first2 ? ` (${first2.path.join(".") || "root"})` : ""}`
+    };
+  }
+  const message = e instanceof Error ? e.message : String(e);
+  return { status: "unavailable", error: message };
+}
+async function searchJobs(query, opts = {}) {
+  const q = (query ?? "").trim();
+  const limit = Math.min(100, Math.max(1, opts.limit ?? (opts.postedSince ? 50 : 10)));
+  const timeoutMs = Math.min(3e4, Math.max(1e3, opts.timeoutMs ?? 1e4));
+  const chosen = (opts.sources?.length ? PROVIDERS.filter((p) => opts.sources.includes(p.id)) : PROVIDERS).filter(
+    (p) => q || p.categoryOption && opts[p.categoryOption]?.length
+  );
+  if (!chosen.length) return { query: q, results: [], providers: [] };
+  const settled = await Promise.all(
+    chosen.map(async (p) => {
+      const checked_at = (/* @__PURE__ */ new Date()).toISOString();
+      try {
+        const results2 = await p.search(q, limit, timeoutMs, opts);
+        return {
+          outcome: {
+            source: p.id,
+            label: p.label,
+            ok: true,
+            status: "healthy",
+            count: results2.length,
+            checked_at
+          },
+          results: results2
+        };
+      } catch (e) {
+        const failure = providerError(e);
+        return {
+          outcome: {
+            source: p.id,
+            label: p.label,
+            ok: false,
+            status: failure.status,
+            count: 0,
+            checked_at,
+            error: failure.error
+          },
+          results: []
+        };
+      }
+    })
+  );
+  const today = opts.today ?? (/* @__PURE__ */ new Date()).toLocaleDateString("sv-SE");
+  let results = settled.flatMap((s) => s.results);
+  if (opts.trackSeen !== false) {
+    const seen = markJobsSeen(results, today);
+    for (const r of results) r.first_seen_at = seen.get(`${r.source}:${r.external_id}`);
+  }
+  results = dedupeAcrossBoards(results);
+  let filtered_out;
+  const years = opts.years;
+  if (opts.postedSince || years != null) {
+    const kept = results.filter((r) => {
+      if (opts.postedSince && (r.posted_at ?? r.first_seen_at ?? today) < opts.postedSince) return false;
+      const range2 = years != null ? experienceRange(r.experience) : null;
+      return !range2 || range2[0] <= years && years <= range2[1];
+    });
+    filtered_out = results.length - kept.length;
+    results = kept;
+  }
+  return {
+    query: q,
+    results,
+    providers: settled.map((s) => s.outcome),
+    ...filtered_out !== void 0 ? { filtered_out } : {}
+  };
+}
+function experienceRange(text) {
+  const t = (text ?? "").replace(/\s/g, "");
+  if (!t) return null;
+  if (/무관/.test(t)) return [0, Infinity];
+  const m = t.match(/(\d+)?~(\d+)년/);
+  if (m) return [m[1] ? +m[1] : 0, +m[2]];
+  const min2 = t.match(/(\d+)년(이상|↑)/);
+  if (min2) return [/신입/.test(t) ? 0 : +min2[1], Infinity];
+  if (/신입/.test(t)) return /경력/.test(t) ? [0, Infinity] : [0, 0];
+  return null;
+}
+var normCompany = (s) => s.replace(/\([^)]*\)|㈜|주식회사/g, "").toLowerCase().replace(/[^\p{L}\p{N}]/gu, "");
+var normTitle = (title, company) => {
+  const c = normCompany(company);
+  return title.replace(/\[([^\]]*)\]/g, (tag, inner) => {
+    const n = normCompany(inner);
+    return n && c && (c.includes(n) || n.includes(c)) ? "" : tag;
+  }).toLowerCase().replace(/[^\p{L}\p{N}]/gu, "");
+};
+function dedupeAcrossBoards(results) {
+  const byKey = /* @__PURE__ */ new Map();
+  const out = [];
+  for (const r of results) {
+    const key = `${normCompany(r.company)}|${normTitle(r.position, r.company)}`;
+    const first2 = byKey.get(key);
+    if (first2 && first2.source !== r.source) {
+      (first2.also_on ??= []).push({ source: r.source, url: r.url });
+      if (!first2.posted_at && r.posted_at) first2.posted_at = r.posted_at;
+      continue;
+    }
+    byKey.set(key, r);
+    out.push(r);
+  }
+  return out;
+}
 
 // packages/core/src/offers.ts
 function withJob(offer, job) {
@@ -77553,6 +77767,82 @@ function registerDiagnosticRoutes(router2) {
   });
 }
 
+// apps/web/src/job-search-routes.ts
+var isYmd = (s) => /^\d{4}-\d{2}-\d{2}$/.test(s) && !Number.isNaN(Date.parse(s)) && new Date(s).toISOString().startsWith(s);
+var Categories = {
+  remember_categories: external_exports.array(external_exports.string().max(100)).max(20).optional(),
+  saramin_categories: external_exports.array(external_exports.string().regex(/^\d+$/)).max(20).optional()
+};
+var SearchSchema = external_exports.object({
+  keyword: external_exports.string().max(100).optional(),
+  ...Categories,
+  sources: external_exports.array(external_exports.enum([...JOB_SEARCH_SOURCES])).optional(),
+  limit: external_exports.number().int().min(1).max(100).optional(),
+  posted_since: external_exports.string().refine((s) => s === "today" || isYmd(s)).optional(),
+  years: external_exports.number().int().min(0).max(40).optional()
+});
+var PrefsSchema = external_exports.object({ keyword: external_exports.string().max(100).optional(), ...Categories });
+function assertKnownCategories(remember2 = [], saramin2 = []) {
+  const bad = [...remember2.filter((c) => !isRememberCategory(c)), ...saramin2.filter((c) => !isSaraminCategory(c))];
+  if (bad.length) throw new HttpError(400, `\uB9AC\uBA64\uBC84\xB7\uC0AC\uB78C\uC778 \uBD84\uB958\uD45C\uC5D0 \uC5C6\uB294 \uAC12\uC785\uB2C8\uB2E4: ${bad.join(", ")}`);
+}
+function registerJobSearchRoutes(router2) {
+  router2.get("/api/job-search/categories", (ctx) => findJobCategories(ctx.query.get("q") ?? "", 20));
+  router2.get("/api/job-search/preferences", () => {
+    const preferences = getJobSearchPreferences();
+    const saramin_names = Object.fromEntries(preferences.saramin_categories.map((c) => [c, saraminCategoryName(c) ?? c]));
+    return { preferences, saramin_names };
+  });
+  router2.put("/api/job-search/preferences", async (ctx) => {
+    const input = await readJsonBody(ctx.req, PrefsSchema);
+    assertKnownCategories(input.remember_categories, input.saramin_categories);
+    return {
+      preferences: setJobSearchPreferences({
+        ...input.keyword !== void 0 ? { keyword: input.keyword.trim() } : {},
+        ...input.remember_categories ? { remember_categories: input.remember_categories } : {},
+        ...input.saramin_categories ? { saramin_categories: input.saramin_categories } : {}
+      })
+    };
+  });
+  router2.post("/api/job-search", async (ctx) => {
+    const input = await readJsonBody(ctx.req, SearchSchema);
+    let keyword = (input.keyword ?? "").trim();
+    let remember2 = input.remember_categories ?? [];
+    let saramin2 = input.saramin_categories ?? [];
+    let usedSaved = false;
+    if (!keyword && !remember2.length && !saramin2.length) {
+      const saved = getJobSearchPreferences();
+      ({ keyword, remember_categories: remember2, saramin_categories: saramin2 } = saved);
+      usedSaved = true;
+      if (!keyword && !remember2.length && !saramin2.length) {
+        throw new HttpError(400, "\uAC80\uC0C9\uC5B4\uB098 \uC9C1\uBB34\uB97C \uB123\uC5B4 \uC8FC\uC138\uC694.");
+      }
+    }
+    assertKnownCategories(remember2, saramin2);
+    const today = (/* @__PURE__ */ new Date()).toLocaleDateString("sv-SE");
+    const res = await searchJobs(keyword, {
+      sources: input.sources,
+      limit: input.limit,
+      rememberCategories: remember2,
+      saraminCategories: saramin2,
+      postedSince: input.posted_since === "today" ? today : input.posted_since,
+      years: input.years,
+      today
+    });
+    const savedByUrl = new Map(jobRepo.list().filter((j) => j.url).map((j) => [j.url, j.id]));
+    const results = res.results.map((r) => ({
+      ...r,
+      saved_job_id: savedByUrl.get(r.url) ?? r.also_on?.map((a) => savedByUrl.get(a.url)).find(Boolean) ?? null
+    }));
+    return {
+      ...res,
+      results,
+      used_saved_preferences: usedSaved,
+      conditions: { keyword, remember_categories: remember2, saramin_categories: saramin2, years: input.years ?? null }
+    };
+  });
+}
+
 // apps/web/src/server.ts
 var __dirname2 = path6.dirname(fileURLToPath2(import.meta.url));
 var WEB_ROOT = BUNDLED ? path6.resolve(__dirname2, "public") : path6.resolve(__dirname2, "..", "public");
@@ -77560,6 +77850,7 @@ var LANDING_URL = "https://careermate.life/";
 var router = new Router();
 registerApiRoutes(router);
 registerDiagnosticRoutes(router);
+registerJobSearchRoutes(router);
 function createServer() {
   return http.createServer(async (req, res) => {
     try {

package/docs/FAQ.md

@@ -79,6 +79,30 @@ UTF-8로 다시 저장하거나 내용을 붙여넣어 주세요.
 
 ---
 
+## 공고 찾기
+
+### 채용공고도 찾아주나요?
+네. AI에게 "백엔드 공고 찾아줘", "경리 공고 찾아줘"처럼 말하면 **원티드·점핏·리멤버·사람인**의
+공개 공고를 모아 보여줍니다. 로그인이나 API 키는 필요 없고, 밖으로 나가는 것은 검색어와 직무
+조건뿐입니다(프로필·이력서는 보내지 않음). 잡코리아는 robots.txt 제약 때문에 넣지 않았습니다.
+개발 직군만이 아니라 모든 직군에서 됩니다. 직무 이름을 각 사이트의 분류로 바꾸는 표가 내장돼
+있습니다(리멤버 26개 그룹·315개 세부 직무, 사람인 21개 분야·2,178개 코드). 여러 사이트에 함께
+올라온 공고는 한 줄로 합칩니다. 고른 공고만 저장되고, 저장한 공고는 적합도 분석과 자소서로 이어집니다.
+대시보드의 **공고 찾기** 화면에서도 같은 검색을 하고 클릭 한 번으로 저장할 수 있습니다.
+
+### 오늘 올라온 공고만 볼 수 있나요?
+자주 보는 직무를 검색 조건으로 한 번 저장해 두면 **"오늘 올라온 내 직무 공고 보여줘"** 만으로
+새 공고를 봅니다. 리멤버·사람인은 사이트 게시일로 거릅니다. 원티드·점핏은 게시일을 주지 않아
+CareerMate가 처음 본 날로 거르므로, **첫 검색에서는 전부 새 공고로 보입니다.**
+
+### 경력 연차로 거를 수 있나요?
+네. "경력 5년인데 프론트엔드 공고 찾아줘"처럼 연차를 말하면 경력 범위에 그 연차가 들어가는 공고만
+남깁니다. 5년이면 "3~10년"은 남고 "8~20년"은 빠집니다. 경력 표기를 읽을 수 없는 공고는 빼지 않고
+남겨 둡니다. 2026-11-04에 프론트엔드·경력 5년으로 검색했을 때 합친 뒤 173건 중 123건이 남고
+50건이 연차 조건으로 빠졌습니다.
+
+---
+
 ## 공고 분석 / 자소서
 
 ### "공고 URL은 어떻게 넣어요?"

package/docs/MCP_TOOLS.md

@@ -141,7 +141,7 @@ AI 클라이언트가 연결되면 이 도구를 가장 먼저 호출해 상태
 
 | 도구 | 목적 | 주요 입력 | 반환 | 언제 호출 | 읽기전용 |
 | --- | --- | --- | --- | --- | --- |
-| `search_jobs` | 키워드나 직무 조건으로 무인증 공개 잡보드(원티드·점핏·리멤버·사람인)에서 공고를 *가져옴*(저장은 안 함). 여러 사이트의 같은 공고는 한 줄로 합침 | `keyword?`, `sources?`, `limit?`(사이트별, 기본 10, posted_since가 있으면 50, 최대 100), `remember_categories?`(["재무·회계·세무>회계결산"]), `saramin_categories?`(["322"]), `posted_since?`("today"·YYYY-MM-DD). keyword와 직무 조건을 모두 비우면 저장된 검색 조건 사용 | `{ query, results[](회사·직무·url·지역·경력·기술·마감·posted_at·first_seen_at·also_on, 사람인은 category_codes), providers[], filtered_out?, conditions, used_saved_preferences }` | "○○ 공고 찾아줘", "오늘 올라온 공고 보여줘". 결과를 보여주고 **고른 것만** save_job_posting. 원티드·점핏은 게시일이 없어 처음 본 날로 거름 | ✅ |
+| `search_jobs` | 키워드나 직무 조건으로 무인증 공개 잡보드(원티드·점핏·리멤버·사람인)에서 공고를 *가져옴*(저장은 안 함). 여러 사이트의 같은 공고는 한 줄로 합침 | `keyword?`, `sources?`, `limit?`(사이트별, 기본 10, posted_since가 있으면 50, 최대 100), `remember_categories?`(["재무·회계·세무>회계결산"]), `saramin_categories?`(["322"]), `posted_since?`("today"·YYYY-MM-DD), `years?`(사용자 경력 연차, 공고 경력 범위에 들어가는 것만). keyword와 직무 조건을 모두 비우면 저장된 검색 조건 사용 | `{ query, results[](회사·직무·url·지역·경력·기술·마감·posted_at·first_seen_at·also_on, 사람인은 category_codes), providers[], filtered_out?, conditions, used_saved_preferences }` | "○○ 공고 찾아줘", "오늘 올라온 공고 보여줘". 결과를 보여주고 **고른 것만** save_job_posting. 원티드·점핏은 게시일이 없어 처음 본 날로 거름 | ✅ |
 | `find_job_categories` | 직무 이름을 리멤버 분류("상위>하위")와 사람인 직무 코드로 변환(내장 분류표, 외부 통신 없음). 모든 직군 | `query`(쉼표로 여러 개), `limit?`(기본 20) | `{ query, remember[], saramin[](code·name·group·kind) }` 관련도순 | search_jobs·set_job_search_preferences에 직무 조건을 넣기 전 | ✅ |
 | `get_job_search_preferences` | 저장된 공고 검색 조건 조회 | 없음 | `{ keyword, remember_categories, saramin_categories, updated_at }` | "내 검색 조건 뭐야?" | ✅ |
 | `set_job_search_preferences` | 자주 볼 공고 검색 조건 저장(준 필드만 갱신). 리멤버 분류는 내장 분류표로 검증 | `keyword?`, `remember_categories?`, `saramin_categories?` | 저장된 조건 | 사용자 직무를 find_job_categories로 찾고 확인받은 뒤 | ✏️ |

package/docs/START_WORKFLOW.md

@@ -56,6 +56,36 @@
 
 ---
 
+## A-1. 공고 찾기 (지원할 공고가 아직 없을 때)
+
+사용자가 "공고 찾아줘", "오늘 올라온 내 직무 공고 보여줘"라고 하면 아래 순서로 진행합니다. 원티드·점핏·리멤버·사람인 네 곳의 공개 공고를 로그인·API 키 없이 가져옵니다. 밖으로 나가는 것은 검색어와 직무 조건뿐이고 사용자 데이터는 보내지 않습니다. 잡코리아는 robots.txt 제약으로 포함하지 않습니다.
+
+### 1. 직무 분류 찾기 - `find_job_categories`
+
+- 개발 직군만이 아니라 모든 직군에 씁니다. "경리", "간호사", "재무", "백엔드" 같은 직무 이름을 리멤버 분류("상위>하위")와 사람인 숫자 코드로 바꿔 줍니다.
+- 내장된 분류표(리멤버 26개 그룹·315개 세부 직무, 사람인 21개 분야·2,178개 코드)에서 찾으므로 외부 통신이 없습니다. 사용자가 직무를 말하지 않았으면 프로필의 희망 직무를 씁니다.
+- 결과는 관련도순입니다. 다 넣지 말고 사용자 직무에 맞는 것만 고릅니다.
+
+### 2. (자주 볼 직무라면) 검색 조건 저장 - `set_job_search_preferences`
+
+- 어떤 직무로 저장할지 사용자에게 확인한 뒤 저장합니다. 이후 "오늘 올라온 내 직무 공고 보여줘"는 `search_jobs`를 조건 없이 `posted_since: "today"`로 부르면 됩니다.
+
+### 3. 공고 검색 - `search_jobs`
+
+- `keyword` 또는 1단계에서 고른 직무 조건을 넣습니다. 직무 조건만 주면 직무 조건을 지원하는 리멤버·사람인만 검색합니다.
+- `posted_since`("today" 또는 YYYY-MM-DD): 리멤버·사람인은 사이트 게시일로 거릅니다. 원티드·점핏은 게시일을 주지 않아 CareerMate가 처음 본 날로 거르므로, 첫 검색에서는 전부 새 공고로 보인다고 사용자에게 알려 주세요.
+- `years`: 사용자 경력 연차입니다. 공고의 경력 범위에 이 연차가 들어가는 것만 남깁니다(5년이면 "3~10년"은 남고 "8~20년"은 빠짐). 경력 표기를 읽을 수 없는 공고는 남깁니다.
+- `limit`: 사이트별 건수입니다. 기본 10건, `posted_since`가 있으면 50건, 최대 100건입니다.
+- 여러 사이트에 함께 올라온 같은 공고는 한 줄로 합치고, 나머지 링크는 `also_on`에 둡니다.
+- 예(2026-11-04 실측): 프론트엔드·경력 5년은 합친 뒤 173건 중 123건이 남고 50건이 연차 조건으로 빠졌습니다. 재무는 153건, 백엔드·경력 3년은 95건이 남았습니다.
+
+### 4. 고른 공고만 저장 - `save_job_posting`
+
+- 결과를 번호 목록으로 보여주고 "어떤 공고를 저장할까요?"라고 묻습니다. 사용자가 고른 공고만 `save_job_posting`으로 저장하고, 그다음은 B(공고 분석)로 이어갑니다.
+- 대시보드의 "공고 찾기" 화면에서도 같은 검색을 하고 클릭 한 번으로 저장할 수 있다고 안내해도 됩니다.
+
+---
+
 ## B. 공고 분석하기 (핵심 흐름)
 
 사용자가 공고 링크나 내용을 주면 아래 순서로 진행합니다.

package/docs/WORKFLOWS.md

@@ -234,6 +234,30 @@ LinkedIn 프로필과 포트폴리오 같은 자기표현 자산을 직무에
 
 ---
 
+## 공고 찾기 (analyze_job 앞 단계)
+
+공고 찾기는 별도 워크플로우로 정의돼 있지 않다. 사용자에게 지원할 공고가 아직 없을 때 `analyze_job` 앞에서 쓴다.
+
+**트리거:** "백엔드 공고 찾아줘 / 경리 공고 있어? / 오늘 올라온 내 직무 공고 보여줘"처럼 공고를 찾아 달라고 할 때.
+
+**단계:**
+
+1. `find_job_categories`로 사용자 직무(말하지 않았으면 프로필의 희망 직무)를 리멤버 분류와 사람인 코드로 바꾼다. 모든 직군을 다루며, 내장 분류표를 쓰므로 외부 통신이 없다.
+2. 자주 볼 직무라고 사용자가 확인하면 `set_job_search_preferences`로 저장한다. 이후 "오늘 올라온 공고"는 `search_jobs`를 조건 없이 `posted_since: "today"`로 부른다.
+3. `search_jobs`로 원티드·점핏·리멤버·사람인의 공개 공고를 가져온다. 경력 연차를 알면 `years`로 경력 범위에 맞지 않는 공고를 거른다. 원티드·점핏은 게시일을 주지 않아 CareerMate가 처음 본 날로 거르므로, 첫 검색에서는 전부 새 공고로 보인다고 알린다.
+4. 결과를 번호 목록으로 보여주고, 사용자가 고른 공고만 `save_job_posting`으로 저장한 뒤 `analyze_job`으로 이어간다.
+
+```
+find_job_categories
+  → set_job_search_preferences        # 자주 볼 직무일 때, 사용자 확인 후
+  → search_jobs                       # posted_since·years는 필요할 때
+  → (사용자가 공고 선택)
+  → save_job_posting                  # 고른 공고만
+  → analyze_job
+```
+
+---
+
 ## 워크플로우 간 연결
 
 워크플로우는 독립적이지 않고 자연스럽게 이어진다.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "careermate",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "type": "module",
   "description": "CareerMate — an MCP-first, local-first career workspace. Your career database and documents stay on your machine; optional discovery and update features may use the internet without sending stored career data.",
   "license": "MIT",

package/packages/core/src/job-categories.ts

@@ -95,12 +95,23 @@ export function isRememberCategory(value: string): boolean {
   return !!subs && (sub === undefined || subs.includes(sub));
 }
 
-let saraminCodes: Set<string> | undefined;
+let saraminCodes: Map<string, string> | undefined;
+// First name wins if a code repeats, so the 직무·직업 name (listed first) is kept.
+const saraminIndex = () => {
+  if (!saraminCodes) {
+    saraminCodes = new Map();
+    for (const kinds of Object.values(SARAMIN_CATEGORIES))
+      for (const list of Object.values(kinds)) for (const [c, n] of list) if (!saraminCodes.has(c)) saraminCodes.set(c, n);
+  }
+  return saraminCodes;
+};
 
 /** A cat_kewd code from the snapshot. Unknown codes are rejected rather than risk an unfiltered list. */
 export function isSaraminCategory(code: string): boolean {
-  saraminCodes ??= new Set(
-    Object.values(SARAMIN_CATEGORIES).flatMap((kinds) => Object.values(kinds).flatMap((list) => list.map(([c]) => c))),
-  );
-  return saraminCodes.has(code);
+  return saraminIndex().has(code);
+}
+
+/** Display name of a Saramin code ("322" -> "경리"), or undefined if unknown. */
+export function saraminCategoryName(code: string): string | undefined {
+  return saraminIndex().get(code);
 }