@heripo/research-radar 5.0.6 → 5.2.0

package/dist/index.js

@@ -2,6 +2,7 @@ import { createAnthropic } from '@ai-sdk/anthropic';
 import { createGoogleGenerativeAI } from '@ai-sdk/google';
 import { createOpenAI } from '@ai-sdk/openai';
 import { DateType, GenerateNewsletter } from '@llm-newsletter-kit/core';
+import { jsonSchema, generateText, Output } from 'ai';
 import * as cheerio from 'cheerio';
 import TurndownService from 'turndown';
 import { JSDOM } from 'jsdom';
@@ -9,6 +10,440 @@ import safeMarkdown2Html from 'safe-markdown2html';
 import DOMPurify from 'dompurify';
 import juice from 'juice';
 
+/**
+ * Deterministic pre-filter for public job-posting APIs.
+ *
+ * Both sources return every public-sector vacancy in the country — roughly
+ * 1,300 postings per fortnight from 나라일터 alone — so the newsletter pipeline
+ * must not see them all. Scoring is an LLM call per article, and asking it to
+ * reject thousands of unrelated postings would be slow, expensive, and noisy.
+ *
+ * This cuts by rule first, and deliberately errs toward keeping things: a
+ * posting survives if its institution is a heritage body **or** its title names
+ * a heritage job. The remaining judgement — a heritage institution hiring for a
+ * non-heritage role, or a borderline field — is left to the importance prompt,
+ * which reads the full posting.
+ */
+/** Institutions whose name alone settles the domain. */
+const HERITAGE_INSTITUTION = /국가유산청|국립문화유산연구원|국립해양유산연구소|한국전통문화대학교|국가유산진흥원|국립고궁박물관|궁능유적본부|국립[가-힣]*박물관|[가-힣]{2,}시립박물관|[가-힣]{2,}군립박물관|역사박물관|민속박물관|문화유산|국가유산|문화재단|[가-힣]{2,}유적|[가-힣]{2,}유물|고고|발굴/;
+/** Job titles that settle the domain regardless of the institution. */
+const HERITAGE_JOB = /학예|고고|발굴|매장유산|보존처리|보존과학|문화재|국가유산|문화유산|유물|고건축|전통건축|수리기술|전통문화|무형유산|천연기념물|전시기획|큐레이터|학예연구/;
+/**
+ * Roles excluded even at a heritage institution.
+ *
+ * A museum hiring a cleaner or a security guard is not heritage news. This is
+ * the same distinction the importance prompt makes, applied here so the obvious
+ * cases never cost an LLM call.
+ */
+const NON_HERITAGE_ROLE = /미화|청소|방호|경비|청원경찰|조리|취사|영양사|시설관리|시설물|기계설비|전기설비|조경|운전|당직|소방|보건|간호|집배|매점|카페|주차|경리|경호/;
+/** NCS job categories that can plausibly carry heritage work (재정경제부 API). */
+const HERITAGE_NCS_CODES = [
+    'R600004', // 교육.자연.사회과학 — 고고학·역사학 연구직
+    'R600008', // 문화.예술.디자인.방송 — 학예·전시
+    'R600022', // 인쇄.목재.가구.공예 — 보존처리·전통공예
+    'R600025', // 연구
+];
+/**
+ * Whether a posting should reach the analysis stage.
+ *
+ * @returns true when the posting looks heritage-related and is not one of the
+ *   excluded support roles
+ */
+function isHeritageJobCandidate({ institution, title, categoryCodes = [], }) {
+    if (NON_HERITAGE_ROLE.test(title)) {
+        return false;
+    }
+    const named = HERITAGE_INSTITUTION.test(institution) || HERITAGE_JOB.test(title);
+    if (!named) {
+        return false;
+    }
+    if (categoryCodes.length === 0) {
+        return true;
+    }
+    return categoryCodes.some((code) => HERITAGE_NCS_CODES.includes(code));
+}
+/**
+ * Heritage subjects as they appear in a 나라장터 notice title.
+ *
+ * Wider than {@link HERITAGE_JOB} because a bid names the work rather than a
+ * role: 발굴조사, 보수정비, 기록화 and so on.
+ */
+const HERITAGE_BID_SUBJECT = /발굴조사|시굴조사|표본조사|입회조사|지표조사|매장유산|매장문화재|고분군|폐사지|문화재\s*수리|국가유산\s*수리|보존처리|보존과학|학예|고고|고건축|단청|석조문화재|목조문화재|전통건축|유적\s*정비|유물|기록화/;
+/**
+ * Work excluded from a 나라장터 notice regardless of who issued it.
+ *
+ * 나라장터 carries every public procurement notice in the country, and heritage
+ * vocabulary collides badly with civil engineering and event support: 급경사지
+ * 정밀조사 is landslide risk, not archaeology, and a museum's 건설폐기물 처리 or
+ * a 문화재단's 축제 셔틀버스 is not heritage work either. These are the cases
+ * that need no judgement — anything arguable is left to the importance prompt.
+ *
+ * A word whose meaning turns on how it is used does not belong here, because
+ * this check runs before every inclusion signal and cannot be argued back.
+ * `드론` is narrowed to `드론쇼` for that reason: 국가유산 방재드론 스테이션 운영
+ * is heritage disaster response. Dropped outright for the same reason:
+ * `재선충` (남양주 홍릉과 유릉 소나무재선충병 긴급 예방사업 is care of a
+ * 조선왕릉's historic landscape), `산불` (안동 산불피해 국가유산 복원(안동
+ * 국탄댁), 청송 만세루 산불피해 복원사업, and 국가유산 재난방지시설
+ * 구축(산불소화시설) are all heritage restoration or disaster prevention),
+ * `숲가꾸기` (the same 역사경관림 care as 재선충), and `소독`/`방역` (의림지
+ * 역사박물관 수장고 및 유물 소독 is collection conservation). All of them now
+ * reach the importance prompt, which reads the whole notice.
+ *
+ * Dropping them does not widen intake on its own: this list only decides notices
+ * that already carry an inclusion signal, and the 산불·숲가꾸기 forestry notices
+ * it used to catch carry none — over a two-week sample of 10,199 notices it
+ * admitted no new ones. What it changes is that those titles can now be argued
+ * for at all: 의림지 역사박물관 수장고 및 유물 소독 passes on `유물`, and
+ * 국가유산 재난방지시설 구축(산불소화시설) passes when 국가유산청 issues it.
+ * Where the issuer is a 지자체 and the title carries no subject term — 안동
+ * 산불피해 국가유산 복원(안동 국탄댁) — the notice still fails, on the
+ * inclusion side rather than here.
+ */
+const NON_HERITAGE_BID = /급경사지|사방댐|관정|제설|건설폐기물|생활폐기물|폐아스콘|석면|청소|경비|방호|급식|조리|셔틀|현수막|드론쇼|키오스크|주차/;
+/**
+ * 나라장터 procurement classifications that settle the domain on their own.
+ *
+ * The taxonomy carries one heritage category, and it catches notices no
+ * vocabulary would: 팔만대장경 P-XRF 분석, issued by 해인사 장경도량, matches
+ * neither the institution nor the title patterns. It is only a supplement —
+ * 공사 notices carry no classification at all, so it cannot replace them.
+ */
+const HERITAGE_PROCUREMENT_CLASSIFICATIONS = ['문화재 조사/발굴 및 수리'];
+/**
+ * Whether a 나라장터 notice should reach the analysis stage.
+ *
+ * Deliberately loose. Of roughly 1,000 notices a day this keeps about ten, and
+ * the remaining judgement — a heritage institution procuring fire alarms, a
+ * 문화재단 running a festival — is left to the importance prompt, which reads
+ * the whole notice. Tightening it here cost real articles: an earlier attempt
+ * to exclude 보수정비 also dropped 영양 하담고택 보수정비사업 and 보길도
+ * 윤선도원림 판석보 보수정비공사.
+ */
+function isHeritageBidCandidate({ institution, title, classification, }) {
+    if (NON_HERITAGE_BID.test(title)) {
+        return false;
+    }
+    if (classification &&
+        HERITAGE_PROCUREMENT_CLASSIFICATIONS.includes(classification.trim())) {
+        return true;
+    }
+    return (HERITAGE_INSTITUTION.test(institution) || HERITAGE_BID_SUBJECT.test(title));
+}
+
+const DEFAULT_BATCH_SIZE = 100;
+const DEFAULT_CONCURRENCY = 24;
+/**
+ * Asks for the indices to keep rather than a verdict per row.
+ *
+ * A boolean array has to line up with the input to mean anything, and a model
+ * that returns 99 or 101 entries for 100 rows shifts every verdict after the
+ * mistake without failing. Indices carry their own alignment, and anything out
+ * of range or repeated is discarded rather than trusted.
+ */
+const KEEP_SCHEMA = jsonSchema({
+    type: 'object',
+    properties: {
+        keep: {
+            type: 'array',
+            items: { type: 'integer' },
+            description: '국가유산 업무와 관련될 가능성이 있는 공고의 번호',
+        },
+    },
+    required: ['keep'],
+    additionalProperties: false,
+});
+const SYSTEM_PROMPT = `너는 대한민국 나라장터 입찰공고를 국가유산 뉴스레터용으로 선별한다.
+
+이것은 **선별** 단계이지 평가 단계가 아니다. 중요도와 기사 가치는 뒤의 채점
+단계가 공고 전문을 읽고 따로 판단한다. 따라서 여기서는 재현율을 우선하여
+**조금이라도 국가유산 업무일 가능성이 있으면 포함**한다. 애매하면 포함한다.
+
+포함할 것:
+- 발굴조사, 시굴조사, 지표조사, 입회조사, 매장유산 관련 사업
+- 국가유산·문화재의 수리, 보수, 정비, 복원, 이전, 해체
+- 보존처리, 보존과학, 기록화, 정밀실측, 학술연구, 종합정비계획
+- 고택, 종택, 재사, 서원, 향교, 사찰, 읍성, 산성, 고분, 왕릉, 원림, 명승 등
+  지정·비지정 유산을 대상으로 하는 사업
+- 박물관·미술관의 전시, 소장품·유물 관리, 수장고 업무
+- 국가유산을 대상으로 한 재난방지·방재·소방 시설
+
+제외할 것:
+- 유산과 무관한 토목, 임업, 도로, 상하수도, 조경 사업
+- 청소, 경비, 급식, 셔틀, 현수막 등 일반 지원 용역
+- 유산과 무관한 건물의 일반 시설 유지관리
+- 축제·행사의 운영 대행, 무대·음향·홍보물 등 행사 지원 그 자체
+
+단, 국가유산의 지정·승격·등록처럼 유산 자체에 일어난 일을 기념하거나
+알리는 사업은 행사 형식이더라도 포함한다.
+
+중요: **발주 기관이 국가유산 기관이 아니어도 사업 내용이 유산이면 포함한다.**
+지자체가 발주하는 고택 보수, 읍성 정비, 산불 피해 국가유산 복원이 여기 해당한다.
+반대로 발주 기관이 유산 기관이어도 내용이 무관하면 제외한다.
+
+주의: 한국어 부분문자열에 속지 마라. '생산성'은 산성이 아니고, '재사용'은
+재사가 아니며, '서원구'는 서원이 아니다.`;
+/**
+ * The three fields the model is shown, normalized once.
+ *
+ * The verdict cache keys on exactly this, so a candidate that reads identically
+ * to the model is the same candidate to the cache. Deriving both from here is
+ * what keeps them from drifting: keying on less than the model sees merges two
+ * notices that it judged separately, and the second verdict silently overwrites
+ * the first — within a single run, not only across retries.
+ */
+function identityOf(candidate) {
+    return [
+        candidate.institution.trim(),
+        candidate.title.trim(),
+        candidate.classification?.trim() ?? '',
+    ];
+}
+function buildUserPrompt(candidates) {
+    const lines = candidates.map((candidate, index) => {
+        const [institution, title, classification] = identityOf(candidate);
+        return (`${index}. [${institution}] ${title}` +
+            (classification ? ` <${classification}>` : ''));
+    });
+    return `다음 ${candidates.length}건 중 국가유산 업무와 관련될 가능성이 있는 공고의 번호만 골라라.\n\n${lines.join('\n')}`;
+}
+/** Applies the deterministic filter, which is what triage falls back to. */
+function deterministicVerdicts(candidates) {
+    return candidates.map((candidate) => isHeritageBidCandidate(candidate));
+}
+async function triageBatch(candidates, { model, onFallback }, signal) {
+    try {
+        const { output } = await generateText({
+            model,
+            output: Output.object({ schema: KEEP_SCHEMA }),
+            system: SYSTEM_PROMPT,
+            prompt: buildUserPrompt(candidates),
+            abortSignal: signal,
+        });
+        const verdicts = new Array(candidates.length).fill(false);
+        let usable = false;
+        for (const index of output.keep) {
+            if (Number.isInteger(index) && index >= 0 && index < candidates.length) {
+                verdicts[index] = true;
+                usable = true;
+            }
+        }
+        // An empty selection is a legitimate answer for a batch of road works, but
+        // a selection that is entirely out of range is a malformed response wearing
+        // the right shape, and it must not read as "reject everything".
+        if (!usable && output.keep.length > 0) {
+            onFallback?.('every returned index was out of range', candidates.length);
+            return deterministicVerdicts(candidates);
+        }
+        return verdicts;
+    }
+    catch (error) {
+        // A cancelled crawl must fail the fetch, not quietly answer from the regex:
+        // core has already given up on this attempt, and returning a list now would
+        // hand it a result it is no longer waiting for. The signal is the ground
+        // truth rather than the error's shape, which the AI SDK may have wrapped.
+        if (signal?.aborted) {
+            throw error;
+        }
+        onFallback?.(error instanceof Error ? error.message : String(error), candidates.length);
+        return deterministicVerdicts(candidates);
+    }
+}
+/**
+ * Builds the LLM triage that replaces the regex as 나라장터's gate.
+ *
+ * 나라장터 carries about 1,000 용역 and 공사 notices a day, so a 48-hour window
+ * holds roughly 1,500 — far too many to score one by one, which is why a
+ * deterministic filter stood here first. But heritage vocabulary cannot be
+ * settled by substring: `산불` is forestry in 산불예방 숲가꾸기 and heritage work
+ * in 안동 산불피해 국가유산 복원, and widening the other way collides just as
+ * badly (`산성` matches 생산성, `재사` matches 재사용). Judging 100 titles per
+ * request costs about 15 calls a day, so the judgement can be made by something
+ * that reads them.
+ *
+ * It never fails open: an error, or a response whose indices are unusable, falls
+ * back to {@link isHeritageBidCandidate} for that batch rather than admitting
+ * every notice into per-article scoring. Omitting triage entirely leaves the
+ * deterministic filter in charge, which is how the health-check runs without an
+ * LLM key.
+ */
+const createHeritageBidTriage = (options) => {
+    const { batchSize = DEFAULT_BATCH_SIZE, concurrency = DEFAULT_CONCURRENCY } = options;
+    // Verdicts survive across calls so core's retry resumes rather than restarts.
+    // Core aborts the first attempt at 10 seconds and tries again with a longer
+    // budget; without this, every attempt would pay for the whole window again.
+    const verdicts = new Map();
+    const keyOf = (candidate) => identityOf(candidate).join('\u0000');
+    return async (candidates, signal) => {
+        if (candidates.length === 0) {
+            return [];
+        }
+        const pending = candidates.filter((c) => !verdicts.has(keyOf(c)));
+        const batches = [];
+        for (let index = 0; index < pending.length; index += batchSize) {
+            batches.push(pending.slice(index, index + batchSize));
+        }
+        let next = 0;
+        const workers = Array.from({ length: Math.min(concurrency, batches.length) }, async () => {
+            while (next < batches.length) {
+                const batch = batches[next++];
+                const decided = await triageBatch(batch, options, signal);
+                batch.forEach((candidate, index) => {
+                    verdicts.set(keyOf(candidate), decided[index]);
+                });
+            }
+        });
+        // A rejection here propagates out of the fetch, which is what an aborted
+        // crawl needs; completed batches stay cached for the next attempt.
+        await Promise.all(workers);
+        return candidates.map((c) => verdicts.get(keyOf(c)) ?? false);
+    };
+};
+
+const API_BASE$2 = 'https://apis.data.go.kr/1051000/recruitment';
+const SITE_BASE$2 = 'https://job.alio.go.kr';
+/**
+ * Public 알리오 board URL used as this target's list page.
+ *
+ * As with 나라일터, core fetches this URL and `createAlioFetch` answers it from
+ * the 재정경제부 open API, keeping the service key out of the configuration.
+ */
+const ALIO_LIST_URL = `${SITE_BASE$2}/recruit.do`;
+/** Public posting URL. */
+const buildAlioDetailUrl = (serial) => `${SITE_BASE$2}/recruitview.do?idx=${serial}`;
+/** `yyyymmdd` to ISO `yyyy-mm-dd`. */
+function toIsoDate$2(compact) {
+    return /^\d{8}$/.test(compact)
+        ? `${compact.slice(0, 4)}-${compact.slice(4, 6)}-${compact.slice(6, 8)}`
+        : '';
+}
+/**
+ * Serves the 알리오 target from the 재정경제부 open API.
+ *
+ * This board only covers 공기업 and 준정부기관, so heritage postings are rare —
+ * 국가유산청 and the national museums publish through 나라일터 instead. It is
+ * collected anyway because a body like 국립농업박물관 does appear here, and the
+ * NCS job codes make filtering cheap and precise.
+ *
+ * Only postings still open (`ongoingYn=Y`) are requested.
+ */
+const createAlioFetch = (baseFetch = fetch, options) => {
+    const { apiKey, rowsPerPage = 3000 } = options;
+    return async (input, init) => {
+        const requestUrl = typeof input === 'string'
+            ? input
+            : input instanceof URL
+                ? input.href
+                : input.url;
+        let url;
+        try {
+            url = new URL(requestUrl);
+        }
+        catch {
+            return baseFetch(input, init);
+        }
+        if (url.origin !== SITE_BASE$2) {
+            return baseFetch(input, init);
+        }
+        if (!apiKey) {
+            // Without a key the board is simply not collected. See gojobs.parser.ts.
+            return Response.json({ result: [] });
+        }
+        if (url.pathname === '/recruit.do') {
+            return baseFetch(`${API_BASE$2}/list?serviceKey=${apiKey}&resultType=json` +
+                `&numOfRows=${rowsPerPage}&pageNo=1&ongoingYn=Y`, init);
+        }
+        if (url.pathname === '/recruitview.do') {
+            const serial = url.searchParams.get('idx');
+            if (serial) {
+                return baseFetch(`${API_BASE$2}/detail?serviceKey=${apiKey}&resultType=json&sn=${serial}`, init);
+            }
+        }
+        return baseFetch(input, init);
+    };
+};
+function parseJson$2(body) {
+    try {
+        return JSON.parse(body);
+    }
+    catch {
+        return null;
+    }
+}
+/** Renders a posting's fields as the article body. */
+function renderAlioContent(record) {
+    const lines = [
+        ['기관', record.instNm],
+        ['직무분야', record.ncsCdNmLst],
+        ['고용형태', record.hireTypeNmLst],
+        ['채용구분', record.recrutSeNm],
+        ['근무지역', record.workRgnNmLst],
+        ['모집인원', record.recrutNope ? `${record.recrutNope}명` : ''],
+        [
+            '공고기간',
+            [record.pbancBgngYmd, record.pbancEndYmd]
+                .map((value) => toIsoDate$2(value ?? ''))
+                .filter(Boolean)
+                .join(' - '),
+        ],
+        ['원문', record.srcUrl],
+    ]
+        .filter(([, value]) => value)
+        .map(([label, value]) => `- **${label}**: ${String(value).trim()}`);
+    const sections = [
+        ['지원자격', record.aplyQlfcCn],
+        ['우대사항', record.prefCn],
+        ['전형방법', record.scrnprcdrMthdExpln],
+    ]
+        .filter(([, value]) => value?.trim())
+        .flatMap(([label, value]) => [
+        '',
+        `### ${label}`,
+        '',
+        String(value).trim(),
+    ]);
+    return [`## ${record.recrutPbancTtl ?? ''}`, '', ...lines, ...sections]
+        .join('\n')
+        .trim();
+}
+/** Parses the aggregated list response, keeping only heritage-related postings. */
+const parseAlioList = (body) => {
+    const parsed = parseJson$2(body);
+    const posts = [];
+    for (const record of parsed?.result ?? []) {
+        const title = record.recrutPbancTtl?.trim();
+        if (!title || record.recrutPblntSn == null) {
+            continue;
+        }
+        const heritage = isHeritageJobCandidate({
+            institution: record.instNm ?? '',
+            title,
+            categoryCodes: (record.ncsCdLst ?? '').split(',').filter(Boolean),
+        });
+        if (!heritage) {
+            continue;
+        }
+        posts.push({
+            uniqId: String(record.recrutPblntSn),
+            title,
+            date: toIsoDate$2(record.pbancBgngYmd ?? ''),
+            detailUrl: buildAlioDetailUrl(record.recrutPblntSn),
+            dateType: DateType.REGISTERED,
+        });
+    }
+    return posts;
+};
+/** Parses a `/detail` response into the article body. */
+const parseAlioDetail = (body) => {
+    const parsed = parseJson$2(body);
+    const record = parsed?.result;
+    return {
+        detailContent: record ? renderAlioContent(record) : '',
+        hasAttachedFile: true,
+        hasAttachedImage: false,
+    };
+};
+
 /**
  * Formats a date string by replacing dots with dashes.
  * If the string contains a newline (indicating a date range),
@@ -115,7 +550,136 @@ function getUniqIdFromBuyeoMuseum(element) {
     return (element.attr('onclick') ?? '').match(/goView\('(.*)'\)/)?.[1] ?? '';
 }
 
+const parseCheongjuMuseumList = (html) => {
+    const $ = cheerio.load(html);
+    const posts = [];
+    const baseUrl = 'https://cheongju.museum.go.kr';
+    $('table.bbs_default_list tbody tr').each((index, element) => {
+        const columns = $(element).find('td');
+        if (columns.length === 0) {
+            return;
+        }
+        const titleElement = columns.eq(1).find('a');
+        const relativeHref = titleElement.attr('href');
+        if (!relativeHref) {
+            return;
+        }
+        const fullUrl = new URL(relativeHref.replace('./', '/www/'), baseUrl);
+        const detailUrl = fullUrl.href;
+        const uniqId = fullUrl.searchParams.get('nttNo') ?? undefined;
+        const title = titleElement.text()?.trim() ?? '';
+        const date = getDate(columns.eq(4).text().trim());
+        posts.push({
+            uniqId,
+            title,
+            date,
+            detailUrl: cleanUrl(detailUrl),
+            dateType: DateType.REGISTERED,
+        });
+    });
+    return posts;
+};
+const parseCheongjuMuseumDetail = (html) => {
+    const $ = cheerio.load(html);
+    const content = $('td.content');
+    return {
+        detailContent: new TurndownService().turndown(content.html() ?? ''),
+        hasAttachedFile: $('tr.FILE td p').length > 0,
+        hasAttachedImage: content.find('img').length > 0,
+    };
+};
+
+const EXCAVATION_BASE_URL = 'https://www.e-minwon.go.kr';
+/** List page of the 국가유산청 발굴조사 보고서 board. */
+const EXCAVATION_REPORT_LIST_URL = `${EXCAVATION_BASE_URL}/ge/ee/getListEcexmRptp.do`;
+/** Public detail URL for one report, keyed by its board id (`ecexmRcno`). */
+const buildExcavationReportDetailUrl = (externalId) => `${EXCAVATION_BASE_URL}/ge/ee/getEcexmRptp.do?ecexmRcno=${externalId}`;
+/**
+ * Marks a response body as injected report data rather than scraped HTML, so
+ * the parsers below can tell the two apart without guessing.
+ */
+const INJECTED_MARKER = '@heripo/research-radar:excavation-reports';
+function parseInjectedPayload(body) {
+    if (!body.includes(INJECTED_MARKER)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(body);
+        return parsed.marker === INJECTED_MARKER ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function jsonResponse$1(payload) {
+    return new Response(JSON.stringify(payload), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+    });
+}
+/**
+ * Serves the 발굴조사 보고서 board from an injected source instead of the live
+ * site, leaving every other request untouched.
+ *
+ * Core's crawling chain always fetches a target's list URL and then each detail
+ * URL, so the substitution happens at the fetch layer — the same seam
+ * `createKrasFetch` uses. `source` is called once and its result reused for the
+ * detail requests that follow.
+ *
+ * @param baseFetch - Fetch to delegate every other request to
+ * @param source - Supplies the reports for this run
+ */
+const createExcavationReportFetch = (baseFetch = fetch, source) => {
+    let pending = null;
+    const loadReports = () => (pending ??= source());
+    return async (input, init) => {
+        const requestUrl = typeof input === 'string'
+            ? input
+            : input instanceof URL
+                ? input.href
+                : input.url;
+        const url = new URL(requestUrl, EXCAVATION_BASE_URL);
+        if (url.origin !== new URL(EXCAVATION_BASE_URL).origin) {
+            return baseFetch(input, init);
+        }
+        if (url.pathname === new URL(EXCAVATION_REPORT_LIST_URL).pathname) {
+            const reports = await loadReports();
+            return jsonResponse$1({
+                marker: INJECTED_MARKER,
+                reports,
+            });
+        }
+        if (url.pathname === '/ge/ee/getEcexmRptp.do') {
+            const externalId = url.searchParams.get('ecexmRcno');
+            const report = (await loadReports()).find((candidate) => candidate.externalId === externalId);
+            if (report) {
+                return jsonResponse$1({
+                    marker: INJECTED_MARKER,
+                    report,
+                });
+            }
+        }
+        return baseFetch(input, init);
+    };
+};
+/** Renders a report's fields as the article body. */
+function renderExcavationReportContent(report) {
+    const lines = Object.entries(report.fields)
+        .filter(([, value]) => value != null && String(value).trim() !== '')
+        .map(([label, value]) => `- **${label}**: ${String(value).trim()}`);
+    return ['## 발굴조사 보고서 정보', '', ...lines].join('\n');
+}
 const parseExcavationReportList = (html) => {
+    const injected = parseInjectedPayload(html);
+    if (injected) {
+        return injected.reports.map((report) => ({
+            uniqId: report.externalId,
+            title: report.title,
+            date: report.submittedDate,
+            detailUrl: buildExcavationReportDetailUrl(report.externalId),
+            dateType: DateType.REGISTERED,
+        }));
+    }
     const $ = cheerio.load(html);
     const posts = [];
     const baseUrl = 'https://www.e-minwon.go.kr';
@@ -172,6 +736,14 @@ const parseExcavationSiteList = (html) => {
     return posts;
 };
 const parseExcavationReportDetail = (html) => {
+    const injected = parseInjectedPayload(html);
+    if (injected) {
+        return {
+            detailContent: renderExcavationReportContent(injected.report),
+            hasAttachedFile: injected.report.hasAttachedFile ?? true,
+            hasAttachedImage: false,
+        };
+    }
     const $ = cheerio.load(html);
     const content = $('table.td_left').parent();
     const trList = content.find('table tbody tr');
@@ -205,6 +777,320 @@ function getUniqIdFromExcavationItem(element) {
     return ((element.attr('onclick') ?? '').match(/dataSelected\('(.*)'\)/)?.[1] ?? '');
 }
 
+const API_BASE$1 = 'https://apis.data.go.kr/1230000/ad/BidPublicInfoService';
+const SITE_BASE$1 = 'https://www.g2b.go.kr';
+/**
+ * Public 나라장터 board URL used as this target's list page.
+ *
+ * Core fetches a target's `url` directly, so this stands in for the API calls:
+ * `createG2bFetch` recognises it and queries the 조달청 open API instead, which
+ * keeps the service key and the time window out of the configuration.
+ */
+const G2B_LIST_URL = `${SITE_BASE$1}/co/co/ococ/CoOcOc.do`;
+/** Public notice URL, which is also what readers of the newsletter follow. */
+const buildG2bDetailUrl = (notice, order) => `${SITE_BASE$1}/link/PNPE027_01/single/?bidPbancNo=${notice}&bidPbancOrd=${order}`;
+/**
+ * Business categories collected.
+ *
+ * 나라장터 splits its operations by 업무구분 and a notice only answers on the
+ * matching one. Heritage work appears as 용역 (발굴조사, 학술연구, 보존처리) and
+ * 공사 (수리, 정비); 물품 and 외자 carry none, so they are not requested.
+ */
+const OPERATIONS = ['Servc', 'Cnstwk'];
+/** `resultCode` the service returns on success. */
+const SUCCESS_RESULT_CODE = '00';
+/** Offset the service's wall clock runs on. */
+const KST_OFFSET_MS = 9 * 60 * 60 * 1000;
+/**
+ * `YYYYMMDDHHMM` in KST, the format `inqryBgnDt` and `inqryEndDt` expect.
+ *
+ * The parameters carry no timezone and the service reads them as Korean local
+ * time, the same clock `bidNtceDt` is published on. Serialising UTC instead
+ * shifts the whole window back nine hours: on a live seven-day query that was
+ * 2,595 notices against 2,975, with the most recent 380 falling outside it.
+ */
+function toApiDateTime(date) {
+    return new Date(date.getTime() + KST_OFFSET_MS)
+        .toISOString()
+        .replace(/[-:T]/g, '')
+        .slice(0, 12);
+}
+/** `2026-09-15 13:42:20` to ISO `2026-09-15`. */
+function toIsoDate$1(value) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})/.exec(value ?? '');
+    return match ? `${match[1]}-${match[2]}-${match[3]}` : '';
+}
+function jsonResponse(payload) {
+    return new Response(JSON.stringify(payload), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+    });
+}
+/**
+ * Serves the 나라장터 target from the 조달청 open API.
+ *
+ * The list page is answered by querying both business categories and merging
+ * them. Detail requests are answered from that same response — the list carries
+ * every field the article body needs, so no second round trip is made and the
+ * daily quota of 1,000 calls is barely touched.
+ */
+const createG2bFetch = (baseFetch = fetch, options) => {
+    const { apiKey, windowHours = 48, rowsPerPage = 999, maxPages = 4, triage, } = options;
+    /** Notices from the most recent list call, keyed by `<bidNtceNo>:<bidNtceOrd>`. */
+    const noticeCache = new Map();
+    return async (input, init) => {
+        const requestUrl = typeof input === 'string'
+            ? input
+            : input instanceof URL
+                ? input.href
+                : input.url;
+        let url;
+        try {
+            url = new URL(requestUrl);
+        }
+        catch {
+            return baseFetch(input, init);
+        }
+        if (url.origin !== SITE_BASE$1) {
+            return baseFetch(input, init);
+        }
+        if (url.pathname === new URL(G2B_LIST_URL).pathname) {
+            if (!apiKey) {
+                // Without a key the board is simply not collected: answer with an empty
+                // payload so the parsers yield nothing and no request is made.
+                return jsonResponse({ items: [] });
+            }
+            const end = new Date();
+            const begin = new Date(end.getTime() - windowHours * 60 * 60 * 1000);
+            // The two 업무구분 are independent queries, so they run together: walked
+            // one after the other they take about 12 seconds, which already exceeds
+            // the 10 seconds core allows a crawl fetch on its first attempt, before
+            // triage adds anything. Pages within one operation stay sequential
+            // because each page's size decides whether another is needed.
+            //
+            // A partial result is worse than none here: if 공사 fails while 용역
+            // succeeds, the run looks healthy — the target still yields articles and
+            // the health-check still passes — while every construction tender is
+            // missing. Fail the whole list instead, which core logs as
+            // `crawl.list.fetch.failed` and the health-check reports as a failure.
+            const pages = await Promise.all(OPERATIONS.map(async (operation) => {
+                const notices = [];
+                for (let page = 1; page <= maxPages; page++) {
+                    const response = await baseFetch(`${API_BASE$1}/getBidPblancListInfo${operation}?serviceKey=${apiKey}` +
+                        `&numOfRows=${rowsPerPage}&pageNo=${page}&type=json&inqryDiv=1` +
+                        `&inqryBgnDt=${toApiDateTime(begin)}&inqryEndDt=${toApiDateTime(end)}`, init);
+                    if (!response.ok) {
+                        return `나라장터 ${operation} list failed with HTTP ${response.status}`;
+                    }
+                    const body = (await response.json());
+                    const resultCode = body.response?.header?.resultCode;
+                    // data.go.kr answers its own errors with HTTP 200 and a result code.
+                    if (resultCode !== SUCCESS_RESULT_CODE) {
+                        return `나라장터 ${operation} list returned resultCode ${resultCode ?? 'none'}`;
+                    }
+                    const batch = body.response?.body?.items ?? [];
+                    for (const notice of batch) {
+                        notices.push({
+                            ...notice,
+                            businessDivision: operation === 'Servc' ? '용역' : '공사',
+                        });
+                    }
+                    if (batch.length < rowsPerPage) {
+                        break;
+                    }
+                    // Same reasoning as the partial-failure check above: a list that is
+                    // silently short looks healthy. If the window no longer fits inside
+                    // `maxPages`, the notices past the cap are never judged and never
+                    // missed by anything downstream, so fail instead of truncating.
+                    if (page === maxPages) {
+                        const totalCount = body.response?.body?.totalCount ?? 0;
+                        if (totalCount > maxPages * rowsPerPage) {
+                            return (`나라장터 ${operation} window holds ${totalCount} notices, ` +
+                                `beyond the ${maxPages * rowsPerPage} that ${maxPages} pages ` +
+                                `can retrieve — raise maxPages or narrow windowHours`);
+                        }
+                    }
+                }
+                return notices;
+            }));
+            const failure = pages.find((result) => typeof result === 'string');
+            if (typeof failure === 'string') {
+                return new Response(failure, {
+                    status: 502,
+                    statusText: 'Bad Gateway',
+                });
+            }
+            const collected = pages.flat();
+            // Deduplicate before judging: the same notice arrives on more than one
+            // page, and triage is billed per row.
+            const unique = [];
+            const seenKeys = new Set();
+            for (const notice of collected) {
+                const key = `${notice.bidNtceNo}:${notice.bidNtceOrd}`;
+                if (!notice.bidNtceNm || !notice.bidNtceNo || seenKeys.has(key)) {
+                    continue;
+                }
+                seenKeys.add(key);
+                unique.push(notice);
+            }
+            const candidates = unique.map((notice) => ({
+                institution: `${notice.ntceInsttNm ?? ''} ${notice.dminsttNm ?? ''}`,
+                title: notice.bidNtceNm ?? '',
+                classification: notice.pubPrcrmntMidClsfcNm,
+            }));
+            // `init.signal` is core's crawl timeout. It reaches the data.go.kr calls
+            // above through `init`; triage has to be given it explicitly, or an
+            // aborted crawl would leave 22 LLM requests running and bill them again
+            // on the next attempt.
+            const verdicts = triage
+                ? await triage(candidates, init?.signal ?? undefined)
+                : candidates.map((candidate) => isHeritageBidCandidate(candidate));
+            const heritage = unique.filter((_, index) => verdicts[index]);
+            // The cache backs the detail path, so it holds exactly what the list
+            // serves — dropping a notice from one and not the other either breaks its
+            // detail request or retains 1,500 entries to serve a few dozen.
+            noticeCache.clear();
+            for (const notice of heritage) {
+                noticeCache.set(`${notice.bidNtceNo}:${notice.bidNtceOrd}`, notice);
+            }
+            return jsonResponse({ items: heritage });
+        }
+        if (url.pathname === '/link/PNPE027_01/single/') {
+            const key = `${url.searchParams.get('bidPbancNo')}:${url.searchParams.get('bidPbancOrd')}`;
+            const notice = noticeCache.get(key);
+            if (notice) {
+                return jsonResponse({ item: notice });
+            }
+        }
+        return baseFetch(input, init);
+    };
+};
+function parseJson$1(body) {
+    try {
+        return JSON.parse(body);
+    }
+    catch {
+        return null;
+    }
+}
+/** Renders a notice's fields as the article body. */
+function renderG2bContent(notice) {
+    const won = (value) => {
+        const amount = Number(value);
+        return Number.isFinite(amount) && amount > 0
+            ? `${amount.toLocaleString('ko-KR')}원`
+            : '';
+    };
+    const lines = [
+        ['업무구분', notice.businessDivision],
+        ['공고종류', notice.ntceKindNm],
+        ['용역구분', notice.srvceDivNm],
+        ['공고기관', notice.ntceInsttNm],
+        ['수요기관', notice.dminsttNm],
+        [
+            '분류',
+            [notice.pubPrcrmntLrgClsfcNm, notice.pubPrcrmntMidClsfcNm]
+                .filter(Boolean)
+                .join(' > '),
+        ],
+        ['추정가격', won(notice.presmptPrce)],
+        ['배정예산', won(notice.asignBdgtAmt)],
+        ['계약방법', notice.cntrctCnclsMthdNm],
+        ['낙찰방법', notice.sucsfbidMthdNm],
+        ['공고일시', notice.bidNtceDt],
+        ['입찰마감', notice.bidClseDt],
+        ['개찰일시', notice.opengDt],
+        [
+            '공고번호',
+            [notice.bidNtceNo, notice.bidNtceOrd].filter(Boolean).join('-'),
+        ],
+        [
+            '담당자',
+            [notice.ntceInsttOfclNm, notice.ntceInsttOfclTelNo]
+                .filter(Boolean)
+                .join(' '),
+        ],
+    ]
+        .filter(([, value]) => value)
+        .map(([label, value]) => `- **${label}**: ${String(value).trim()}`);
+    return [`## ${notice.bidNtceNm ?? ''}`, '', ...lines].join('\n').trim();
+}
+/** Parses the merged list response, keeping only heritage-related notices. */
+const parseG2bList = (body) => {
+    const parsed = parseJson$1(body);
+    const posts = [];
+    const seen = new Set();
+    for (const notice of parsed?.items ?? []) {
+        const title = notice.bidNtceNm?.trim();
+        const number = notice.bidNtceNo;
+        const order = notice.bidNtceOrd ?? '000';
+        if (!title || !number) {
+            continue;
+        }
+        const key = `${number}:${order}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        posts.push({
+            uniqId: key,
+            title,
+            date: toIsoDate$1(notice.bidNtceDt),
+            detailUrl: notice.bidNtceDtlUrl || buildG2bDetailUrl(number, order),
+            dateType: DateType.REGISTERED,
+        });
+    }
+    return posts;
+};
+/** Parses a cached notice into the article body. */
+const parseG2bDetail = (body) => {
+    const parsed = parseJson$1(body);
+    return {
+        detailContent: parsed?.item ? renderG2bContent(parsed.item) : '',
+        hasAttachedFile: true,
+        hasAttachedImage: false,
+    };
+};
+
+const parseGimhaeMuseumList = (html, hrefPrefix) => {
+    const $ = cheerio.load(html);
+    const posts = [];
+    const baseUrl = 'https://gimhae.museum.go.kr';
+    $('table.board_list tbody tr').each((index, element) => {
+        const columns = $(element).find('td');
+        if (columns.length === 0) {
+            return;
+        }
+        const titleElement = columns.eq(1).find('a');
+        const relativeHref = titleElement.attr('href');
+        if (!relativeHref) {
+            return;
+        }
+        const fullUrl = new URL(`${hrefPrefix}${relativeHref}`, baseUrl);
+        const detailUrl = fullUrl.href;
+        const uniqId = fullUrl.searchParams.get('no') ?? undefined;
+        const title = titleElement.text()?.trim() ?? '';
+        const date = getDate(columns.eq(5).text().trim());
+        posts.push({
+            uniqId,
+            title,
+            date,
+            detailUrl: cleanUrl(detailUrl),
+            dateType: DateType.REGISTERED,
+        });
+    });
+    return posts;
+};
+const parseGimhaeMuseumDetail = (html) => {
+    const $ = cheerio.load(html);
+    const content = $('div.bbs--view--content');
+    return {
+        detailContent: new TurndownService().turndown(content.html() ?? ''),
+        hasAttachedFile: $('div.bbs--view--file').length > 0,
+        hasAttachedImage: content.find('img').length > 0,
+    };
+};
+
 const parseGogungList = (html) => {
     const $ = cheerio.load(html);
     const posts = [];
@@ -244,6 +1130,205 @@ const parseGogungDetail = (html) => {
     };
 };
 
+const API_BASE = 'https://apis.data.go.kr/1760000/PblJobService';
+const SITE_BASE = 'https://www.gojobs.go.kr';
+/**
+ * Public 나라일터 board URL used as this target's list page.
+ *
+ * Core fetches a target's `url` directly, so this stands in for the API call:
+ * `createGojobsFetch` recognises it and queries `/getList` instead, which keeps
+ * the service key and the date window out of the checked-in configuration.
+ */
+const GOJOBS_LIST_URL = `${SITE_BASE}/apmList.do`;
+/** Public posting URL, which is also what readers of the newsletter follow. */
+const buildGojobsDetailUrl = (idx) => `${SITE_BASE}/apmView.do?empmnsn=${idx}`;
+/** `yyyy-mm-dd`, the format `Begin_de` and `End_de` expect. */
+function toApiDate(date) {
+    return date.toISOString().slice(0, 10);
+}
+/** `yyyymmdd` (as the API returns dates) to ISO `yyyy-mm-dd`. */
+function toIsoDate(compact) {
+    return /^\d{8}$/.test(compact)
+        ? `${compact.slice(0, 4)}-${compact.slice(4, 6)}-${compact.slice(6, 8)}`
+        : '';
+}
+/**
+ * Serves the 나라일터 target from the 인사혁신처 open API.
+ *
+ * The board carries every public-sector vacancy in the country, and its
+ * documented `Kwrd` search parameter is ignored by the service, so the whole
+ * date window is requested and narrowed in `parseGojobsList`. `Begin_de` and
+ * `End_de` do work and keep that window bounded.
+ *
+ * Detail requests to the public posting URL are answered from `/getItem`, which
+ * returns the announcement body directly — no HTML page is fetched.
+ */
+const createGojobsFetch = (baseFetch = fetch, options) => {
+    const { apiKey, windowDays = 7, rowsPerPage = 3000 } = options;
+    return async (input, init) => {
+        const requestUrl = typeof input === 'string'
+            ? input
+            : input instanceof URL
+                ? input.href
+                : input.url;
+        let url;
+        try {
+            url = new URL(requestUrl);
+        }
+        catch {
+            return baseFetch(input, init);
+        }
+        if (url.origin !== SITE_BASE) {
+            return baseFetch(input, init);
+        }
+        if (!apiKey) {
+            // Without a key the board is simply not collected: answer with an empty
+            // payload so the parsers yield nothing and no request is made.
+            return new Response('<response><body><items/></body></response>', {
+                status: 200,
+                headers: { 'content-type': 'application/xml' },
+            });
+        }
+        if (url.pathname === '/apmList.do') {
+            const end = new Date();
+            const begin = new Date(end.getTime() - windowDays * 24 * 60 * 60 * 1000);
+            return baseFetch(`${API_BASE}/getList?serviceKey=${apiKey}&numOfRows=${rowsPerPage}` +
+                `&pageNo=1&Begin_de=${toApiDate(begin)}&End_de=${toApiDate(end)}`, init);
+        }
+        if (url.pathname === '/apmView.do') {
+            const idx = url.searchParams.get('empmnsn');
+            if (idx) {
+                return baseFetch(`${API_BASE}/getItem?serviceKey=${apiKey}&idx=${idx}`, init);
+            }
+        }
+        return baseFetch(input, init);
+    };
+};
+function textOf($, item, tag) {
+    return $(item).find(tag).first().text().trim();
+}
+/**
+ * Parses `/getList` responses, keeping only heritage-related postings.
+ *
+ * Several concatenated pages may arrive in one body; Cheerio's XML mode reads
+ * them as a single document, which is what the fetch above relies on.
+ */
+const parseGojobsList = (xml) => {
+    const $ = cheerio.load(xml, { xml: true });
+    const posts = [];
+    const seen = new Set();
+    $('item').each((_, element) => {
+        const idx = textOf($, element, 'idx');
+        const title = textOf($, element, 'title');
+        const institution = textOf($, element, 'insttname');
+        if (!idx || !title || seen.has(idx)) {
+            return;
+        }
+        if (!isHeritageJobCandidate({ institution, title })) {
+            return;
+        }
+        seen.add(idx);
+        posts.push({
+            uniqId: idx,
+            title,
+            date: toIsoDate(textOf($, element, 'regdate')),
+            detailUrl: buildGojobsDetailUrl(idx),
+            dateType: DateType.REGISTERED,
+        });
+    });
+    return posts;
+};
+/** Parses a `/getItem` response into the article body. */
+const parseGojobsDetail = (xml) => {
+    const $ = cheerio.load(xml, { xml: true });
+    const item = $('item').first();
+    const field = (tag) => item.find(tag).first().text().trim();
+    const lines = [
+        ['기관', field('insttname')],
+        ['지역', field('areaname')],
+        ['공고일', toIsoDate(field('regdate'))],
+        ['마감일', toIsoDate(field('enddate'))],
+    ]
+        .filter(([, value]) => value)
+        .map(([label, value]) => `- **${label}**: ${value}`);
+    const contents = field('contents');
+    return {
+        detailContent: [`## ${field('title')}`, '', ...lines, '', contents]
+            .join('\n')
+            .trim(),
+        hasAttachedFile: true,
+        hasAttachedImage: false,
+    };
+};
+
+const parseGyeongjuMuseumList = (html, hrefPrefix) => {
+    const $ = cheerio.load(html);
+    const posts = [];
+    const baseUrl = 'https://gyeongju.museum.go.kr';
+    $('table tbody tr').each((index, element) => {
+        const columns = $(element).find('td');
+        if (columns.length === 0) {
+            return;
+        }
+        const titleElement = columns.eq(1).find('a');
+        const relativeHref = titleElement.attr('href');
+        if (!relativeHref) {
+            return;
+        }
+        const fullUrl = new URL(`${hrefPrefix}${relativeHref}`, baseUrl);
+        const detailUrl = fullUrl.href;
+        const uniqId = fullUrl.searchParams.get('no') ?? undefined;
+        const title = titleElement.text()?.trim() ?? '';
+        const date = getDate(columns.eq(4).text().trim());
+        posts.push({
+            uniqId,
+            title,
+            date,
+            detailUrl: cleanUrl(detailUrl),
+            dateType: DateType.REGISTERED,
+        });
+    });
+    return posts;
+};
+const parseGyeongjuMuseumNoticeList = (html) => {
+    const $ = cheerio.load(html);
+    const posts = [];
+    const baseUrl = 'https://gyeongju.museum.go.kr';
+    $('table tbody tr').each((index, element) => {
+        const columns = $(element).find('td');
+        if (columns.length === 0) {
+            return;
+        }
+        const titleElement = columns.eq(3).find('a');
+        const relativeHref = titleElement.attr('href');
+        if (!relativeHref) {
+            return;
+        }
+        const fullUrl = new URL(`/kor/html/sub07/0703.html${relativeHref}`, baseUrl);
+        const detailUrl = fullUrl.href;
+        const uniqId = fullUrl.searchParams.get('no') ?? undefined;
+        const title = titleElement.text()?.trim() ?? '';
+        const date = getDate(columns.eq(5).text().trim());
+        posts.push({
+            uniqId,
+            title,
+            date,
+            detailUrl: cleanUrl(detailUrl),
+            dateType: DateType.REGISTERED,
+        });
+    });
+    return posts;
+};
+const parseGyeongjuMuseumDetail = (html) => {
+    const $ = cheerio.load(html);
+    const content = $('div.bd_detail_cont');
+    return {
+        detailContent: new TurndownService().turndown(content.html() ?? ''),
+        hasAttachedFile: $('div.bd_detail_file ul.file').length > 0,
+        hasAttachedImage: content.find('img').length > 0,
+    };
+};
+
 const parseHeritageAgencyList = (html) => {
     const $ = cheerio.load(html);
     const posts = [];
@@ -324,6 +1409,45 @@ const parseHsasDetail = (html) => {
     };
 };
 
