@nomadamas/k-skill 0.1.0

package/skills/job-posting-match/scripts/job_posting_match.py

@@ -0,0 +1,396 @@
+#!/usr/bin/env python3
+"""Match Korean job postings against a job seeker's resume/profile.
+
+Reads public JobKorea and Saramin search result pages only. It does not log in,
+submit applications, save postings, or mutate any account state.
+"""
+from __future__ import annotations
+
+import argparse
+import html
+import json
+import re
+import sys
+import urllib.error
+import urllib.parse
+import urllib.request
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Iterable
+
+USER_AGENT = "Mozilla/5.0 (compatible; k-skill job-posting-match/1.0; +https://github.com/NomaDamas/k-skill)"
+
+ROLE_TERMS = [
+    "퍼포먼스 마케터", "그로스 마케터", "CRM 마케터", "콘텐츠 마케터", "브랜드 마케터", "마케팅 매니저",
+    "백엔드 개발자", "프론트엔드 개발자", "풀스택 개발자", "데이터 분석가", "데이터 엔지니어", "프로덕트 매니저",
+    "서비스 기획자", "프로덕트 디자이너", "UI/UX 디자이너", "영업", "회계", "인사", "채용", "운영", "MD",
+]
+TOOL_TERMS = [
+    "GA4", "Google Ads", "Meta Ads", "Facebook Ads", "SQL", "Python", "Java", "Spring", "React", "Vue",
+    "Node.js", "TypeScript", "JavaScript", "AWS", "GCP", "Kubernetes", "Docker", "Looker Studio", "Tableau",
+    "Amplitude", "Braze", "CRM", "SEO", "ASO", "Figma", "Notion", "Excel", "PowerPoint",
+]
+INDUSTRY_TERMS = ["커머스", "이커머스", "B2C", "B2B", "SaaS", "핀테크", "에듀테크", "헬스케어", "게임", "콘텐츠", "플랫폼", "스타트업"]
+NEGATIVE_DEFAULTS = ["보험영업", "대출영업", "텔레마케팅", "TM", "방문판매", "다단계"]
+ACTION_LABELS = {"스크랩", "관심공고", "즉시지원", "입사지원", "홈페이지 지원", "저장", "공유", "닫기", "더보기"}
+
+
+@dataclass
+class Posting:
+    source: str
+    title: str
+    company: str = ""
+    url: str = ""
+    location: str = ""
+    career: str = ""
+    deadline: str = ""
+    summary: str = ""
+    score: int = 0
+    reasons: list[str] = field(default_factory=list)
+    cautions: list[str] = field(default_factory=list)
+    matched_terms: list[str] = field(default_factory=list)
+
+
+def clean_text(value: str) -> str:
+    value = re.sub(r"<script\b.*?</script>", " ", value, flags=re.I | re.S)
+    value = re.sub(r"<style\b.*?</style>", " ", value, flags=re.I | re.S)
+    value = re.sub(r"<[^>]+>", " ", value)
+    value = html.unescape(value)
+    value = re.sub(r"\s+", " ", value).strip()
+    for label in ACTION_LABELS:
+        value = re.sub(rf"\b{re.escape(label)}\b", " ", value)
+    return re.sub(r"\s+", " ", value).strip()
+
+
+def fetch(url: str) -> str:
+    req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT, "Accept-Language": "ko-KR,ko;q=0.9"})
+    with urllib.request.urlopen(req, timeout=25) as response:
+        raw = response.read()
+        charset = response.headers.get_content_charset() or "utf-8"
+        return raw.decode(charset, "replace")
+
+
+def absolute_url(source: str, href: str) -> str:
+    href = html.unescape(href)
+    base = "https://www.jobkorea.co.kr" if source == "jobkorea" else "https://www.saramin.co.kr"
+    return urllib.parse.urljoin(base, href)
+
+
+def attribute_text(value: object) -> str:
+    return value if isinstance(value, str) else ""
+
+
+def split_keywords(text: str) -> list[str]:
+    found: list[str] = []
+    lower = text.lower()
+    for term in ROLE_TERMS + TOOL_TERMS + INDUSTRY_TERMS:
+        if term.lower() in lower and term not in found:
+            found.append(term)
+    # Add a few meaningful free tokens, but avoid single Korean syllables and common words.
+    stop = {"경력", "경험", "담당", "업무", "지원", "희망", "사용", "가능", "이력서", "자기소개서", "서울", "경기"}
+    for token in re.findall(r"[A-Za-z][A-Za-z0-9.+#-]{1,}|[가-힣]{2,}", text):
+        if token in stop or token in found:
+            continue
+        if len(found) >= 16:
+            break
+        found.append(token)
+    return found
+
+
+def build_queries(resume_text: str, explicit: list[str]) -> list[str]:
+    if explicit:
+        return [q.strip() for q in explicit if q.strip()]
+    terms = split_keywords(resume_text)
+    roles = [t for t in terms if t in ROLE_TERMS]
+    tools = [t for t in terms if t in TOOL_TERMS]
+    industries = [t for t in terms if t in INDUSTRY_TERMS]
+    queries: list[str] = []
+    if roles:
+        queries.append(" ".join((roles[:1] + tools[:2])[:3]))
+        if len(roles) > 1:
+            queries.append(" ".join((roles[1:2] + tools[:1])[:2]))
+    if industries and roles:
+        queries.append(f"{industries[0]} {roles[0]}")
+    if not queries and terms:
+        queries.append(" ".join(terms[:3]))
+    return list(dict.fromkeys(q for q in queries if q))[:3]
+
+
+def parse_jobkorea(markup: str, limit: int) -> list[Posting]:
+    postings: list[Posting] = []
+    seen: set[str] = set()
+    try:
+        from bs4 import BeautifulSoup  # type: ignore
+        soup = BeautifulSoup(markup, "html.parser")
+        anchors = soup.find_all("a", href=re.compile(r"/Recruit/GI_Read/", re.I))
+        for a in anchors:
+            url = absolute_url("jobkorea", attribute_text(a.get("href")))
+            job_id = re.search(r"/Recruit/GI_Read/(\d+)", url)
+            key = job_id.group(1) if job_id else url
+            text = clean_text(a.get_text(" "))
+            if not text or key in seen or len(text) < 4:
+                continue
+            container = a.find_parent(attrs={"data-sentry-component": "CardJob"}) or a.find_parent("div")
+            blob = clean_text(container.get_text(" ") if container else text)
+            company = ""
+            same_links = container.find_all("a", href=True) if container else []
+            for link in same_links:
+                lt = clean_text(link.get_text(" "))
+                if lt and lt != text and len(lt) <= 40 and not re.search(r"채용|모집|마케터|개발자|담당|매니저", lt):
+                    company = lt
+                    break
+            postings.append(Posting(source="jobkorea", title=text, company=company, url=url, summary=blob[:700]))
+            seen.add(key)
+            if len(postings) >= limit:
+                break
+    except Exception:
+        pass
+    if postings:
+        return postings
+
+    for m in re.finditer(r'<a\b[^>]*href=["\']([^"\']*/Recruit/GI_Read/\d+[^"\']*)["\'][^>]*>(.*?)</a>', markup, re.I | re.S):
+        url = absolute_url("jobkorea", m.group(1))
+        key = re.search(r"/Recruit/GI_Read/(\d+)", url)
+        key_s = key.group(1) if key else url
+        title = clean_text(m.group(2))
+        if not title or key_s in seen:
+            continue
+        postings.append(Posting(source="jobkorea", title=title, url=url, summary=title))
+        seen.add(key_s)
+        if len(postings) >= limit:
+            break
+    return postings
+
+
+def parse_saramin(markup: str, limit: int) -> list[Posting]:
+    postings: list[Posting] = []
+    seen: set[str] = set()
+    try:
+        from bs4 import BeautifulSoup  # type: ignore
+        soup = BeautifulSoup(markup, "html.parser")
+        for item in soup.select("div.item_recruit, div.list_item, div.item_recruit_sri"):
+            a = item.select_one('h2.job_tit a[href*="/zf_user/jobs/relay/view"], a[href*="rec_idx="]')
+            if not a:
+                continue
+            url = absolute_url("saramin", attribute_text(a.get("href")))
+            rec = re.search(r"rec_idx=(\d+)", url)
+            key = rec.group(1) if rec else url
+            if key in seen:
+                continue
+            title = clean_text(attribute_text(a.get("title")) or a.get_text(" "))
+            company_el = item.select_one(".corp_name a, .corp_name, .company_nm a, .company_nm")
+            condition = clean_text(" ".join(x.get_text(" ") for x in item.select(".job_condition span, .job_sector, .area, .career, .education")))
+            deadline_el = item.select_one(".date, .deadlines, .support_detail .date")
+            company = clean_text(company_el.get_text(" ")) if company_el else ""
+            deadline = clean_text(deadline_el.get_text(" ")) if deadline_el else ""
+            blob = clean_text(item.get_text(" "))
+            postings.append(Posting(source="saramin", title=title, company=company, url=url, career=condition, deadline=deadline, summary=blob[:700]))
+            seen.add(key)
+            if len(postings) >= limit:
+                break
+    except Exception:
+        pass
+    if postings:
+        return postings
+
+    blocks = re.split(r'<div[^>]+class=["\'][^"\']*item_recruit', markup, flags=re.I)
+    for block in blocks[1:]:
+        m = re.search(r'<a\b[^>]*href=["\']([^"\']*rec_idx=\d+[^"\']*)["\'][^>]*(?:title=["\']([^"\']+)["\'])?[^>]*>(.*?)</a>', block, re.I | re.S)
+        if not m:
+            continue
+        url = absolute_url("saramin", m.group(1))
+        key = re.search(r"rec_idx=(\d+)", url)
+        key_s = key.group(1) if key else url
+        if key_s in seen:
+            continue
+        title = clean_text(m.group(2) or m.group(3))
+        company_match = re.search(r'class=["\'][^"\']*corp_name[^"\']*["\'][^>]*>\s*(?:<a[^>]*>)?(.*?)(?:</a>)?\s*</', block, re.I | re.S)
+        company = clean_text(company_match.group(1)) if company_match else ""
+        postings.append(Posting(source="saramin", title=title, company=company, url=url, summary=clean_text(block)[:700]))
+        seen.add(key_s)
+        if len(postings) >= limit:
+            break
+    return postings
+
+
+def search_jobkorea(query: str, limit: int) -> list[Posting]:
+    url = "https://www.jobkorea.co.kr/Search/?" + urllib.parse.urlencode({"stext": query})
+    markup = fetch(url)
+    if "잡코리아" not in markup and "JobKorea" not in markup:
+        raise RuntimeError("잡코리아가 예상과 다른 응답을 반환했습니다")
+    return parse_jobkorea(markup, limit)
+
+
+def search_saramin(query: str, limit: int) -> list[Posting]:
+    url = "https://www.saramin.co.kr/zf_user/search/recruit?" + urllib.parse.urlencode({"searchword": query})
+    markup = fetch(url)
+    if "사람인" not in markup and "Saramin" not in markup:
+        raise RuntimeError("사람인이 예상과 다른 응답을 반환했습니다")
+    return parse_saramin(markup, limit)
+
+
+def detect_career_years(text: str) -> int | None:
+    years = [int(x) for x in re.findall(r"(\d{1,2})\s*년", text)]
+    return max(years) if years else None
+
+
+def negative_term_matches(term: str, haystack: str) -> bool:
+    normalized = term.strip().lower()
+    if not normalized:
+        return False
+    if re.fullmatch(r"[a-z0-9]{1,3}", normalized):
+        return re.search(rf"(?<![a-z0-9]){re.escape(normalized)}(?![a-z0-9])", haystack) is not None
+    return normalized in haystack
+
+
+def score_posting(posting: Posting, resume_text: str, desired_locations: list[str], negative_terms: list[str], career_years: int | None) -> Posting:
+    haystack = " ".join([posting.title, posting.company, posting.location, posting.career, posting.summary]).lower()
+    resume_terms = split_keywords(resume_text)
+    matched = [term for term in resume_terms if term.lower() in haystack]
+    role_matches = [t for t in matched if t in ROLE_TERMS]
+    tool_matches = [t for t in matched if t in TOOL_TERMS]
+    industry_matches = [t for t in matched if t in INDUSTRY_TERMS]
+
+    score = 35
+    score += min(25, len(role_matches) * 12 + max(0, len(matched) - len(role_matches)) * 2)
+    score += min(20, len(tool_matches) * 5)
+    score += min(10, len(industry_matches) * 5)
+
+    reasons: list[str] = []
+    cautions: list[str] = []
+    if role_matches:
+        reasons.append("직무 키워드 일치: " + ", ".join(role_matches[:3]))
+    if tool_matches:
+        reasons.append("도구/스킬 일치: " + ", ".join(tool_matches[:5]))
+    if industry_matches:
+        reasons.append("산업/도메인 힌트 일치: " + ", ".join(industry_matches[:3]))
+    if desired_locations:
+        loc_hits = [loc for loc in desired_locations if loc.lower() in haystack]
+        if loc_hits:
+            score += 10
+            reasons.append("희망 지역 일치: " + ", ".join(loc_hits))
+        else:
+            cautions.append("희망 지역은 목록 요약에서 확인되지 않음")
+    if career_years is not None:
+        if "신입" in haystack and career_years >= 3:
+            score -= 15
+            cautions.append("신입 공고일 가능성이 있어 경력과 맞지 않을 수 있음")
+        elif "경력" in haystack or re.search(r"\d+\s*년", haystack):
+            score += 5
+            reasons.append("경력 조건이 있는 공고로 보임")
+    bad_hits = [term for term in negative_terms if negative_term_matches(term, haystack)]
+    if bad_hits:
+        score -= 30
+        cautions.append("제외 조건 감지: " + ", ".join(bad_hits[:5]))
+    if not reasons:
+        cautions.append("이력서 키워드와 직접 일치하는 근거가 적어 낮은 신뢰도의 후보")
+
+    posting.score = max(0, min(100, score))
+    posting.reasons = reasons
+    posting.cautions = cautions
+    posting.matched_terms = matched[:12]
+    return posting
+
+
+def dedupe(postings: Iterable[Posting]) -> list[Posting]:
+    out: list[Posting] = []
+    seen: set[str] = set()
+    for p in postings:
+        key = re.sub(r"[?#].*$", "", p.url) or (p.source + p.title + p.company)
+        if key in seen:
+            continue
+        seen.add(key)
+        out.append(p)
+    return out
+
+
+def print_markdown(postings: list[Posting], queries: list[str], args: argparse.Namespace) -> None:
+    print("# 이력서 기반 채용공고 매칭 결과\n")
+    print(f"- 검색어: {', '.join(queries)}")
+    print(f"- 조회 소스: {', '.join(args.source)}")
+    print(f"- 결과 수: {len(postings)}")
+    print("- 주의: 공개 검색 결과 요약 기반 추천입니다. 지원 전 원문 공고에서 마감일·연봉·근무지·자격요건을 직접 확인하세요.")
+    print("- 안전 경계: 로그인, 스크랩, 입사지원, 개인정보 입력, 메시지 발송은 자동 수행하지 않았습니다.\n")
+    for idx, p in enumerate(postings, 1):
+        print(f"## {idx}. [{p.source}] {p.title}")
+        if p.company:
+            print(f"- 회사: {p.company}")
+        print(f"- 점수: {p.score}/100")
+        print(f"- URL: {p.url}")
+        if p.reasons:
+            print("- 추천 이유: " + "; ".join(p.reasons))
+        if p.cautions:
+            print("- 주의점: " + "; ".join(p.cautions))
+        if p.matched_terms:
+            print("- 매칭 키워드: " + ", ".join(p.matched_terms))
+        print("- 지원 전략: 공고 제목/요약과 일치하는 경험을 이력서 상단 요약과 최근 경력 bullet에 먼저 배치하세요.")
+        print()
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Match JobKorea/Saramin public job postings against a resume")
+    src = parser.add_mutually_exclusive_group()
+    src.add_argument("--resume-text", help="이력서/경력요약 텍스트")
+    src.add_argument("--resume-file", help="이력서/경력요약 텍스트 파일")
+    parser.add_argument("--keyword", "-k", action="append", default=[], help="검색어. 없으면 이력서에서 자동 생성")
+    parser.add_argument("--location", action="append", default=[], help="희망 지역. 여러 번 지정 가능")
+    parser.add_argument("--negative", action="append", default=[], help="제외 키워드. 여러 번 지정 가능")
+    parser.add_argument("--career-years", type=int, help="경력 연차. 없으면 이력서 텍스트에서 추정")
+    parser.add_argument("--source", action="append", choices=["jobkorea", "saramin"], help="조회 소스. 기본: 둘 다")
+    parser.add_argument("--per-source", type=int, default=10, help="검색어별/소스별 가져올 공고 수")
+    parser.add_argument("--limit", type=int, default=10, help="최종 출력 공고 수")
+    parser.add_argument("--json", action="store_true", help="JSON 출력")
+    return parser
+
+
+def run(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if args.resume_file:
+        resume_text = Path(args.resume_file).read_text(encoding="utf-8")
+    else:
+        resume_text = args.resume_text or ""
+    if not resume_text and not args.keyword:
+        parser.error("--resume-text/--resume-file 또는 --keyword 중 하나는 필요합니다")
+    args.source = args.source or ["jobkorea", "saramin"]
+    career_years = args.career_years if args.career_years is not None else detect_career_years(resume_text)
+    queries = build_queries(resume_text, args.keyword)
+    negative_terms = list(dict.fromkeys(args.negative + NEGATIVE_DEFAULTS))
+
+    collected: list[Posting] = []
+    errors: list[str] = []
+    for query in queries:
+        if "jobkorea" in args.source:
+            try:
+                collected.extend(search_jobkorea(query, args.per_source))
+            except Exception as exc:  # noqa: BLE001 - CLI should continue with other source
+                errors.append(f"jobkorea:{query}: {exc}")
+        if "saramin" in args.source:
+            try:
+                collected.extend(search_saramin(query, args.per_source))
+            except Exception as exc:  # noqa: BLE001
+                errors.append(f"saramin:{query}: {exc}")
+
+    scored = [score_posting(p, resume_text or " ".join(queries), args.location, negative_terms, career_years) for p in dedupe(collected)]
+    scored.sort(key=lambda p: p.score, reverse=True)
+    result = scored[: args.limit]
+    if args.json:
+        print(json.dumps({"queries": queries, "errors": errors, "postings": [asdict(p) for p in result]}, ensure_ascii=False, indent=2))
+    else:
+        print_markdown(result, queries, args)
+        if errors:
+            print("## 조회 경고")
+            for error in errors:
+                print(f"- {error}")
+    return 0 if result else 1
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(run())
+    except urllib.error.HTTPError as exc:
+        print(f"HTTP error: {exc.code} {exc.reason}", file=sys.stderr)
+        raise SystemExit(2)
+    except (urllib.error.URLError, RuntimeError) as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        raise SystemExit(1)

package/skills/job-posting-match/scripts/test_job_posting_match.py

@@ -0,0 +1,54 @@
+import unittest
+
+from job_posting_match import NEGATIVE_DEFAULTS, Posting, build_queries, parse_jobkorea, parse_saramin, score_posting
+
+
+JOBKOREA_FIXTURE = '\n<div data-sentry-component="CardJob">\n  <a href="https://www.jobkorea.co.kr/Recruit/GI_Read/111?x=1">퍼포먼스 마케터 채용</a>\n  <a href="https://www.jobkorea.co.kr/Recruit/GI_Read/111?x=1">커머스A</a>\n  <p>서울 강남구 경력 3년 GA4 Google Ads Meta Ads 커머스</p>\n</div>\n<div data-sentry-component="CardJob">\n  <a href="https://www.jobkorea.co.kr/Recruit/GI_Read/222?x=1">보험영업 담당자</a>\n  <a href="https://www.jobkorea.co.kr/Recruit/GI_Read/222?x=1">보험B</a>\n  <p>대출영업 TM 신입</p>\n</div>\n'
+
+SARANIM_FIXTURE = '\n<div class="item_recruit">\n  <div class="corp_name"><a>뷰티커머스</a></div>\n  <h2 class="job_tit"><a title="화장품 브랜드 퍼포먼스 마케터" href="/zf_user/jobs/relay/view?rec_idx=333&searchword=x"><span>화장품 브랜드 <b>퍼포먼스 마케터</b></span></a></h2>\n  <div class="job_condition"><span>서울</span><span>경력 5년</span></div>\n  <div class="job_sector">GA4 CRM Meta Ads 커머스</div>\n</div>\n<div class="item_recruit">\n  <div class="corp_name"><a>무관회사</a></div>\n  <h2 class="job_tit"><a title="총무 담당자" href="/zf_user/jobs/relay/view?rec_idx=444"><span>총무 담당자</span></a></h2>\n  <div class="job_condition"><span>부산</span><span>신입</span></div>\n</div>\n'
+
+
+class JobPostingMatchTest(unittest.TestCase):
+    def test_build_queries_from_resume(self):
+        queries = build_queries("퍼포먼스 마케터 5년 GA4 Meta Ads SQL 커머스", [])
+        self.assertTrue(any("퍼포먼스 마케터" in q for q in queries))
+        self.assertLessEqual(len(queries), 3)
+
+    def test_parse_jobkorea_cards_and_dedupe(self):
+        postings = parse_jobkorea(JOBKOREA_FIXTURE, 10)
+        self.assertEqual(len(postings), 2)
+        self.assertEqual(postings[0].title, "퍼포먼스 마케터 채용")
+        self.assertIn("GI_Read/111", postings[0].url)
+
+    def test_parse_saramin_cards(self):
+        postings = parse_saramin(SARANIM_FIXTURE, 10)
+        self.assertEqual(len(postings), 2)
+        self.assertEqual(postings[0].company, "뷰티커머스")
+        self.assertIn("rec_idx=333", postings[0].url)
+
+    def test_score_prefers_matching_posting_and_penalizes_negative(self):
+        resume = "퍼포먼스 마케터 5년 GA4 Google Ads Meta Ads SQL 커머스 서울"
+        good, bad = parse_jobkorea(JOBKOREA_FIXTURE, 10)
+        good = score_posting(good, resume, ["서울"], ["보험영업", "대출영업"], 5)
+        bad = score_posting(bad, resume, ["서울"], ["보험영업", "대출영업"], 5)
+        self.assertGreater(good.score, bad.score)
+        self.assertTrue(good.reasons)
+        self.assertTrue(any("제외 조건" in c for c in bad.cautions))
+
+    def test_score_does_not_match_short_latin_negative_inside_words(self):
+        resume = "프론트엔드 개발자 5년 React TypeScript HTML CSS 서울"
+        posting = Posting(
+            source="fixture",
+            title="프론트엔드 개발자",
+            company="A",
+            summary="React TypeScript HTML CSS 서울 경력 5년",
+        )
+
+        scored = score_posting(posting, resume, ["서울"], NEGATIVE_DEFAULTS, 5)
+
+        self.assertEqual(scored.score, 84)
+        self.assertFalse(any("TM" in caution for caution in scored.cautions))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/job-posting-match/skill.json

@@ -0,0 +1,8 @@
+{
+  "name": "job-posting-match",
+  "description": "한국 구직자의 이력서·경력요약과 희망조건을 바탕으로 잡코리아·사람인 공개 채용공고를 검색하고 적합도와 지원 전략을 정리합니다. 돌쇠에서는 공식 표면을 통한 후속 액션까지 진행한다.",
+  "profiles": [
+    "action:communication"
+  ],
+  "frontmatter": "name: job-posting-match\ndescription: 한국 구직자의 이력서·경력요약과 희망조건을 바탕으로 잡코리아·사람인 공개 채용공고를 검색하고 적합도와 지원 전략을 정리합니다. 돌쇠에서는 공식 표면을 통한 후속 액션까지 진행한다.\nlicense: MIT\nmetadata:\n  category: recruiting\n  locale: ko-KR\n  phase: v1"
+}

package/skills/jobkorea-talent-search/instruction.md

@@ -0,0 +1,118 @@
+# jobkorea-talent-search
+
+## Use when
+
+- 사용자가 잡코리아에서 후보를 찾아달라고 요청한다.
+- 기업회원 로그인 세션에서 마스킹 이력서/목록을 비교해야 한다.
+- 유료 열람 전 shortlist, 점수, 근거, 리스크, 후보 URL이 필요하다.
+
+## Hard boundaries
+
+Allowed:
+- 잡코리아 기업회원 브라우저 세션 열기 및 검색 필터 입력
+- 현재 보이는 마스킹 목록/이력서/프로필 읽기
+- 후보 분석, 점수화, shortlist 작성, 유료 열람 추천
+
+Never do without explicit user handoff/confirmation:
+- 유료 이력서 열람, 마스킹 해제, 연락처 확인
+- 포지션 제안 발송, 스크랩, 메모 저장, 후보 상태 변경
+- 결제/유료 크레딧 사용
+- 비밀번호, OTP, 인증번호, 세션 쿠키 요청/저장
+- 후보 개인정보 장기 저장 또는 대량 수집
+
+If a control may spend credits, reveal contact/private info, send a proposal, or mutate account state, stop before clicking it.
+
+## Primary access
+
+Open:
+
+```text
+https://www.jobkorea.co.kr/corp/person/find
+```
+
+If not logged in, pause and show:
+
+```text
+잡코리아 인재검색은 경력 상세/포트폴리오/마스킹 이력서 확인을 위해 기업회원 로그인이 필요합니다.
+제가 브라우저로 잡코리아 기업 인재검색 페이지를 열어둘게요.
+열린 브라우저에서 직접 로그인해 주세요. 비밀번호나 인증정보는 저에게 알려주지 마세요.
+로그인이 끝나면 “로그인했어”라고 알려주시면, 같은 브라우저 세션에서 검색을 이어가겠습니다.
+```
+
+Resume only in the same browser session after the user confirms login.
+
+## Input normalization
+
+Extract or infer:
+
+- role_title
+- must_have / nice_to_have
+- negative_keywords
+- career min/max
+- location/work_area
+- role-specific evaluation signals
+- limit / requested Top N
+
+Do not block on missing details when a reasonable first search is possible.
+
+## Workflow
+
+1. Open the primary URL and verify corporate login.
+2. Ask the user to log in manually only when required; never handle credentials.
+3. Apply filters: keyword, 직무/스킬, 지역, 경력, recent activity/update, exclusions when supported.
+4. Build a candidate pool from visible rows.
+5. Before final Top N, open normal resume/detail links for promising candidates when this does not trigger paid unlock/contact/proposal actions.
+6. Read only visible free/masked details: career, responsibilities, project/achievement evidence, skills, education/certs/languages, desired location/salary, portfolio links if visible, recent activity.
+7. Score role-adaptively: must-have fit, career depth, concrete achievement/project evidence, location/activity fit, nice-to-have signals, and risk penalty.
+8. Return Korean shortlist with direct URL per recommended candidate.
+
+If detail pages are inaccessible or paid-walled, label results as `목록 기반 1차 shortlist` and lower confidence. If detail text was inspected, label as `상세 이력 확인 기반 shortlist`.
+
+## No-login fallback
+
+Use only when the user cannot or will not log in. It is low-confidence because it cannot inspect resume details.
+
+```bash
+python3 jobkorea-talent-search/scripts/jobkorea_talent_search.py   --keyword "퍼포먼스 마케터 GA4"   --work-area "서울"   --career-min 3   --career-max 7   --limit 20
+```
+
+## URL extraction guidance
+
+Every recommended candidate needs a direct JobKorea resume/profile URL whenever available. If browser extraction fails, inspect anchors, onclick handlers, data attributes, card containers, and detail-page `location.href`. If still missing, write `URL: 추출 실패` and explain why.
+
+## Output shape
+
+```text
+잡코리아 인재 shortlist
+
+검색 조건
+- 포지션: ...
+- 필수/우대/제외 조건: ...
+- 경력/지역: ...
+- 모드: 상세 이력 확인 기반 shortlist / 목록 기반 1차 shortlist
+
+유료 열람 추천 Top N
+1. 후보 A
+   - 점수: 88/100
+   - 근거: ...
+   - 보이는 경력/성과: ...
+   - 리스크: ...
+   - 추천 액션: 채용 담당자가 유료 열람 검토
+   - URL: ...
+
+보류 후보
+- ...
+
+검색 한계
+- 마스킹/현재 표시 정보만 분석했음
+- 연락처/실명/비공개 정보는 열람하지 않음
+- 유료 액션은 실행하지 않음
+```
+
+## Failure modes
+
+- Login/2FA required: open the page and let the user complete it manually.
+- Browser/session unavailable: explain that the agent needs browser/computer-use access; do not silently switch to low-confidence fallback.
+- Paid wall/contact wall: stop and mark as manual paid review needed.
+- Empty results: adjust keywords, career, region, update/relevance filters.
+- UI changed: rediscover the visible form/data flow before updating scripts.

package/skills/jobkorea-talent-search/scripts/jobkorea_talent_models.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Final
+
+BASE_URL: Final = "https://www.jobkorea.co.kr"
+FIND_PATH: Final = "/corp/person/find"
+AJAX_PATH: Final = "/corp/person/detailsearchajax"
+DEFAULT_UA: Final = (
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+    "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0 Safari/537.36"
+)
+
+
+@dataclass(frozen=True, slots=True)
+class Candidate:
+    rno: str
+    url: str
+    name: str = ""
+    meta: str = ""
+    career: str = ""
+    education: str = ""
+    locations: str = ""
+    salary: str = ""
+    skills: str = ""
+    badges: str = ""
+    raw_summary: str = ""