+const parseIksanMuseumList = (html) => {
+    const $ = cheerio.load(html);
+    const posts = [];
+    const baseUrl = 'https://iksan.museum.go.kr';
+    $('div.bd_list_wrap table tbody tr').each((index, element) => {
+        const columns = $(element).find('td');
+        if (columns.length === 0) {
+            return;
+        }
+        const titleElement = columns.eq(1).find('a');
+        const relativeHref = titleElement.attr('href');
+        if (!relativeHref) {
+            return;
+        }
+        const fullUrl = new URL(`/kor/html/sub05/0501.html${relativeHref}`, baseUrl);
+        const detailUrl = fullUrl.href;
+        const uniqId = fullUrl.searchParams.get('no') ?? undefined;
+        const title = titleElement.text()?.trim() ?? '';
+        const date = getDate(columns.eq(5).text().trim());
+        posts.push({
+            uniqId,
+            title,
+            date,
+            detailUrl: cleanUrl(detailUrl),
+            dateType: DateType.REGISTERED,
+        });
+    });
+    return posts;
+};
+const parseIksanMuseumDetail = (html) => {
+    const $ = cheerio.load(html);
+    const content = $('div.bd_detail_cont');
+    return {
+        detailContent: new TurndownService().turndown(content.html() ?? ''),
+        hasAttachedFile: $('ul.file li').length > 0,
+        hasAttachedImage: content.find('img').length > 0,
+    };
+};
+
 const parseJbgogoList = (html) => {
     const $ = cheerio.load(html);
     const posts = [];
@@ -364,6 +1488,45 @@ const parseJbgogoDetail = (html) => {
     };
 };
 
+const parseJejuMuseumList = (html) => {
+    const $ = cheerio.load(html);
+    const posts = [];
+    const baseUrl = 'https://jeju.museum.go.kr';
+    $('div.board_list table tbody tr').each((index, element) => {
+        const columns = $(element).find('td');
+        if (columns.length === 0) {
+            return;
+        }
+        const titleElement = columns.eq(1).find('a');
+        const relativeHref = titleElement.attr('href');
+        if (!relativeHref) {
+            return;
+        }
+        const fullUrl = new URL(relativeHref.replace('./', '/_prog/_board/'), baseUrl);
+        const detailUrl = fullUrl.href;
+        const uniqId = fullUrl.searchParams.get('no') ?? undefined;
+        const title = titleElement.text()?.trim() ?? '';
+        const date = getDate(columns.eq(3).text().trim());
+        posts.push({
+            uniqId,
+            title,
+            date,
+            detailUrl: cleanUrl(detailUrl),
+            dateType: DateType.REGISTERED,
+        });
+    });
+    return posts;
+};
+const parseJejuMuseumDetail = (html) => {
+    const $ = cheerio.load(html);
+    const content = $('div.board_viewDetail');
+    return {
+        detailContent: new TurndownService().turndown(content.html() ?? ''),
+        hasAttachedFile: $('li.file div a').length > 0,
+        hasAttachedImage: content.find('img').length > 0,
+    };
+};
+
 const parseJeonjuMuseumList = (html) => {
     const $ = cheerio.load(html);
     const posts = [];
@@ -1627,74 +2790,69 @@ function createCrawlingTargetGroups(customFetch) {
                     parseList: parseJinjuMuseumList,
                     parseDetail: parseJinjuMuseumDetail,
                 },
-                // NOTE: Parsing logic is implemented, but crawling is restricted by robots.txt policy
-                // {
-                //   id: '국립경주박물관_새소식',
-                //   name: '국립경주박물관 새소식',
-                //   url: 'https://gyeongju.museum.go.kr/kor/html/sub07/0701.html',
-                //   parseList: (html) =>
-                //     parseGyeongjuMuseumList(html, '/kor/html/sub07/0701.html'),
-                //   parseDetail: parseGyeongjuMuseumDetail,
-                // },
-                // {
-                //   id: '국립경주박물관_고시공고',
-                //   name: '국립경주박물관 고시/공고',
-                //   url: 'https://gyeongju.museum.go.kr/kor/html/sub07/0703.html',
-                //   parseList: parseGyeongjuMuseumNoticeList,
-                //   parseDetail: parseGyeongjuMuseumDetail,
-                // },
-                // {
-                //   id: '국립경주박물관_보도자료',
-                //   name: '국립경주박물관 보도자료',
-                //   url: 'https://gyeongju.museum.go.kr/kor/html/sub07/0705.html',
-                //   parseList: (html) =>
-                //     parseGyeongjuMuseumList(html, '/kor/html/sub07/0705.html'),
-                //   parseDetail: parseGyeongjuMuseumDetail,
-                // },
-                // {
-                //   id: '국립청주박물관_새소식',
-                //   name: '국립청주박물관 새소식',
-                //   url: 'https://cheongju.museum.go.kr/www/selectBbsNttList.do?bbsNo=1&key=482&nbar=s',
-                //   parseList: parseCheongjuMuseumList,
-                //   parseDetail: parseCheongjuMuseumDetail,
-                // },
-                // {
-                //   id: '국립청주박물관_언론보도자료',
-                //   name: '국립청주박물관 언론보도자료',
-                //   url: 'https://cheongju.museum.go.kr/www/selectBbsNttList.do?bbsNo=20&key=31&nbar=s',
-                //   parseList: parseCheongjuMuseumList,
-                //   parseDetail: parseCheongjuMuseumDetail,
-                // },
-                // {
-                //   id: '국립김해박물관_새소식',
-                //   name: '국립김해박물관 새소식',
-                //   url: 'https://gimhae.museum.go.kr/kr/html/sub04/0401.html',
-                //   parseList: (html) =>
-                //     parseGimhaeMuseumList(html, '/kr/html/sub04/0401.html'),
-                //   parseDetail: parseGimhaeMuseumDetail,
-                // },
-                // {
-                //   id: '국립김해박물관_보도자료',
-                //   name: '국립김해박물관 언론보도자료',
-                //   url: 'https://gimhae.museum.go.kr/kr/html/sub04/0402.html',
-                //   parseList: (html) =>
-                //     parseGimhaeMuseumList(html, '/kr/html/sub04/0402.html'),
-                //   parseDetail: parseGimhaeMuseumDetail,
-                // },
-                // {
-                //   id: '국립제주박물관_새소식',
-                //   name: '국립제주박물관 새소식',
-                //   url: 'https://jeju.museum.go.kr/_prog/_board/?code=sub02_0201&site_dvs_cd=kr&menu_dvs_cd=050101&ntt_tag=1',
-                //   parseList: parseJejuMuseumList,
-                //   parseDetail: parseJejuMuseumDetail,
-                // },
-                // {
-                //   id: '국립익산박물관_공지사항',
-                //   name: '국립익산박물관 공지사항',
-                //   url: 'https://iksan.museum.go.kr/kor/html/sub05/0501.html',
-                //   parseList: parseIksanMuseumList,
-                //   parseDetail: parseIksanMuseumDetail,
-                // },
+                {
+                    id: '국립경주박물관_새소식',
+                    name: '국립경주박물관 새소식',
+                    url: 'https://gyeongju.museum.go.kr/kor/html/sub07/0701.html',
+                    parseList: (html) => parseGyeongjuMuseumList(html, '/kor/html/sub07/0701.html'),
+                    parseDetail: parseGyeongjuMuseumDetail,
+                },
+                {
+                    id: '국립경주박물관_고시공고',
+                    name: '국립경주박물관 고시/공고',
+                    url: 'https://gyeongju.museum.go.kr/kor/html/sub07/0703.html',
+                    parseList: parseGyeongjuMuseumNoticeList,
+                    parseDetail: parseGyeongjuMuseumDetail,
+                },
+                {
+                    id: '국립경주박물관_보도자료',
+                    name: '국립경주박물관 보도자료',
+                    url: 'https://gyeongju.museum.go.kr/kor/html/sub07/0705.html',
+                    parseList: (html) => parseGyeongjuMuseumList(html, '/kor/html/sub07/0705.html'),
+                    parseDetail: parseGyeongjuMuseumDetail,
+                },
+                {
+                    id: '국립청주박물관_새소식',
+                    name: '국립청주박물관 새소식',
+                    url: 'https://cheongju.museum.go.kr/www/selectBbsNttList.do?bbsNo=1&key=482&nbar=s',
+                    parseList: parseCheongjuMuseumList,
+                    parseDetail: parseCheongjuMuseumDetail,
+                },
+                {
+                    id: '국립청주박물관_언론보도자료',
+                    name: '국립청주박물관 언론보도자료',
+                    url: 'https://cheongju.museum.go.kr/www/selectBbsNttList.do?bbsNo=20&key=31&nbar=s',
+                    parseList: parseCheongjuMuseumList,
+                    parseDetail: parseCheongjuMuseumDetail,
+                },
+                {
+                    id: '국립김해박물관_새소식',
+                    name: '국립김해박물관 새소식',
+                    url: 'https://gimhae.museum.go.kr/kr/html/sub04/0401.html',
+                    parseList: (html) => parseGimhaeMuseumList(html, '/kr/html/sub04/0401.html'),
+                    parseDetail: parseGimhaeMuseumDetail,
+                },
+                {
+                    id: '국립김해박물관_보도자료',
+                    name: '국립김해박물관 언론보도자료',
+                    url: 'https://gimhae.museum.go.kr/kr/html/sub04/0402.html',
+                    parseList: (html) => parseGimhaeMuseumList(html, '/kr/html/sub04/0402.html'),
+                    parseDetail: parseGimhaeMuseumDetail,
+                },
+                {
+                    id: '국립제주박물관_새소식',
+                    name: '국립제주박물관 새소식',
+                    url: 'https://jeju.museum.go.kr/_prog/_board/?code=sub02_0201&site_dvs_cd=kr&menu_dvs_cd=050101&ntt_tag=1',
+                    parseList: parseJejuMuseumList,
+                    parseDetail: parseJejuMuseumDetail,
+                },
+                {
+                    id: '국립익산박물관_공지사항',
+                    name: '국립익산박물관 공지사항',
+                    url: 'https://iksan.museum.go.kr/kor/html/sub05/0501.html',
+                    parseList: parseIksanMuseumList,
+                    parseDetail: parseIksanMuseumDetail,
+                },
             ],
         },
         {
@@ -1729,6 +2887,20 @@ function createCrawlingTargetGroups(customFetch) {
                     parseList: parseKaahList,
                     parseDetail: parseKaahDetail,
                 },
+                // Served from the 조달청 open API rather than scraped. 나라장터 carries
+                // every public procurement notice in the country — about 2,100 in a
+                // 48-hour window — so `createG2bFetch` narrows the list before it is
+                // served: LLM triage when the generator supplies it, and the
+                // deterministic filter in `src/crawling/heritage-job-filter.ts`
+                // otherwise. 용역 and 공사 are merged into this one target. Without an
+                // API key it yields nothing and makes no request.
+                {
+                    id: '나라장터_입찰공고',
+                    name: '나라장터 입찰공고',
+                    url: G2B_LIST_URL,
+                    parseList: parseG2bList,
+                    parseDetail: parseG2bDetail,
+                },
             ],
         },
         {
@@ -1784,29 +2956,46 @@ function createCrawlingTargetGroups(customFetch) {
                     parseList: (html) => parseBuyeoMuseumList(html, '2301270001'),
                     parseDetail: parseBuyeoMuseumDetail,
                 },
-                // NOTE: Parsing logic is implemented, but crawling is restricted by robots.txt policy
-                // {
-                //   id: '국립경주박물관_채용안내',
-                //   name: '국립경주박물관 채용안내',
-                //   url: 'https://gyeongju.museum.go.kr/kor/html/sub07/0704.html',
-                //   parseList: (html) =>
-                //     parseGyeongjuMuseumList(html, '/kor/html/sub07/0704.html'),
-                //   parseDetail: parseGyeongjuMuseumDetail,
-                // },
-                // {
-                //   id: '국립청주박물관_채용및공고',
-                //   name: '국립청주박물관 채용 및 공고',
-                //   url: 'https://cheongju.museum.go.kr/www/selectBbsNttList.do?bbsNo=29&key=476&nbar=s',
-                //   parseList: parseCheongjuMuseumList,
-                //   parseDetail: parseCheongjuMuseumDetail,
-                // },
-                // {
-                //   id: '국립제주박물관_채용정보',
-                //   name: '국립제주박물관 채용정보',
-                //   url: 'https://jeju.museum.go.kr/_prog/_board/?code=sub02_0201&site_dvs_cd=kr&menu_dvs_cd=050102&ntt_tag=2',
-                //   parseList: parseJejuMuseumList,
-                //   parseDetail: parseJejuMuseumDetail,
-                // },
+                {
+                    id: '국립경주박물관_채용안내',
+                    name: '국립경주박물관 채용안내',
+                    url: 'https://gyeongju.museum.go.kr/kor/html/sub07/0704.html',
+                    parseList: (html) => parseGyeongjuMuseumList(html, '/kor/html/sub07/0704.html'),
+                    parseDetail: parseGyeongjuMuseumDetail,
+                },
+                {
+                    id: '국립청주박물관_채용및공고',
+                    name: '국립청주박물관 채용 및 공고',
+                    url: 'https://cheongju.museum.go.kr/www/selectBbsNttList.do?bbsNo=29&key=476&nbar=s',
+                    parseList: parseCheongjuMuseumList,
+                    parseDetail: parseCheongjuMuseumDetail,
+                },
+                {
+                    id: '국립제주박물관_채용정보',
+                    name: '국립제주박물관 채용정보',
+                    url: 'https://jeju.museum.go.kr/_prog/_board/?code=sub02_0201&site_dvs_cd=kr&menu_dvs_cd=050102&ntt_tag=2',
+                    parseList: parseJejuMuseumList,
+                    parseDetail: parseJejuMuseumDetail,
+                },
+                // Served from data.go.kr open APIs rather than scraped. Both boards
+                // carry every public-sector vacancy in the country, so their parsers
+                // apply the heritage filter in `src/crawling/heritage-job-filter.ts`
+                // before anything reaches analysis. Without an API key they yield
+                // nothing and make no request.
+                {
+                    id: '나라일터_채용공고',
+                    name: '나라일터 채용공고',
+                    url: GOJOBS_LIST_URL,
+                    parseList: parseGojobsList,
+                    parseDetail: parseGojobsDetail,
+                },
+                {
+                    id: '알리오_공공기관_채용공고',
+                    name: '알리오 공공기관 채용공고',
+                    url: ALIO_LIST_URL,
+                    parseList: parseAlioList,
+                    parseDetail: parseAlioDetail,
+                },
             ],
         },
     ];
@@ -1841,6 +3030,44 @@ const newsletterConfig = {
         priorityArticleScoreThreshold: 8,
     },
 };
+/**
+ * Maximum importance score per heritage domain (`tag1`).
+ *
+ * The newsletter is archaeology-first: archaeology and cultural heritage keep
+ * the full 1-10 range, while natural and intangible heritage are capped so they
+ * cannot crowd out archaeological coverage. `기타` — material that is not
+ * heritage at all — is capped lowest, because the scoring prompt's academic-value
+ * floor is domain-blind and would otherwise lift things like a general journal's
+ * call for papers into the top half of the scale.
+ *
+ * The cap is applied deterministically after scoring, in
+ * `AnalysisProvider.update()`, rather than asked for in the prompt, so the
+ * ceiling always holds. It never reaches 1: a score of 1 means "exclude from the
+ * newsletter" in the consuming application's candidate query, so capping to 1
+ * would delete these articles instead of demoting them.
+ *
+ * Domains absent from this map are not capped.
+ */
+const maximumImportanceScoreByDomain = {
+    자연유산: 6,
+    무형유산: 6,
+    기타: 5,
+};
+/**
+ * Origins exempted from the robots.txt check.
+ *
+ * Each entry deliberately overrides what the site publishes, so it needs a
+ * reason and should be revisited when that site's robots.txt changes.
+ *
+ * - `http://www.yngogo.or.kr` (영남고고학회): its board is rendered from
+ *   `/module/ntt/unity/selectNttListAjax.ink`, and robots.txt carries a blanket
+ *   `Disallow: /module`. The rule reads as protecting an internal path rather
+ *   than the public board it happens to serve, and there is no other route to
+ *   the listing, so the society's boards are collected under this exemption.
+ */
+const robotsExemptOrigins = [
+    'http://www.yngogo.or.kr',
+];
 /**
  * LLM configuration
  */
@@ -1852,6 +3079,560 @@ const llmConfig = {
     },
 };
 
+/**
+ * Fixed vocabulary for `tag1`, the heritage domain of an article.
+ *
+ * Downstream scoring depends on this being a closed set: importance weighting
+ * ranks archaeology first and cultural heritage second, and natural/intangible
+ * heritage are capped. A free-form tag cannot drive either rule reliably, so
+ * `tag1` is constrained here while `tag2`/`tag3` stay open.
+ *
+ * `기타` exists so that non-heritage material — catering or security job
+ * postings, general administration — is labelled honestly instead of being
+ * forced into a heritage domain it does not belong to.
+ */
+const HERITAGE_DOMAIN_TAGS = [
+    '고고학',
+    '문화유산',
+    '자연유산',
+    '무형유산',
+    '기타',
+];
+/** Narrows an arbitrary tag value to the fixed vocabulary. */
+function toHeritageDomainTag(tag) {
+    const normalized = tag?.trim();
+    return HERITAGE_DOMAIN_TAGS.includes(normalized)
+        ? normalized
+        : null;
+}
+const DOMAIN_RULES = `## tag1 — 유산 영역 (고정 어휘, 아래 5개 중 정확히 하나)
+
+- **고고학**: 발굴조사, 매장유산, 유적·유물 조사, 발굴현장 공개, 발굴조사보고서, 고고학 학술대회·학회 소식
+- **문화유산**: 건조물·미술·기록 등 유형유산, 국보·보물 지정과 보존처리, 박물관 전시·소장품, 유산 정책·제도
+- **자연유산**: 천연기념물, 명승, 지질유산, 유산으로서의 동식물
+- **무형유산**: 전통 기예·의례·공연, 보유자·전승자, 전승 교육
+- **기타**: 위 넷 중 어디에도 해당하지 않는 내용. 유산과 무관한 채용(조리·방호·시설관리 등), 일반 행정·회계 공고가 여기 해당한다.
+
+여러 영역에 걸치면 **고고학 > 문화유산 > 자연유산 > 무형유산** 순으로 앞선 것을 고른다.
+예: 매장유산 발굴 성과를 다루는 국립박물관 전시 기사는 \`고고학\`.
+
+tag1은 반드시 이 5개 문자열 중 하나여야 한다. 변형·수식·조합은 허용하지 않는다.`;
+/**
+ * Replaces core's default tag prompt.
+ *
+ * Core's default asks for three free-form tags. This version pins `tag1` to the
+ * heritage domain vocabulary and keeps the default's reuse behaviour for the
+ * remaining two, so the existing tag pool stays consistent.
+ */
+const classifyTagsPrompt = {
+    system: ({ outputLanguage }) => `당신은 한국 문화유산 분야 기사를 분류하는 전문가다. 기사마다 태그 3개를 매긴다.
+
+${DOMAIN_RULES}
+
+## tag2, tag3 — 주제 태그 (자유 어휘)
+
+- 기사의 구체적인 주제를 나타낸다. 예: 발굴현장공개, 학술대회, 채용, 보존처리, 특별전
+- 제공된 기존 태그 목록과 80% 이상 들어맞으면 그 태그를 그대로 재사용한다. 분류 체계가 흩어지지 않게 하는 것이 새 태그를 만드는 것보다 중요하다.
+- 80%에 못 미칠 때만 새로 만든다. 새 태그는 비슷한 기사 여러 건에 두루 쓰일 수 있어야 한다.
+- 길이 3~15자, ${outputLanguage}로 작성한다.
+- tag1의 5개 어휘(고고학, 문화유산, 자연유산, 무형유산, 기타)는 너무 포괄적이므로 tag2, tag3에 쓰지 않는다.
+- tag2와 tag3은 서로 달라야 한다.`,
+    user: ({ targetArticle, existTags }) => `아래 기사를 분류하라.
+
+## 기사
+
+- 제목: ${targetArticle.title}
+- 본문:
+${targetArticle.detailContent}
+
+## 기존 태그 목록 (tag2, tag3 재사용 후보)
+
+\`\`\`json
+${JSON.stringify(existTags, null, 2)}
+\`\`\`
+
+## 출력
+
+- tag1: 유산 영역. 고고학, 문화유산, 자연유산, 무형유산, 기타 중 정확히 하나.
+- tag2: 주제 태그.
+- tag3: 주제 태그. tag2와 다른 것.`,
+};
+
+/**
+ * Resolves the score floor core would apply for this article's board.
+ *
+ * `minimumImportanceScoreRules` is matched by `targetUrl` and raises the bottom
+ * of the scale for boards that only ever carry relevant material. Core's default
+ * prompt also drops the "score 1 = no practical value" tier and the temporal
+ * expiry rule whenever a floor is in effect, since neither can be expressed
+ * below the floor. The replacement below reproduces that.
+ */
+function resolveMinimumScore({ targetArticle, minimumImportanceScoreRules, }) {
+    const rule = minimumImportanceScoreRules.find(({ targetUrl }) => targetUrl === targetArticle.targetUrl);
+    return rule?.minScore ?? 1;
+}
+const DOMAIN_PRIORITY = `## 유산 영역 우선순위
+
+이 뉴스레터는 고고학을 중심에 둔다. 사안의 객관적 무게가 비슷하다면 아래 순서로 점수를 준다.
+
+1. **고고학** — 발굴조사, 매장유산, 유적·유물, 발굴현장 공개, 고고학 학술 활동
+2. **문화유산** — 유형유산 지정·보존, 박물관 활동, 유산 정책
+3. **자연유산 / 무형유산**
+
+판단이 애매할 때 고고학 기사는 고려 중인 점수대의 위쪽을, 자연유산·무형유산 기사는 아래쪽을 택한다.
+영역은 tag1에 표기되어 있다. 단, 영역만으로 점수를 정하지는 않는다 — 사안 자체가 미미한 고고학 기사보다
+중대한 문화유산 기사가 높은 점수를 받는 것이 옳다.`;
+const SUBJECT_OVER_INSTITUTION = `## 발주·공고 기관이 아니라 사업 내용으로 판단
+
+유산 기관이 낸 공고라도 **내용이 유산 업무가 아니면 낮게 준다.** 기관명은 단서일 뿐 근거가 아니다.
+
+- 유산 업무: 발굴·시굴조사, 매장유산, 문화재 수리·보수정비, 보존처리, 기록화, 유적 정비,
+  학술연구, 유물 조사·분석, 전시 기획
+- 유산 업무가 아닌 것: 소방·전기·냉난방·창호·정보통신 같은 건물 설비와 그 유지보수,
+  청사 환경개선, 홈페이지·전산, 차량 임차, 홍보물·영상 제작,
+  축제·행사의 운영과 그 부대 용역(무대, 홍보, 교통·안전관리 포함)
+  → 국가유산청·국립박물관이 발주했더라도 **1점**. 발주처가 유산 기관이라는 이유로
+  2-3점으로 올리지 않는다. 유산 업무가 아니면 1점이다.
+
+예: "창덕궁 미분무 소화설비 성능개선 공사"는 궁궐 소재지만 소방 설비 공사다.
+"대전선사박물관 창호 긴급교체 공사"도 박물관 건물의 창호 교체다.
+"제72회 백제문화제 혼잡·교통유도 및 차량동선 안전관리 용역", "2026 경북종가음식문화대전
+사업 운영 용역", "청춘양구 펀치볼 사과시래기축제 홍보물 제작"은 모두 행사 운영·지원이다.
+"국립항공박물관 정보통신설비 유지보수" 역시 건물 설비 유지보수다.
+반대로 "팔만대장경 P-XRF 분석"은 발주처가 사찰이어도 명백한 유산 조사이고,
+"안양암 아미타괘불도 보존처리", "중요동산문화유산 기록화 3D 스캐닝",
+"소장유물 복제", "소장품도록 발간"은 유물을 직접 다루므로 정상 채점한다.`;
+const EMPLOYMENT_FILTER = `## 채용 공고 판별
+
+채용 공고는 **직무가 아래 지원 직무 목록에 해당하는지**를 먼저 본다.
+
+- **비유산 지원 직무: 조리·급식, 방호·경비, 청소·미화, 시설관리, 운전, 당직 → 점수 1**
+  이 목록에 해당하는 직무만 1점이다. 목록에 없는 직무를 유추해서 넣지 않는다.
+- **그 밖의 직무는 모두 아래 점수 기준을 정상 적용한다.** 특히 박물관·미술관·연구소가 내는
+  공고는 직무명이 학예직이 아니어도 — 행정, 연구, 교육, 전시, 기록물, 일반직 — 유산 분야로 본다.
+  기관명에 '문화유산'이나 '역사'가 들어가지 않아도 마찬가지다. 국립농업박물관의 행정직 공고는
+  박물관의 일자리이고, 그 자체가 독자에게 실무 정보다.
+- 한 공고에 두 분야가 섞여 있으면 유산 분야 직무를 기준으로 평가한다.`;
+function scoreScale(minimumScore) {
+    const tiers = [
+        '10: 분야 전체에 즉각적이고 중대한 영향 — 주요 법령 통과, 대규모 예산 배정, 학계를 바꾸는 발견',
+        '8-9: 다수 이해관계자에게 중요한 영향 — 주요 정책 변화, 중요 성과 공개, 대형 사업 발표',
+        '7-8: 특정 분야의 중요한 학술·실무 성과 — 학술지 발간, 연구 성과 발표, 보고서 간행, 주요 학술행사, 중요 자원 지정, 중규모 입찰',
+        '5-6: 특정 분야·지역에 한정된 일반적 중요 정보 — 소규모 사업 허가, 일반 행사 공지, 소규모 입찰',
+        '4-5: 일반적인 분야 소식, 중소 규모 행사',
+        '2-3: 단순 정보 공유, 반복적인 일상 소식',
+    ];
+    if (minimumScore === 1) {
+        tiers.push('1: **현재 실무 가치가 없는 정보** — 종료된 지원사업, 지난 행사, 만료된 입찰·채용 공고, 회비 납부 현황·회의록·내부 일정 같은 단순 행정 공지, 그리고 위 채용 판별에서 걸러진 비유산 지원 직무 채용');
+    }
+    return `## 점수 기준 (${minimumScore}-10)\n\n${tiers.join('\n')}`;
+}
+const EVALUATION_AXES = `## 평가 축
+
+- **학술 가치**: 학술지 발간, 연구보고서, 학술대회·심포지엄, 연구 성과 발표는 최소 7점 (지식 기반 확장과 장기 참조 가치)
+- **실무 영향**: 정책, 규정, 입찰, 채용처럼 즉각 대응이 필요한 정보
+- **영향 범위**: 영향받는 이해관계자의 수
+- **희소성**: 정보의 희귀성과 독점성`;
+function temporalRule$1(minimumScore) {
+    if (minimumScore > 1) {
+        return '';
+    }
+    return `
+## 시간 유효성 (HARD RULE)
+
+- 기사에 적힌 마감일, 접수 기간, 행사일, 입찰 마감, 채용 기간, 유효 기간을 뉴스레터 발행일과 비교한다.
+- 이미 지났다면 다른 기준과 무관하게 **1점**. 이 규칙이 다른 모든 고려사항에 우선한다.
+- 이 규칙은 **독자가 기한 안에 행동해야 하는 안내**에만 적용한다. 신청·접수·응모·입찰·참가 모집이 그렇다.
+- 예외 ①: 학술 성과(발간된 학술지, 공개된 연구, 종료된 학술대회 자료)는 참조 가치로 평가하며 깎지 않는다.
+- 예외 ②: **이미 일어난 일을 전하는 보도·발표 기사**는 깎지 않는다. 지정·선정 결과, 조사 성과, 협약·기증·개최 소식처럼
+  독자가 알아두면 되는 내용이면 행사일이 지났더라도 사안의 무게대로 평가한다.
+  (판단 기준: 기사가 독자에게 무엇을 하라고 요구하는가? 아무 행동도 요구하지 않는다면 이 규칙의 대상이 아니다.)
+- 예외 ③: **발굴조사·시굴조사·매장유산 조사 입찰 공고**는 입찰 마감이 지났어도 깎지 않는다.
+  독자는 입찰에 참여하려고 이 소식을 보는 것이 아니라 **어디서 어떤 조사가 시작되는지** 알려고 본다.
+  "○○ 유적 정밀발굴조사 용역 발주"는 그 자체로 고고학계 소식이다.
+  이런 공고는 수의계약으로 나와 마감이 공고 다음 날인 경우가 많아, 마감으로 거르면 정작 알려야 할 조사가 사라진다.
+  문화재 수리·보수정비·보존처리 발주도 같게 본다. 다만 입찰 참여 조건이나 마감을 강조해 쓰지는 않는다.
+- 마감·일정 언급이 전혀 없으면 이 규칙은 적용하지 않는다.
+`;
+}
+/**
+ * Replaces core's default importance prompt.
+ *
+ * Adds the archaeology-first weighting and the non-heritage employment filter,
+ * and drops core's star-rating vocabulary, which the newsletter no longer
+ * renders. The hard ceiling on natural and intangible heritage is **not** here:
+ * it is applied deterministically after scoring, in `AnalysisProvider.update()`,
+ * so the two never disagree.
+ */
+const determineImportancePrompt = {
+    system: (context) => {
+        const minimumScore = resolveMinimumScore(context);
+        return `당신은 한국 문화유산 분야의 중요도 평가 전문가다. 기사의 제목과 본문을 분석해 중요도를 점수로 매긴다.
+
+주 독자는 연구기관 연구원, 지자체·공공기관 담당자, 대학원생, 현장 전문가다. 긴급성·영향력·희소성을 기준으로 평가한다.
+
+${DOMAIN_PRIORITY}
+
+${SUBJECT_OVER_INSTITUTION}
+
+${EMPLOYMENT_FILTER}
+
+${scoreScale(minimumScore)}
+
+${EVALUATION_AXES}
+${temporalRule$1(minimumScore)}`;
+    },
+    user: (context) => {
+        const minimumScore = resolveMinimumScore(context);
+        const { targetArticle, dateService } = context;
+        const publishedDate = targetArticle.publishedDate
+            ? `\n**기사 게시일:** ${targetArticle.publishedDate}`
+            : '';
+        const imageContext = targetArticle.imageContextByLlm
+            ? `\n\n**이미지 분석:** ${targetArticle.imageContextByLlm}`
+            : '';
+        const temporalCheck = minimumScore > 1
+            ? ''
+            : '\n\n점수를 매기기 전에, 이 기사가 독자에게 기한 안에 행동할 것을 요구하는지 확인하라. 요구한다면 그 기한이 위 발행일 기준으로 지났는지 보고, 지났다면 1점이다. 이미 일어난 일을 전하는 보도라면 이 규칙을 적용하지 않는다.';
+        return `아래 기사의 중요도를 ${minimumScore}부터 10까지로 평가하라.
+
+**뉴스레터 발행일:** ${dateService.getPublicationISODateString()}${publishedDate}
+
+**제목:** ${targetArticle.title || '제목 없음'}
+
+**유산 영역(tag1):** ${targetArticle.tag1 || '미분류'}
+**주제 태그:** ${[targetArticle.tag2, targetArticle.tag3].filter(Boolean).join(', ') || '없음'}
+
+**본문:**
+${targetArticle.detailContent || '내용 없음'}${imageContext}${temporalCheck}`;
+    },
+};
+
+/**
+ * Category order. Categories listed here are emitted first, in this order;
+ * anything else follows, ordered by how consequential it is.
+ */
+const LEADING_CATEGORIES = [
+    '🎓 학술대회·학술행사',
+    '📋 발굴조사보고서 (신규 제출)',
+    '⛏️ 발굴현장 공개',
+    '💼 채용·공고',
+];
+/**
+ * The one category that runs last, immediately before 마무리.
+ *
+ * 나라장터 alone contributes about 49 notices a day — more than every other
+ * source combined — so leading with them would bury the 학술대회 and 발굴 news
+ * the newsletter exists for. They are not dropped either: procurement is how
+ * many readers earn a living, and a reader who misses a 공고 misses money.
+ * Last position keeps both true.
+ *
+ * Most of these notices concern non-archaeological heritage — 고택 보수, 향교
+ * 지붕, 사찰 방염 — and they stay for the same reason: archaeologists take that
+ * work. But they are the tail of the issue, not its headline, which is why
+ * {@link SECTION_PLACEMENT} keeps them out of the title and the briefing.
+ */
+const TRAILING_CATEGORY = '📑 사업·입찰 공고';
+/**
+ * Where 사업·입찰 may and may not appear.
+ *
+ * Stated in both the 제목 and 브리핑 rules as well, because fixing only one
+ * place in this prompt has no visible effect — the model satisfies whichever
+ * instruction it reads last.
+ */
+const SECTION_PLACEMENT = `- **\`${TRAILING_CATEGORY}\` 섹션의 소식은 제목(title)과 브리핑에 올리지 않는다.**
+  이 섹션은 본문 맨 끝에서 따로 정리하는 참고 정보다.
+  예외는 **발굴조사·시굴조사·매장유산 조사 입찰**뿐이다. 이것은 어디서 어떤 조사가
+  시작되는지 알리는 고고학 소식이므로, 무게가 있다면 제목과 브리핑에 올릴 수 있다.
+  고택 보수, 향교 정비, 사찰 방염, 박물관 시설 공사 같은 비고고학 유산 사업은
+  본문에는 싣되 제목과 브리핑에는 올리지 않는다.`;
+/**
+ * Per-category table columns.
+ *
+ * Source pages carry far more fields than a newsletter table can hold — an
+ * excavation report listing alone exposes a dozen (허가번호, 조사면적, 조사기간,
+ * 주소 …) — and core's default prompt asked for a generic four-column layout
+ * that overflows at email width. Naming the columns per category keeps the
+ * tables narrow and stops the model from inventing extra ones.
+ */
+const TABLE_SPECS = `### 표 형식 (구조적 목록)
+
+발굴조사보고서, 발굴현장 공개, 채용처럼 같은 형태가 반복되는 항목은 표로 낸다.
+열은 아래에 지정된 것만 쓴다. **원문에 다른 필드가 있어도 열을 추가하지 않는다.**
+
+- **발굴조사보고서**: \`유적 | 소재지 | 성격·시대\`
+  - 유적: 보고서명을 [원제목](URL) 링크로
+  - 소재지: 시도 + 시군구까지만 (예: 경남 합천군). 상세 주소·지번은 쓰지 않는다
+  - 성격·시대: 유적성격/시대구분 (예: 생활유적, 조선시대)
+  - 허가번호, 조사면적, 조사기간, 제출일, 도로명·지번 주소는 **싣지 않는다**
+- **발굴현장 공개**: \`유적 | 소재지 | 공개일시\`
+  - 유적: 공개 대상 유적명을 [원제목](URL) 링크로
+- **채용**: \`공고 | 기관 | 접수 마감\`
+  - 공고: 공고명을 [원제목](URL) 링크로
+  - 기관: 채용 기관명만 (예: 국립중앙박물관)
+  - 접수 마감: 날짜와 시각. 합격자 발표처럼 마감이 없는 공고는 "—"
+- **사업·입찰**: \`사업 | 발주기관 | 마감\`
+  - 사업: 공고명을 [원제목](URL) 링크로
+  - 발주기관: 발주처 이름만 (예: 안동시). 수요기관이 따로 있으면 수요기관을 쓴다
+  - 마감: 입찰 마감 일시. 원문에 없으면 "—"
+  - **아래 시간 유효성 예외 ③으로 살린 만료 공고는 마감 칸을 "—"로 둔다.**
+    이미 지난 마감 일시를 적으면 독자가 지원할 수 있는 것으로 읽는다.
+    그 공고를 싣는 이유는 어디서 어떤 조사가 시작되는지 알리기 위해서다.
+  - 사업금액, 계약방법, 공고번호, 업무구분은 **싣지 않는다**
+
+공통 규칙:
+
+- **첫 열에만 [원제목](URL) 링크를 넣는다.** 나머지 열에는 링크나 긴 제목을 넣지 않고,
+  지정된 값만 짧게 적는다.
+- 항목을 묶거나 "외 n건" 같은 표현으로 줄이지 않는다. 길어도 한 항목당 한 행으로 전부 싣는다.
+- 원문에 값이 없는 칸은 "—"로 채운다. 열 자체를 빼지 않는다.
+- 표 대신 글머리 기호나 번호 목록을 쓰지 않는다.`;
+const VOICE_RULES = `## 어투
+
+- **모든 문장을 '습니다'체로 쓴다.** "~했다", "~이다" 같은 평서형 종결어미를 쓰지 않는다.
+  ("공고했다" → "공고했습니다", "예정이다" → "예정입니다", "선정됐다" → "선정됐습니다")
+  표 안의 짧은 명사구는 예외로 둔다.
+- 신뢰할 만한 동료가 건네는 말투로 쓴다. 딱딱한 공문이나 보도자료 낭독이 아니다.
+  독자가 왜 이 소식을 봐야 하는지, 무엇을 챙기면 되는지를 한 마디로 짚어준다.
+- 다만 과장하거나 들뜨지 않는다. 감탄사, 홍보성 수식어, 억지 친근함은 쓰지 않는다.
+- 단정보다 권유에 가깝게 쓴다. ("확인해야 한다" → "확인해두시면 좋겠습니다")`;
+const EDITORIAL_RULES = `## 편집 규칙
+
+- **중요도 표시를 출력하지 않는다.** 별(★), 점수, "매우 중요" 같은 등급 표기를 본문 어디에도 쓰지 않는다. 중요도는 순서와 분량으로만 드러낸다.
+- **뉴스레터 제목(title)에는 이모지를 쓰지 않는다.** 본문 섹션 헤딩에는 쓴다(아래 참고).
+- **모든 \`##\` 섹션 헤딩은 이모지 하나로 시작한다.** 지정된 분류는 지정된 이모지를 그대로 쓰고,
+  그 외 분류는 내용에 맞는 이모지를 하나 고른다. (예: 🏺 전시·국제교류, 📣 기타 공지, 🌿 보존·정비)
+  한 호 안에서 같은 이모지를 두 번 쓰지 않는다.
+- 통계·비중 분석을 만들어내지 않는다. "오늘 소식의 00%가 ~" 같은 문장은 쓰지 않는다.
+- 소식을 언급할 때마다 [원제목](URL) 형식으로 링크한다. "자세히 보기", "기사", "[3번 글]" 같은 표기는 쓰지 않는다.
+- 날짜 범위는 물결표(~)가 아니라 붙임표(-)로 쓴다. 물결표는 마크다운에서 취소선이 된다.
+${SECTION_PLACEMENT}`;
+const LENGTH_CONTROL = `## 분량 (중요도 점수 기준, 점수 자체는 출력하지 않는다)
+
+- **9-10점**: 핵심 사실을 **굵게** + 링크. 대상·범위, 일정·절차, 예산·규모를 필요한 만큼 풀어쓴다.
+- **6-8점**: **최대 3문장.** 핵심 사실 한 문장(굵게 + 링크) + 필요하면 마감·예산 같은 결정적 정보 한두 문장. 하위 항목이나 글머리 목록을 만들지 않는다.
+- **1-5점**: **한 문장.** 핵심 사실 + 링크. 여러 건은 한 목록으로 묶어도 된다.
+
+구조적 목록(표)은 이 분량 제한과 무관하게 모든 항목을 싣는다.`;
+const FACT_RULES = `## 사실성
+
+- 제공된 자료에 명시된 내용만 쓴다. 추론이나 추측으로 확장하지 않는다.
+- "~로 보인다", "~할 전망이다" 같은 추측 표현을 쓰지 않는다.
+- 자료에 없는 기관·정책·계획을 사실처럼 쓰지 않는다.
+- 이미지 분석 결과는 기사의 시각적 맥락을 파악하는 용도로만 쓴다. 거기 담긴 이름·수치·세부 사실을 본문에 인용하지 않는다.
+- 원문 표현을 그대로 옮기지 않는다. 사실만 추출해 새 문장으로 쓴다.`;
+function temporalRule(publicationDate) {
+    return `## 시간 유효성 (HARD RULE)
+
+발행일은 ${publicationDate}이다. 모든 기사에 대해:
+
+- 이 규칙은 **독자가 기한 안에 행동해야 하는 안내**(신청·접수·응모·입찰·참가 모집)에만 적용한다.
+  마감일, 접수 기간, 행사 참가 기한, 입찰 마감, 채용 기간이 발행일 기준으로 이미 지났다면
+  중요도와 무관하게 본문에서 **완전히 제외**한다.
+- 예외 ①: 학술 성과(발간된 학술지, 공개된 연구, 종료된 학술대회 자료)는 참조 가치가 있으므로 남긴다.
+- 예외 ②: **이미 일어난 일을 전하는 보도·발표 기사**는 남긴다. 지정·선정 결과, 조사 성과, 협약·기증·개최 소식처럼
+  독자에게 아무 행동도 요구하지 않는 기사는 행사일이 지났더라도 그대로 싣는다.
+- 예외 ③: **발굴조사·시굴조사·매장유산 조사 입찰 공고**는 입찰 마감이 지났어도 싣는다.
+  독자는 입찰에 참여하려고 보는 것이 아니라 어디서 어떤 조사가 시작되는지 알려고 본다.
+  문화재 수리·보수정비·보존처리 발주도 같다. 다만 이런 항목은 **무엇을 조사·수리하는지** 중심으로 쓰고,
+  마감이 지난 입찰 일정은 적지 않는다.
+- 기사 게시일이 발행일보다 30일 이상 앞서면 신선도를 의심하고, 마감이 남은 진행 중 사업처럼 여전히 앞을 내다보는 가치가 있을 때만 싣는다.
+- 제외한 기사는 "그 밖에 주목할 만한 소식"이나 표에도 언급하지 않는다.`;
+}
+function structure(context) {
+    const { freeFormIntro, dateService } = context;
+    const displayDate = dateService.getPublicationDisplayDateString();
+    const opening = freeFormIntro
+        ? `1. **브리핑**: \`## 📮 ${displayDate} 브리핑\` 형식의 Heading 2로 시작한다. 분야 이름은 헤딩에 넣지 않는다.`
+        : `1. **머리말**: \`# ${displayDate} 문화유산 소식\` 형식의 Heading 1으로 시작하고, 이어서 \`## 📮 ${displayDate} 브리핑\` 문단을 쓴다.`;
+    return `## 구성
+
+${opening}
+
+   브리핑은 **3-4문장, 짧고 강하게** 쓴다. 오늘 가장 무게 있는 소식 한두 건을 이름을 들어 짚고, 독자가 왜 지금 이것을 봐야 하는지 한 문장으로 말한다.
+   통계, 비중, 항목 수 세기는 쓰지 않는다. 글머리 목록도 만들지 않는다. 구독 링크는 여기에 넣지 않는다.
+   **\`${TRAILING_CATEGORY}\` 섹션의 소식은 브리핑에 올리지 않는다.** 단, 발굴조사·시굴조사
+   입찰은 고고학 소식이므로 무게가 있다면 올릴 수 있다.
+
+2. **분류**: 아래 순서를 지킨다. 해당 소식이 없는 분류는 건너뛴다.
+
+${LEADING_CATEGORIES.map((c, i) => `   ${i + 1}) ${c}`).join('\n')}
+   ${LEADING_CATEGORIES.length + 1}) 그 외 (정책·제도, 지정·보존, 전시·행사 등 내용에 맞게 묶는다)
+   ${LEADING_CATEGORIES.length + 2}) ${TRAILING_CATEGORY} — **반드시 마지막 분류**로, \`## 📌 마무리\` 바로 앞에 둔다
+
+   \`${TRAILING_CATEGORY}\`에는 입찰 공고와 용역·공사 발주 소식을 모은다. 위의 다른
+   분류에 섞어 넣지 않는다. 건수가 많아도 표로 한 행씩 전부 싣고, 줄이거나 생략하지 않는다.
+   독자가 놓치면 일감을 놓치는 정보다.
+
+   각 분류는 Heading 2(\`##\`)를 쓴다. 분류 안에서는 중요한 것부터 배치한다.
+   같은 내용이 여러 출처에서 왔다면 가장 자세한 것을 기준으로 한 번만 쓴다.
+
+3. **마무리**: 마지막 섹션은 반드시 \`## 📌 마무리\`로 쓴다. 두 부분으로 구성한다.
+
+   가. 오늘 다룬 주요 소식을 한 문단으로 정리한다. 행사명 뒤에 날짜를 괄호로 덧붙인다.
+       (예: "국립김해박물관 가야 특별전 개막(9.18.), 백제학회 학술대회(9.18.) 등을 다루었습니다.")
+
+   나. 이어서 \`**임박한 주요 일정 및 마감:**\` 줄을 넣고, 날짜순 글머리 목록을 만든다.
+       한 줄에 한 날짜씩 묶고, 같은 날 여러 건이면 \` / \`로 잇는다.
+       형식: \`- **2026년 9월 18일(금):** 국립김해박물관 특별전 개막 / 백제학회 학술대회\`
+       마감 시각이 있으면 날짜 뒤에 붙인다. (예: \`- **2026년 9월 21일(월) 18:00:** …\`)
+       본문에서 다룬 일정만 넣는다. 날짜가 없는 소식은 넣지 않는다.
+       **\`${TRAILING_CATEGORY}\` 섹션의 입찰 마감은 이 목록에 넣지 않는다.** 마감 일시는
+       그 섹션의 표에 이미 있고, 목록까지 입찰로 채우면 학술대회·채용·전시 일정이 묻힌다.
+       학술대회, 채용 접수, 전시 개막·종료, 신청 마감 같은 나머지 일정만 넣는다.
+
+   다음 호 예고나 문의처는 쓰지 않는다.`;
+}
+function titleRules(context) {
+    const { titleContext } = context;
+    const common = `- 길이는 20-70자를 지킨다.
+- **이모지를 넣지 않는다.**
+- "뉴스레터" 같은 일반 명사 대신 구체적인 사실, 수치, 일정을 담는다.
+- '발표', '시행', '마감 임박'처럼 중립적이고 객관적인 표현을 쓴다.
+${SECTION_PLACEMENT}`;
+    if (titleContext) {
+        return `## 제목
+
+- **"${titleContext}"가 제목에 반드시 그대로 들어가야 한다.** 오늘 본문의 핵심 맥락과 자연스럽게 결합해 완성된 제목을 만든다.
+${common}`;
+    }
+    return `## 제목
+
+- 오늘 가장 중요한 소식 한두 건의 핵심 사실을 객관적으로 전달한다.
+- 가장 중요한 사실을 앞에 둔다.
+${common}`;
+}
+/**
+ * Replaces core's default newsletter prompt.
+ *
+ * Core's default mandates emoticons in the title and section headings, renders
+ * importance as star ratings, and asks for share-of-coverage statistics — all of
+ * which this newsletter removes. Those instructions cannot be cancelled by
+ * appending contradicting rules, so the prompt is written from scratch.
+ *
+ * It still has to satisfy core's fixed output schema, which drives a full
+ * regeneration (capped at 5 attempts) when the model reports a failure:
+ * a 20-70 character title, `isWrittenInOutputLanguage`, `copyrightVerified`,
+ * `factAccuracy`, and the `titleContext` phrase when one is supplied.
+ */
+const generateNewsletterPrompt = {
+    system: (context) => {
+        const { newsletterBrandName, expertFields, outputLanguage, dateService, subscribePageUrl, } = context;
+        const subscribeRule = subscribePageUrl
+            ? `\n\n## 공유 안내\n\n\`## 📌 마무리\` 섹션 **뒤에**, 본문 맨 마지막 줄로 링크를 한 번만 넣는다. 브리핑이나 본문 중간에는 넣지 않는다.
+
+이 글을 읽는 사람은 **이미 구독자**다. 구독을 권하지 말고, 동료에게 **소개·공유**해달라고 청한다.
+("구독해보세요", "정기 수신을 신청하세요" 같은 표현은 쓰지 않는다.)
+
+형식: 공유를 청하는 한 문장 + \`[${newsletterBrandName} 구독하기](${subscribePageUrl})\` 링크.
+(예: "이 소식이 도움이 되셨다면 동료 연구자에게도 소개해주시면 좋겠습니다. [${newsletterBrandName} 구독하기](${subscribePageUrl})")`
+            : '';
+        return `당신은 "${newsletterBrandName}"의 뉴스레터 편집자다. 독자는 ${expertFields.join(', ')} 분야의 연구자, 기관 담당자, 현장 전문가다.
+
+바쁜 전문가가 2-3분 안에 핵심을 파악할 수 있도록, 사실 중심으로 간결하게 씁니다.
+
+모든 내용은 ${outputLanguage}로 쓴다.
+
+${VOICE_RULES}
+
+${structure(context)}
+
+${EDITORIAL_RULES}${subscribeRule}
+
+${LENGTH_CONTROL}
+
+${TABLE_SPECS}
+
+${FACT_RULES}
+
+${temporalRule(dateService.getPublicationDisplayDateString())}
+
+${titleRules(context)}
+
+## 출력 형식
+
+본문은 마크다운으로 쓴다. 제목(#, ##), 굵게(**), 목록(-), 표를 활용한다.
+\`isWrittenInOutputLanguage\`, \`copyrightVerified\`, \`factAccuracy\`는 위 규칙을 모두 지켰을 때 true로 보고한다.`;
+    },
+    user: (context) => {
+        const { targetArticles, dateService, expertFields } = context;
+        const articles = targetArticles
+            .map((article, index) => {
+            const tags = [article.tag1, article.tag2, article.tag3]
+                .filter(Boolean)
+                .join(', ');
+            const image = article.imageContextByLlm
+                ? `\n**이미지 분석(맥락 파악용, 세부 사실 인용 금지):** ${article.imageContextByLlm}`
+                : '';
+            const published = article.publishedDate
+                ? `\n**게시일:** ${article.publishedDate}`
+                : '';
+            return `## 소식 ${index + 1}
+**제목:** ${article.title}
+**URL:** ${article.url}
+**중요도:** ${article.importanceScore}/10
+**태그:** ${tags}
+**구분:** ${article.contentType}${published}${image}
+**본문:**
+${article.detailContent}`;
+        })
+            .join('\n\n');
+        return `아래는 새로 수집된 ${expertFields.join(', ')} 관련 소식 전체다.
+
+${articles}
+
+---
+
+**발행일:** ${dateService.getPublicationISODateString()} (${dateService.getPublicationDisplayDateString()})
+
+위 소식으로 ${dateService.getPublicationDisplayDateString()} 자 뉴스레터를 작성하라.
+
+먼저 시간 유효성 HARD RULE을 적용해 **신청·접수 기한이 지난 안내**를 제외하고, 남은 소식을 지정된 분류 순서대로 배치한다.
+이미 일어난 일을 전하는 보도 기사는 행사일이 지났더라도 제외하지 않는다.
+중요도 점수는 분량을 정하는 데만 쓰고 본문에 출력하지 않는다.
+본문은 '습니다'체로 쓰고, 모든 섹션 헤딩은 이모지로 시작하며, 공유 링크는 \`## 📌 마무리\` 뒤 맨 마지막 줄에 한 번만 넣는다.
+독자는 이미 구독자이므로 구독 권유가 아니라 동료에게 소개해달라는 문장으로 쓴다.`;
+    },
+};
+
+/**
+ * Research Radar's LLM prompt overrides.
+ *
+ * Each builder here **replaces** core's built-in prompt for that stage rather
+ * than extending it — a `PromptBuilder` returns the whole prompt string. That is
+ * deliberate: core's defaults instruct the model to use emoticons, render
+ * importance as star ratings, and add share-of-coverage statistics, all of which
+ * this newsletter removes. Appending contradicting rules to those defaults
+ * degrades the output, so a replacement is written from scratch instead.
+ *
+ * **Contract a replacement must still satisfy.** Core's output schema is fixed,
+ * and `generateNewsletter` regenerates the whole newsletter whenever the model
+ * reports a failure. A replacement prompt has to steer the model toward:
+ *
+ * - `title`: 20–70 characters
+ * - `isWrittenInOutputLanguage`, `copyrightVerified`, `factAccuracy`: true
+ * - `titleContext` (KRAS mode): the phrase must appear in the title
+ *
+ * Core caps that loop at 5 attempts, so a prompt that ignores the contract costs
+ * up to 5 full generations on the most expensive model in the pipeline.
+ *
+ * Tune these against real articles with core's playground
+ * (`npm run playground:generate-newsletter` in ../llm-newsletter-kit-core) and
+ * diff them against the defaults for free with `playground:verify-prompts`.
+ * The playground loads this module from `dist`, so run `npm run build` here
+ * after every edit — its source cannot be imported directly across repos
+ * because of the `~/*` path alias.
+ */
+const researchRadarPromptProvider = {
+    analysis: {
+        classifyTags: classifyTagsPrompt,
+        determineImportance: determineImportancePrompt,
+    },
+    contentGenerate: {
+        generateNewsletter: generateNewsletterPrompt,
+    },
+};
+
 /**
  * Analysis provider implementation
  * - LLM-based article analysis
@@ -1869,13 +3650,13 @@ class AnalysisProvider {
         this.articleRepository = articleRepository;
         this.tagRepository = tagRepository;
         this.classifyTagOptions = {
-            model: this.openai('gpt-5-mini'),
+            model: this.openai('gpt-5.6-luna'),
         };
         this.analyzeImagesOptions = {
-            model: this.openai('gpt-5.1'),
+            model: this.openai('gpt-5.6-terra'),
         };
         this.determineScoreOptions = {
-            model: this.openai('gpt-5.1'),
+            model: this.openai('gpt-5.6-terra'),
             minimumImportanceScoreRules: [
                 // Korean Archaeological Society news: minimum score 6
                 {
@@ -1981,9 +3762,29 @@ class AnalysisProvider {
      * @param article - Article with analysis data
      */
     async update(article) {
-        await this.articleRepository.updateAnalysis(article);
+        await this.articleRepository.updateAnalysis({
+            ...article,
+            importanceScore: capScoreByHeritageDomain(article),
+        });
     }
 }
+/**
+ * Applies the per-domain score ceiling from `maximumImportanceScoreByDomain`.
+ *
+ * The domain comes from `tag1`, which the tag classification prompt pins to a
+ * fixed vocabulary. An off-vocabulary value means the classification did not
+ * hold, so the article is left uncapped rather than capped on a guess.
+ */
+function capScoreByHeritageDomain(article) {
+    const domain = toHeritageDomainTag(article.tag1);
+    if (!domain) {
+        return article.importanceScore;
+    }
+    const maximumScore = maximumImportanceScoreByDomain[domain];
+    return maximumScore === undefined
+        ? article.importanceScore
+        : Math.min(article.importanceScore, maximumScore);
+}
 
 /**
  * Shared HTML fragments used by both newsletter and welcome email templates.
@@ -2634,6 +4435,231 @@ class ContentGenerateProvider {
     }
 }
 
+/**
+ * robots.txt enforcement for crawling.
+ *
+ * Applied at the fetch layer, the same seam the KRAS and excavation-report
+ * adapters use, so core's crawling pipeline is untouched: a disallowed request
+ * is answered with 403 instead of being sent. Core treats a 4xx list response as
+ * a failed fetch, logs `crawl.list.fetch.failed`, and continues with an empty
+ * page, so a blocked target yields no articles rather than breaking the run.
+ */
+/**
+ * Parses robots.txt into user-agent groups.
+ *
+ * Unknown fields (Sitemap, Crawl-delay, Host) and malformed lines are skipped —
+ * 국가유산청 serves a `Disaloow:` typo, which must not be read as a rule.
+ * Consecutive `User-agent:` lines share one rule block, per the spec.
+ */
+function parseRobotsTxt(text) {
+    const groups = [];
+    let current = null;
+    let previousLineWasAgent = false;
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.split('#')[0].trim();
+        if (!line) {
+            continue;
+        }
+        const separator = line.indexOf(':');
+        if (separator === -1) {
+            continue;
+        }
+        const field = line.slice(0, separator).trim().toLowerCase();
+        const value = line.slice(separator + 1).trim();
+        if (field === 'user-agent') {
+            if (!previousLineWasAgent || !current) {
+                current = { agents: [], rules: [] };
+                groups.push(current);
+            }
+            current.agents.push(value.toLowerCase());
+            previousLineWasAgent = true;
+            continue;
+        }
+        if (field === 'allow' || field === 'disallow') {
+            current?.rules.push({ allow: field === 'allow', path: value });
+        }
+        previousLineWasAgent = false;
+    }
+    return groups;
+}
+/** Matches a robots path pattern, supporting `*` wildcards and a `$` anchor. */
+function matchesPattern(pattern, path) {
+    if (pattern === '') {
+        return false;
+    }
+    const anchored = pattern.endsWith('$');
+    const body = anchored ? pattern.slice(0, -1) : pattern;
+    const segments = body.split('*');
+    let position = 0;
+    for (const [index, segment] of segments.entries()) {
+        if (index === 0) {
+            if (!path.startsWith(segment)) {
+                return false;
+            }
+            position = segment.length;
+            continue;
+        }
+        if (segment === '') {
+            // Trailing wildcard: anything left over matches, unless `$` demands the end.
+            if (index === segments.length - 1) {
+                return !anchored;
+            }
+            continue;
+        }
+        const found = path.indexOf(segment, position);
+        if (found === -1) {
+            return false;
+        }
+        position = found + segment.length;
+    }
+    return anchored ? position === path.length : true;
+}
+/** Picks the group for this user agent: a named match first, then `*`. */
+function selectGroup(groups, userAgent) {
+    const normalized = userAgent.toLowerCase();
+    const named = groups.find((group) => group.agents.some((agent) => agent !== '*' && normalized.includes(agent)));
+    return named ?? groups.find((group) => group.agents.includes('*')) ?? null;
+}
+/**
+ * Decides whether a path may be requested.
+ *
+ * The most specific matching rule wins; `Allow` wins a tie. A user agent with no
+ * matching group, and a group with no matching rule, are both allowed.
+ *
+ * @param pathWithQuery - Path including the query string, e.g. `/bbs/list.do?key=1`
+ */
+function isPathAllowed(groups, userAgent, pathWithQuery) {
+    const group = selectGroup(groups, userAgent);
+    if (!group) {
+        return { allowed: true };
+    }
+    let best = null;
+    for (const rule of group.rules) {
+        if (!matchesPattern(rule.path, pathWithQuery)) {
+            continue;
+        }
+        if (!best ||
+            rule.path.length > best.path.length ||
+            (rule.path.length === best.path.length && rule.allow)) {
+            best = rule;
+        }
+    }
+    if (!best || best.allow) {
+        return { allowed: true };
+    }
+    return { allowed: false, rule: `Disallow: ${best.path}` };
+}
+function resolveRequestUrl(input) {
+    if (typeof input === 'string') {
+        return input;
+    }
+    return input instanceof URL ? input.href : input.url;
+}
+/** Reads the User-Agent from an outgoing request, whatever shape the headers take. */
+function resolveUserAgent(input, init) {
+    const headers = init?.headers ?? (input instanceof Request ? input.headers : undefined);
+    if (!headers) {
+        return '*';
+    }
+    if (headers instanceof Headers) {
+        return headers.get('user-agent') ?? '*';
+    }
+    if (Array.isArray(headers)) {
+        const found = headers.find(([key]) => key.toLowerCase() === 'user-agent');
+        return found?.[1] ?? '*';
+    }
+    const entry = Object.entries(headers).find(([key]) => key.toLowerCase() === 'user-agent');
+    return entry?.[1] ?? '*';
+}
+/**
+ * Builds a robots.txt gate: a verdict function and a fetch that enforces it,
+ * sharing one per-origin cache.
+ *
+ * robots.txt is fetched once per origin and the in-flight promise is shared, so
+ * concurrent requests to the same site cause a single lookup. The lookup itself
+ * bypasses the check.
+ *
+ * **Fails open.** A missing (4xx), unreachable, or unparseable robots.txt allows
+ * the request. A transient outage should not silently empty the newsletter, and
+ * 404 already means "no restrictions" under the standard. Blocked requests are
+ * reported through `onBlocked` rather than logged here.
+ */
+function createRobotsGate(baseFetch = fetch, options = {}) {
+    const { onBlocked, timeoutMs = 10_000, exemptOrigins = [] } = options;
+    const cache = new Map();
+    const exempt = new Set(exemptOrigins.map((origin) => {
+        try {
+            return new URL(origin).origin;
+        }
+        catch {
+            return origin;
+        }
+    }));
+    const loadRobots = (origin) => {
+        const cached = cache.get(origin);
+        if (cached) {
+            return cached;
+        }
+        const pending = (async () => {
+            try {
+                const response = await baseFetch(`${origin}/robots.txt`, {
+                    redirect: 'follow',
+                    signal: AbortSignal.timeout(timeoutMs),
+                });
+                if (!response.ok) {
+                    return [];
+                }
+                const body = await response.text();
+                // Some sites answer robots.txt with their HTML 404 page.
+                return body.trimStart().startsWith('<') ? [] : parseRobotsTxt(body);
+            }
+            catch {
+                return [];
+            }
+        })();
+        cache.set(origin, pending);
+        return pending;
+    };
+    const isAllowed = async (requestUrl, userAgent = '*') => {
+        let url;
+        try {
+            url = new URL(requestUrl);
+        }
+        catch {
+            return { allowed: true };
+        }
+        if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+            return { allowed: true };
+        }
+        if (url.pathname === '/robots.txt') {
+            return { allowed: true };
+        }
+        if (exempt.has(url.origin)) {
+            return { allowed: true };
+        }
+        const groups = await loadRobots(url.origin);
+        return isPathAllowed(groups, userAgent, url.pathname + url.search);
+    };
+    const gatedFetch = async (input, init) => {
+        const requestUrl = resolveRequestUrl(input);
+        const userAgent = resolveUserAgent(input, init);
+        const verdict = await isAllowed(requestUrl, userAgent);
+        if (verdict.allowed) {
+            return baseFetch(input, init);
+        }
+        onBlocked?.({ url: requestUrl, userAgent, rule: verdict.rule });
+        return new Response(`Blocked by robots.txt (${verdict.rule}) - ${new URL(requestUrl).origin}/robots.txt`, { status: 403, statusText: 'Blocked by robots.txt' });
+    };
+    return { isAllowed, fetch: gatedFetch };
+}
+/**
+ * Wraps a fetch so that requests disallowed by the origin's robots.txt are
+ * refused with 403 instead of sent. See {@link createRobotsGate}.
+ */
+function createRobotsAwareFetch(baseFetch = fetch, options = {}) {
+    return createRobotsGate(baseFetch, options).fetch;
+}
+
 /**
  * Crawling provider implementation
  * - Defines crawling targets
@@ -2648,9 +4674,32 @@ class CrawlingProvider {
     customFetch;
     /** Crawling target groups configuration */
     crawlingTargetGroups;
-    constructor(articleRepository, customFetch) {
+    constructor(articleRepository, customFetch, excavationReportSource, logger, publicDataApiKey, bidTriage) {
         this.articleRepository = articleRepository;
-        this.customFetch = createKrasFetch(customFetch ?? fetch);
+        // robots.txt is checked first, so a disallowed request is never sent — not
+        // even through a proxy. The injected and KRAS adapters sit inside it: their
+        // requests either bypass the network entirely or are rewritten to a URL
+        // that still gets checked.
+        const withRobots = createRobotsAwareFetch(customFetch ?? fetch, {
+            exemptOrigins: robotsExemptOrigins,
+            onBlocked: ({ url, rule, userAgent }) => {
+                logger?.info({
+                    event: 'crawl.robots.blocked',
+                    data: { url, rule, userAgent },
+                });
+            },
+        });
+        const withKras = createKrasFetch(withRobots);
+        // The two public job boards are read from data.go.kr open APIs. Without a
+        // key they answer with an empty list and make no request, so the targets
+        // stay configured and simply collect nothing.
+        const withPublicJobs = createG2bFetch(createAlioFetch(createGojobsFetch(withKras, { apiKey: publicDataApiKey ?? '' }), { apiKey: publicDataApiKey ?? '' }), { apiKey: publicDataApiKey ?? '', triage: bidTriage });
+        // When the application supplies excavation reports, that board is served
+        // from the injected source and never requested over the network. Every
+        // other target keeps going through the same fetch as before.
+        this.customFetch = excavationReportSource
+            ? createExcavationReportFetch(withPublicJobs, excavationReportSource)
+            : withPublicJobs;
         this.crawlingTargetGroups = createCrawlingTargetGroups(this.customFetch);
     }
     /**
@@ -2811,7 +4860,7 @@ function createContentGenerationModel(config) {
     switch (config.provider) {
         case 'openai': {
             const provider = createOpenAI({ apiKey: config.apiKey });
-            return provider(config.model ?? 'gpt-5.4');
+            return provider(config.model ?? 'gpt-5.6-sol');
         }
         case 'anthropic': {
             const provider = createAnthropic({ apiKey: config.apiKey });
@@ -2829,7 +4878,19 @@ function createNewsletterGenerator(dependencies) {
     });
     const dateService = new DateService(dependencies.publishDate);
     const taskService = new TaskService(dependencies.taskRepository);
-    const crawlingProvider = new CrawlingProvider(dependencies.articleRepository, dependencies.customFetch);
+    const crawlingProvider = new CrawlingProvider(dependencies.articleRepository, dependencies.customFetch, dependencies.excavationReportSource, dependencies.logger, dependencies.publicDataApiKey, 
+    // 나라장터 publishes about 1,500 notices per 48-hour window, so which ones
+    // reach per-article scoring is decided here, 100 titles per request. The
+    // deterministic filter stays behind it as the fallback.
+    createHeritageBidTriage({
+        model: openai('gpt-5.6-luna'),
+        onFallback: (reason, batchSize) => {
+            dependencies.logger?.info({
+                event: 'crawl.g2b.triage.fallback',
+                data: { reason, batchSize },
+            });
+        },
+    }));
     const analysisProvider = new AnalysisProvider(openai, dependencies.articleRepository, dependencies.tagRepository);
     // Inject display date from DateService into template options
     const templateOptions = dependencies.templateOptions
@@ -2853,6 +4914,7 @@ function createNewsletterGenerator(dependencies) {
     const contentGenerateProvider = new ContentGenerateProvider(contentModel, dependencies.articleRepository, dependencies.newsletterRepository, templateOptions, resolvedBrandName);
     return new GenerateNewsletter({
         contentOptions: resolvedContentOptions,
+        promptProvider: dependencies.promptProvider ?? researchRadarPromptProvider,
         dateService,
         taskService,
         crawlingProvider,
@@ -3152,5 +5214,5 @@ ${poweredByFooterHtml()}
 </html>`;
 }
 
-export { AnalysisProvider, ContentGenerateProvider, CrawlingProvider, DateService, TaskService, contentOptions, createCrawlingTargetGroups, generateNewsletter, generateWelcomeHTML, getSourceList, llmConfig, newsletterConfig };
+export { AnalysisProvider, ContentGenerateProvider, CrawlingProvider, DateService, TaskService, contentOptions, createCrawlingTargetGroups, generateNewsletter, generateWelcomeHTML, getSourceList, llmConfig, maximumImportanceScoreByDomain, newsletterConfig, researchRadarPromptProvider, robotsExemptOrigins };
 //# sourceMappingURL=index.js.map