elanous 0.2.16 → 0.2.17

package/scripts/intake-news.ts

@@ -0,0 +1,169 @@
+import { createHash } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { judge } from '../src/llm/judge-layer.js';
+import { effectiveInstanceRoot } from '../src/instance/resolve.js';
+import { canonicalUrl } from '../src/intake-plane/items.js';
+
+export interface NewsSource { name: string; rss: string }
+export interface NewsArticle { title: string; description: string; url: string; published: string }
+export interface NewsCheck { items: { fact: string; line: string; verdict: string; current: string }[] }
+export interface NewsDeps {
+  fetch?: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+  now?: () => Date;
+  check?: (facts: readonly string[]) => Promise<NewsCheck>;
+  classify?: (article: NewsArticle) => Promise<boolean>;
+  log?: (message: string) => void;
+}
+
+const AXES = /하니스|harness|에이전트|agent|코딩\s*(?:에이전트|agent)|coding\s*agent|로컬\s*(?:llm|언어모델)|local\s*llm|기업.{0,12}ai\s*도입|enterprise\s*ai|ai\s*투자|인공지능\s*투자|ai\s*investment/i;
+const AMBIGUOUS = /\bAI\b|인공지능|생성형|\bLLM\b/i;
+const entity = (text: string): string => text.replace(/&#(x[\da-f]+|\d+);|&(amp|lt|gt|quot|apos|nbsp|lsquo|rsquo|ldquo|rdquo|middot|hellip|ndash|mdash);/gi, (match, numeric: string | undefined, named: string | undefined) => {
+  if (numeric) {
+    const code = numeric[0]?.toLowerCase() === 'x' ? parseInt(numeric.slice(1), 16) : parseInt(numeric, 10);
+    return code > 0 && code <= 0x10ffff ? String.fromCodePoint(code) : match;
+  }
+  return ({ amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ', lsquo: '‘', rsquo: '’', ldquo: '“', rdquo: '”', middot: '·', hellip: '…', ndash: '–', mdash: '—' } as Record<string, string>)[named?.toLowerCase() ?? ''] ?? match;
+});
+const plain = (text: string): string => entity(text.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1').replace(/<[^>]+>/g, ' ')).replace(/\s+/g, ' ').trim();
+const field = (xml: string, tag: string): string => plain(xml.match(new RegExp(`<${tag}(?:\\s[^>]*)?>([\\s\\S]*?)<\\/${tag}>`, 'i'))?.[1] ?? '');
+
+/** RSS 2.0 items, including CDATA, escaped HTML and pubDate. */
+export function parseNewsRss(xml: string): NewsArticle[] {
+  if (!/<rss\b|<rdf:RDF\b/i.test(xml)) throw new Error('RSS 응답이 아님');
+  return [...xml.matchAll(/<item(?:\s[^>]*)?>([\s\S]*?)<\/item>/gi)].flatMap((match) => {
+    const item = match[1] ?? '';
+    const url = field(item, 'link');
+    const published = field(item, 'pubDate');
+    return /^https?:\/\//i.test(url) && Number.isFinite(Date.parse(published))
+      ? [{ title: field(item, 'title'), description: field(item, 'description'), url, published }]
+      : [];
+  });
+}
+
+export function newsInterest(article: NewsArticle): 'yes' | 'no' | 'ambiguous' {
+  const text = `${article.title} ${article.description}`;
+  if (AXES.test(text)) return 'yes';
+  return AMBIGUOUS.test(text) ? 'ambiguous' : 'no';
+}
+
+async function classifyAmbiguous(article: NewsArticle): Promise<boolean> {
+  const decision = await judge({
+    site: 'intake.news.interest',
+    prompt: `제목·요약만 보고 하니스·에이전트·코딩 에이전트·로컬 LLM·기업 AI 도입·AI 투자 관련 기사인지 판정한다. JSON {"relevant":true|false} 만 답하라.\n제목: ${article.title}\n요약: ${article.description}`,
+    schema: (value) => value && typeof value === 'object' && typeof (value as { relevant?: unknown }).relevant === 'boolean'
+      ? (value as { relevant: boolean }).relevant : null,
+  });
+  if (!decision.ok) throw new Error('관심 축 판정 실패');
+  return decision.value;
+}
+
+/** The CLI, not a local imitation of the checker, is the implication authority. No --author or release mutation. */
+async function checkWithCli(facts: readonly string[]): Promise<NewsCheck> {
+  const result = spawnSync('bun', ['bin/elanous.mjs', '--test', 'intake', 'check', ...facts.flatMap((fact) => ['--fact', fact]), '--json'], {
+    cwd: resolve(import.meta.dir, '..'), encoding: 'utf8', timeout: 120_000, maxBuffer: 4 * 1024 * 1024,
+  });
+  if (result.error || result.status !== 0) throw new Error(result.error?.message ?? result.stderr?.trim() ?? `intake check exited ${result.status}`);
+  // Standalone notifications may precede JSON on stdout.
+  const start = result.stdout.indexOf('{');
+  if (start < 0) throw new Error('intake check JSON 없음');
+  const parsed = JSON.parse(result.stdout.slice(start)) as NewsCheck;
+  if (!Array.isArray(parsed.items)) throw new Error('intake check items 없음');
+  return parsed;
+}
+
+function summarize(html: string): string[] {
+  const body = html.replace(/<script\b[^>]*>[\s\S]*?<\/script>|<style\b[^>]*>[\s\S]*?<\/style>/gi, ' ');
+  const paragraphs = [...body.matchAll(/<(?:p|h[1-4])\b[^>]*>([\s\S]*?)<\/(?:p|h[1-4])>/gi)]
+    .map((match) => plain(match[1] ?? '')).filter((text) => text.length >= 25 && !/무단전재|저작권|기자\s*=/.test(text));
+  if (!paragraphs.length) throw new Error('본문을 읽지 못함');
+  const text = paragraphs.join(' ');
+  const sentences = text.split(/(?<=[.!?。])\s+/).map((s) => s.trim()).filter(Boolean);
+  // 앞 문장 요약(최대 다섯 줄) — 짧은 기사는 있는 문장만 남긴다. 낱말을 잘라 줄 수를 채우지 않는다(사실을 지어내지 않는다).
+  return sentences.slice(0, 5).map((sentence) => sentence.slice(0, 240));
+}
+
+export async function runIntakeNews(options: { root: string; sources: readonly NewsSource[]; deps?: NewsDeps }): Promise<{ written: number; failed: number }> {
+  const { root, sources, deps = {} } = options;
+  const request = deps.fetch ?? fetch;
+  const log = deps.log ?? ((message: string) => console.error(message));
+  const now = (deps.now ?? (() => new Date()))();
+  const day = new Date(now.getTime() + 9 * 3600_000).toISOString().slice(0, 10);
+  const state = join(root, 'intake', 'news-seen.jsonl');
+  const lens = join(root, 'intake', 'outbox', 'lens', `${day}.jsonl`);
+  const seen = new Set(existsSync(state) ? readFileSync(state, 'utf8').split('\n').filter(Boolean) : []);
+  // 렌즈에 이미 쓴 기사도 «본 것» — 렌즈 기록과 상태 기록 사이에서 죽어도 재실행이 같은 기사를 다시 쓰지 않는다(24h 창이라 어제·오늘 파일).
+  const yesterday = new Date(now.getTime() + 9 * 3600_000 - 86_400_000).toISOString().slice(0, 10);
+  for (const lensDay of [yesterday, day]) {
+    const file = join(root, 'intake', 'outbox', 'lens', `${lensDay}.jsonl`);
+    if (!existsSync(file)) continue;
+    for (const line of readFileSync(file, 'utf8').split('\n')) {
+      try { const id = (JSON.parse(line) as { id?: unknown }).id; if (typeof id === 'string') seen.add(id); } catch { /* 깨진 줄은 건너뛴다 */ }
+    }
+  }
+  let written = 0;
+  let failed = 0;
+  for (const source of sources) {
+    try {
+      const response = await request(source.rss, { signal: AbortSignal.timeout(30_000) });
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      for (const article of parseNewsRss(await response.text())) {
+        const published = Date.parse(article.published);
+        if (published > now.getTime() || published < now.getTime() - 86_400_000) continue;
+        const id = createHash('sha256').update(canonicalUrl(article.url) ?? article.url).digest('hex').slice(0, 16);
+        if (seen.has(id)) continue;
+        const interest = newsInterest(article);
+        if (interest === 'no') continue;
+        try {
+          if (interest === 'ambiguous' && !(await (deps.classify ?? classifyAmbiguous)(article))) continue;
+          const page = await request(article.url, { signal: AbortSignal.timeout(30_000) });
+          if (!page.ok) throw new Error(`본문 HTTP ${page.status}`);
+          const summary = summarize(await page.text());
+          const name = article.title.match(/\b[A-Z][A-Z0-9]{2,}\b/)?.[0] ?? article.title;
+          // 함의는 기사 하나에서 셋까지 — 제목 ⊕ 요약 앞 두 문장을 각각 «엘라누스가 이걸 하나»로 대조한다(판정선: 함의 3).
+          const facts = [
+            `elanous는 \`${name}\` 관련 ${article.title} 기능을 지원한다`,
+            ...summary.slice(0, 2).map((line) => `elanous는 다음 일을 한다: ${line.slice(0, 160)}`),
+          ];
+          const check = await (deps.check ?? checkWithCli)(facts);
+          if (!check.items.length) throw new Error('intake check 항목 없음');
+          // «판단 필요» is a review suggestion, not an asserted absence; keep the check verdict attached.
+          const suggestions = check.items.filter((item) => item.verdict === '없음' || item.verdict === '판단 필요')
+            .map((item) => ({ kind: '칸 제안', fact: item.fact, status: '제안', verdict: item.verdict }));
+          const verdict = suggestions.length ? '보강'
+            : check.items.every((item) => item.verdict === '있음') ? '참고' : '경쟁 대조';
+          const record = {
+            id, at: now.toISOString(), source: source.name, url: article.url, title: article.title,
+            summary, implication: check.items.map((item) => item.line), suggestions,
+            lensVerdict: verdict, why: `엘라누스 대조: ${check.items.map((item) => item.line).join(' · ')}`.slice(0, 500), target: name,
+          };
+          mkdirSync(dirname(lens), { recursive: true });
+          appendFileSync(lens, `${JSON.stringify(record)}\n`);
+          mkdirSync(dirname(state), { recursive: true });
+          appendFileSync(state, `${id}\n`);
+          seen.add(id);
+          written++;
+        } catch (error) {
+          failed++;
+          log(`못 모음: ${article.url} — ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+    } catch (error) {
+      failed++;
+      log(`못 모음: ${source.name} — ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return { written, failed };
+}
+
+if (import.meta.main) {
+  const config = parseYaml(readFileSync(resolve(import.meta.dir, '../graphs/intake/news-sources.yaml'), 'utf8')) as { sources?: NewsSource[] };
+  if (!Array.isArray(config.sources) || !config.sources.every((source) => source && typeof source.name === 'string' && source.name.trim() && typeof source.rss === 'string' && /^https?:\/\//.test(source.rss))) {
+    throw new Error('news-sources.yaml: sources 배열 필요');
+  }
+  const result = await runIntakeNews({ root: effectiveInstanceRoot(), sources: config.sources });
+  console.log(`intake-news: ${result.written}건 · 못 모음 ${result.failed}건`);
+  if (result.failed) process.exitCode = 1;
+}

package/scripts/release-loop/docs-land-node.ts

@@ -1,10 +1,14 @@
 #!/usr/bin/env bun
-import { existsSync, mkdtempSync, rmSync } from 'node:fs';
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { effectiveInstanceRoot, releaseLedgerRoot } from '../../src/instance/resolve.js';
+import { listChecklist } from '../../src/release-loop/checklist.js';
+import type { ReleaseManifest } from '../../src/release-loop/manifest.js';
+import { recordDocsFollow, type DocsFollowItem } from './release-docs.js';
 import { dirname, join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { errorResult, finishNode, nodeOutput, readGraphContext, runCommand, type CommandRunner } from './node-verdict.js';
 
-export function runDocsLand(run: CommandRunner = runCommand) {
+export function runDocsLand(run: CommandRunner = runCommand, stateRoot = effectiveInstanceRoot(), ledgerRoot = releaseLedgerRoot()) {
   const context = readGraphContext();
   const version = context.input.version;
   if (context.outputs.publish?.outcome !== 'ok') throw new Error('publish must succeed before docs land');
@@ -14,6 +18,37 @@ export function runDocsLand(run: CommandRunner = runCommand) {
   const worktree = nodeOutput(context, 'docs', 'worktree');
   const scratch = dirname(worktree);
   if (dirname(scratch) !== tmpdir() || !/^release-docs-[A-Za-z0-9]+$/.test(scratch.split('/').at(-1) ?? '') || worktree !== join(scratch, 'tree')) throw new Error('invalid docs worktree');
+  const recordFollow = (deployed: boolean) => {
+    const releaseDir = join(stateRoot, 'release', version);
+    const manifest: ReleaseManifest = JSON.parse(readFileSync(join(releaseDir, 'manifest.json'), 'utf8'));
+    if (manifest.version !== version || !Array.isArray(manifest.in)) throw new Error('docs-follow manifest/version mismatch');
+    // MK attestations are independent of generated notes; missing proof is unmeasured.
+    const evidencePath = join(releaseDir, 'docs-follow-evidence.json');
+    // 증거 파일이 깨졌으면 «증거 없음»으로 센다 — 보고서·MK 대기열은 그래도 남긴다(미측정으로).
+    let raw: unknown = { items: [] };
+    try { if (existsSync(evidencePath)) raw = JSON.parse(readFileSync(evidencePath, 'utf8')); }
+    catch (error) { process.stderr.write(`docs-follow evidence unreadable — counted as no evidence: ${String(error)}\n`); }
+    const valid = !!raw && typeof raw === 'object' && 'items' in raw && Array.isArray((raw as { items: unknown }).items);
+    if (!valid) process.stderr.write('docs-follow evidence malformed — counted as no evidence\n');
+    // 항목도 하나씩 본다 — 객체이고 문자열 id 가 있는 것만 증거로 센다(나머지는 «증거 없음»).
+    const evidence: { items: unknown[] } = { items: valid ? (raw as { items: unknown[] }).items
+      .filter((item) => !!item && typeof item === 'object' && typeof (item as { id?: unknown }).id === 'string') : [] };
+    const checklist = listChecklist(version, ledgerRoot);
+    const attestations = new Map((evidence.items as DocsFollowItem[]).map((item) => [item.id, item]));
+    const items = checklist.items.map((item) => ({ ...attestations.get(item.id), id: item.id, status: item.status,
+      ...(deployed ? {} : { docs: undefined }) }));
+    const publicationFile = join(ledgerRoot, 'release', version, 'release.json');
+    const publication: unknown = existsSync(publicationFile) ? JSON.parse(readFileSync(publicationFile, 'utf8')) : null;
+    const publishedAt = publication && typeof publication === 'object' && 'publishedAt' in publication
+      && typeof publication.publishedAt === 'string' ? publication.publishedAt : undefined;
+    const follow = recordDocsFollow(stateRoot, manifest, items, new Date(), publishedAt);
+    return { pending: follow.pending.length, unassessed: follow.unassessed.length, ratio: follow.ratio, verdict: follow.verdict };
+  };
+  // The deployment error is authoritative even if the follow-up ledger cannot be written.
+  const recordFailure = () => {
+    try { return recordFollow(false); }
+    catch (error) { process.stderr.write(`docs-follow recording failed: ${String(error)}\n`); return undefined; }
+  };
   // 재시도 멱등: 노트가 이미 main 에 있으면(앞 판에서 머지됐고 배포만 실패) 착지를 건너뛰고 배포부터.
   const before = run('git', ['fetch', 'origin', 'main']);
   if (before.status !== 0) throw new Error(`docs landing fetch failed: ${before.stderr}`);
@@ -22,16 +57,20 @@ export function runDocsLand(run: CommandRunner = runCommand) {
     if (!existsSync(worktree)) throw new Error(`docs worktree missing and notes not on main: ${worktree}`);
     const land = run('bun', ['bin/elanous.mjs', 'pr', 'land', '--cwd', worktree]);
     if (land.stderr) process.stderr.write(land.stderr);
-    if (land.status === 1) return { outcome: 'fail' as const, verdict: 'fail' as const, summary: `docs land failed: ${land.stderr || land.stdout}` };
+    if (land.status === 1) return { outcome: 'fail' as const, verdict: 'fail' as const, summary: `docs land failed: ${land.stderr || land.stdout}`, docsFollow: recordFailure() };
     if (land.status !== 0 || !land.stdout.includes('✓ merge:')) throw new Error(`docs land incomplete (rc=${land.status}): ${land.stderr || land.stdout}`);
   }
+  // 착지(병합)는 이미 끝났다 — 이 뒤의 모든 실패는 후속 기록을 시도하고 원래 오류를 그대로 던진다.
   const fetch = run('git', ['fetch', 'origin', 'main']);
-  if (fetch.status !== 0) throw new Error(`docs landing fetch failed: ${fetch.stderr}`);
+  if (fetch.status !== 0) { recordFailure(); throw new Error(`docs landing fetch failed: ${fetch.stderr}`); }
   const merged = run('git', ['rev-parse', 'origin/main']);
-  if (merged.status !== 0 || !/^[0-9a-f]{40}\s*$/i.test(merged.stdout)) throw new Error(`merged main commit unavailable: ${merged.stderr}`);
-  const deployDir = mkdtempSync(join(tmpdir(), 'release-docs-deploy-'));
+  if (merged.status !== 0 || !/^[0-9a-f]{40}\s*$/i.test(merged.stdout)) { recordFailure(); throw new Error(`merged main commit unavailable: ${merged.stderr}`); }
+  let deployDir: string;
+  try { deployDir = mkdtempSync(join(tmpdir(), 'release-docs-deploy-')); }
+  catch (error) { recordFailure(); throw error; }
   const deployTree = join(deployDir, 'tree');
   let added = false;
+  let deployed = false;
   try {
     const add = run('git', ['worktree', 'add', '--detach', deployTree, merged.stdout.trim()]);
     if (add.status !== 0) throw new Error(`docs deploy worktree failed: ${add.stderr}`);
@@ -40,21 +79,41 @@ export function runDocsLand(run: CommandRunner = runCommand) {
     if (install.status !== 0) throw new Error(`docs deploy install failed: ${install.stderr}`);
     const deploy = run('bun', ['website/scripts/deploy-pages.ts', '--remote', 'node-b', '--yes'], deployTree);
     if (deploy.stderr) process.stderr.write(deploy.stderr);
-    if (deploy.status === 1) return { outcome: 'fail' as const, verdict: 'fail' as const, summary: `docs deploy failed: ${deploy.stderr || deploy.stdout}` };
+    if (deploy.status === 1) return { outcome: 'fail' as const, verdict: 'fail' as const,
+      summary: `docs deploy failed: ${deploy.stderr || deploy.stdout}`, docsFollow: recordFailure() };
     if (deploy.status !== 0) throw new Error(`docs deploy incomplete (rc=${deploy.status}): ${deploy.stderr || deploy.stdout}`);
+    deployed = true;
     if (existsSync(worktree)) {
       const remove = run('git', ['worktree', 'remove', '--force', worktree]);
       if (remove.status !== 0) throw new Error(`docs worktree cleanup failed: ${remove.stderr}`);
     }
     rmSync(scratch, { recursive: true, force: true });
-    return { outcome: 'ok' as const, verdict: 'pass' as const, summary: `docs landed and deployed v${version}` };
+    // 배포 성공 — 후속 기록 실패(manifest 없음 등)는 결과를 «실패»로 바꾸지 않는다. 알리고 넘어간다.
+    let follow: ReturnType<typeof recordFollow> | undefined;
+    try { follow = recordFollow(true); }
+    catch (error) { process.stderr.write(`docs-follow recording failed after deploy: ${String(error)}\n`); }
+    return { outcome: 'ok' as const, verdict: 'pass' as const,
+      summary: `docs landed and deployed v${version}${follow ? ` · docs-follow pending=${follow.pending} unassessed=${follow.unassessed}` : ' · docs-follow not recorded'}`,
+      docsFollow: follow };
+  } catch (error) {
+    if (!deployed) recordFailure();
+    else {
+      // 배포는 됐는데 정리에서 실패 — 보고서·MK 대기열은 «배포됨»으로 남기고 원래 오류를 보존한다.
+      try { recordFollow(true); }
+      catch (recordError) { process.stderr.write(`docs-follow recording failed: ${String(recordError)}\n`); }
+    }
+    throw error;
   } finally {
     try {
       if (added) {
         const remove = run('git', ['worktree', 'remove', '--force', deployTree]);
-        if (remove.status !== 0) throw new Error(`docs deploy cleanup failed: ${remove.stderr}`);
+        // 배포 임시 트리 정리 실패는 앞선 결과(반환·원래 오류)를 덮지 않는다 — 알리고 넘어간다.
+        if (remove.status !== 0) process.stderr.write(`docs deploy cleanup failed (kept the original result): ${remove.stderr}\n`);
       }
-    } finally { rmSync(deployDir, { recursive: true, force: true }); }
+    } finally {
+      try { rmSync(deployDir, { recursive: true, force: true }); }
+      catch (error) { process.stderr.write(`docs deploy temp cleanup failed (kept the original result): ${String(error)}\n`); }
+    }
   }
 }
 

package/scripts/release-loop/publish-node.ts

@@ -36,7 +36,7 @@ export function waitForAssets(run: CommandRunner, repo: string, tag: string, nam
   }
 }
 
-export function runPublish(run: CommandRunner = runCommand) {
+export function runPublish(run: CommandRunner = runCommand, prodFreezeRoot?: string) {
   const context = readGraphContext();
   const version = context.input.version;
   // A measured automatic decision or the existing human approval must authorize publication.
@@ -68,7 +68,7 @@ export function runPublish(run: CommandRunner = runCommand) {
     writeFileSync(file, body);
     // Same in-flight marker as merges: `freeze on` waits for a publication that already passed this check.
     // Unlike a merge, a frozen publication is not queued: it fails, and the release run is run again after `freeze off`.
-    const landing = beginLandingMerge();
+    const landing = beginLandingMerge(undefined, undefined, prodFreezeRoot);
     const frozen = landing.frozen;
     if (frozen) {
       landing.end(); // already released by beginLandingMerge when frozen; kept explicit so no path leaves a marker

package/scripts/release-loop/release-docs.ts

@@ -1,6 +1,140 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { appendSeatRequestRows, listSeatRequests, withSeatRequestLedgerLock } from '../../src/seat-dispatch/seat-request-ledger.js';
 import { debug } from '../../src/debug/log.js';
 import type { ReleaseManifest } from '../../src/release-loop/manifest.js';
 
+type DocsFollowEvidence = { location: string; verifiedAt: string; publishedAt: string };
+type DocsFollowExposure = {
+  verdict: 'public' | 'beta' | 'internal';
+  judge: 'MK';
+  rubric: string;
+  verifiedAt: string;
+};
+export type DocsFollowItem = {
+  id: string;
+  status: string;
+  sha?: string;
+  exposure?: DocsFollowExposure;
+  docs?: DocsFollowEvidence;
+  homepage?: { elanous: DocsFollowEvidence; elanvital: DocsFollowEvidence };
+  readme?: DocsFollowEvidence;
+};
+type DocsFollowCoverage = {
+  id: string;
+  sha: string | null;
+  docs: boolean;
+  homepage: boolean;
+  readme: boolean;
+  missing: Array<'docs' | 'homepage' | 'readme'>;
+};
+type DocsFollowReport = {
+  coverage: DocsFollowCoverage[];
+  pending: DocsFollowCoverage[];
+  unassessed: string[];
+  ratio: number | null;
+  verdict: 'pass' | 'fail' | 'unmeasured';
+};
+
+/** An attestation is not coverage unless it points to a measured, timestamped surface. */
+function evidenced(value: DocsFollowEvidence | undefined, measuredAt?: string): boolean {
+  const at = value?.verifiedAt ? Date.parse(value.verifiedAt) : NaN;
+  const published = value?.publishedAt ? Date.parse(value.publishedAt) : NaN;
+  return !!value?.location?.trim() && Number.isFinite(at) && Number.isFinite(published)
+    && /(?:Z|[+-]\d\d:\d\d)$/.test(value.verifiedAt)
+    && /(?:Z|[+-]\d\d:\d\d)$/.test(value.publishedAt)
+    && published <= at && (measuredAt === undefined || at <= Date.parse(measuredAt));
+}
+
+/** Unknown exposure/landing never becomes a published claim; it remains visible as an unassessed item. */
+export function calculateDocsFollow(manifest: ReleaseManifest, items: readonly DocsFollowItem[], publishedAt?: string, measuredAt?: string): DocsFollowReport {
+  const landed = new Set(manifest.in.map((entry) => entry.sha).filter(Boolean));
+  const green = items.filter((item) => item.status === 'green');
+  const ids = new Set<string>();
+  for (const item of items) {
+    if (!item.id?.trim() || ids.has(item.id)) throw new Error('invalid or duplicate docs-follow item');
+    ids.add(item.id);
+  }
+  const judged = (item: DocsFollowItem) => item.exposure?.judge === 'MK'
+    && !!item.exposure.rubric?.trim() && evidenced({ location: item.exposure.rubric, verifiedAt: item.exposure.verifiedAt,
+      publishedAt: item.exposure.verifiedAt }, measuredAt)
+    && ['public', 'beta', 'internal'].includes(item.exposure.verdict);
+  const unassessed = green.filter((item) => !judged(item) || !item.sha || !landed.has(item.sha))
+    .map((item) => item.id);
+  const supplied = new Set(items.map((item) => item.sha));
+  for (const entry of manifest.in) {
+    if (entry.sha && (entry.kind === 'feat' || entry.kind === 'fix' || entry.kind === 'security') && entry.line && !supplied.has(entry.sha)) {
+      unassessed.push(`landing:${entry.sha}`);
+    }
+  }
+  const visible = green.filter((item) => judged(item) && (item.exposure?.verdict === 'public' || item.exposure?.verdict === 'beta') && item.sha && landed.has(item.sha));
+  const coverage: DocsFollowCoverage[] = visible.map((item) => {
+    const docs = evidenced(item.docs, measuredAt);
+    const homepage = evidenced(item.homepage?.elanous, measuredAt) && evidenced(item.homepage?.elanvital, measuredAt);
+    const readme = evidenced(item.readme, measuredAt);
+    return { id: item.id, sha: item.sha!, docs, homepage, readme,
+      missing: ([['docs', docs], ['homepage', homepage], ['readme', readme]] as const)
+        .filter(([, present]) => !present).map(([surface]) => surface) };
+  });
+  const pending = coverage.filter((item) => !item.docs || !item.homepage);
+  const covered = coverage.filter((item) => item.docs && item.homepage && item.readme).length;
+  const start = publishedAt ? Date.parse(publishedAt) : NaN;
+  const end = measuredAt ? Date.parse(measuredAt) : NaN;
+  const deadline = start + 24 * 60 * 60 * 1000;
+  const validWindow = Number.isFinite(start) && Number.isFinite(end) && end >= start
+    && /(?:Z|[+-]\d\d:\d\d)$/.test(publishedAt ?? '')
+    && /(?:Z|[+-]\d\d:\d\d)$/.test(measuredAt ?? '');
+  const atDeadline = validWindow && end > deadline
+    ? calculateDocsFollow(manifest, items, publishedAt, new Date(deadline).toISOString()) : null;
+  const timely = atDeadline ?? { coverage, pending, unassessed,
+    ratio: coverage.length && !unassessed.length ? covered / coverage.length : null };
+  const pass = validWindow && timely.coverage.length > 0 && !timely.unassessed.length
+    && timely.ratio !== null && timely.ratio >= 0.8 && !timely.pending.length;
+  // Missing proof may still establish timely coverage; only a verified late publication rules it out.
+  const lateProof = (proof: DocsFollowEvidence | undefined) => evidenced(proof, measuredAt)
+    && Date.parse(proof!.publishedAt) > deadline;
+  const impossible = validWindow && end > deadline && !pass && !timely.unassessed.length
+    && visible.length > 0 && (
+      visible.some((item) => lateProof(item.docs) || lateProof(item.homepage?.elanous) || lateProof(item.homepage?.elanvital))
+      || visible.filter((item) => ![item.docs, item.homepage?.elanous, item.homepage?.elanvital, item.readme]
+        .some(lateProof)).length / visible.length < 0.8
+    );
+  return { coverage, pending, unassessed,
+    ratio: coverage.length && !unassessed.length ? covered / coverage.length : null,
+    verdict: pass ? 'pass' as const : impossible ? 'fail' as const : 'unmeasured' as const };
+}
+
+/** Persist a per-release report and queue each missing docs/home item once for MK. */
+export function recordDocsFollow(root: string, manifest: ReleaseManifest, items: readonly DocsFollowItem[], now: Date = new Date(), publishedAt?: string) {
+  if (!Number.isFinite(now.getTime())) throw new Error('invalid docs-follow time');
+  if (!/^\d+\.\d+\.\d+$/.test(manifest.version)) throw new Error('invalid docs-follow version');
+  const report = calculateDocsFollow(manifest, items, publishedAt, now.toISOString());
+  const path = join(root, 'release', manifest.version, 'docs-follow.json');
+  const journal = join(root, 'seat-requests', 'requests.jsonl');
+  withSeatRequestLedgerLock(journal, () => {
+    const known = new Set(listSeatRequests(root).map((row) => row.key));
+    const missing = [
+      ...report.pending.map((item) => ({ id: item.id, text: `문서 반영 대기 목록 v${manifest.version} · ${item.id}: ${item.missing.join(', ')} — 착지 ${item.sha}; docs·홈 실측 뒤 닫기` })),
+      ...report.unassessed.map((id) => ({ id, text: `문서 반영 대기 목록 v${manifest.version} · ${id}: 착지·green·EXPOSE-RUBRIC 근거 미판정 — 확인 전 공개 문면 금지` })),
+    ];
+    const rows = missing.filter((item) => !known.has(`docs-follow:${manifest.version}:${item.id}`)).map((item) => ({
+      key: `docs-follow:${manifest.version}:${item.id}`, seat: 'MK', status: 'queued' as const,
+      text: item.text, queuedAt: now.toISOString(), ref: `release:${manifest.version}:docs-follow`,
+    }));
+    mkdirSync(join(root, 'release', manifest.version), { recursive: true });
+    const temp = `${path}.${createHash('sha256').update(now.toISOString()).digest('hex').slice(0, 12)}.tmp`;
+    try {
+      writeFileSync(temp, JSON.stringify({ version: manifest.version, measuredAt: now.toISOString(), ...report }, null, 2) + '\n');
+      renameSync(temp, path);
+    } finally {
+      if (existsSync(temp)) unlinkSync(temp);
+    }
+    appendSeatRequestRows(journal, rows);
+  });
+  return report;
+}
+
 /** Render public IN lines only; keep private titles and PR numbers out of release notes. */
 export function renderReleaseNotes(manifest: ReleaseManifest, version: string): string {
   const sections = [

package/scripts/release-loop/version-node.ts

@@ -64,7 +64,7 @@ function shippedNextMdLines(repo: string, cut: string | undefined): { lines: Set
   return { lines: new Set(shown.stdout.split('\n').map((line) => line.trim()).filter((line) => line.startsWith('- '))) };
 }
 
-function landing(repo: string, kind: Kind, releaseVersion: string, cut?: string, cutCommit?: string): Output {
+function landing(repo: string, kind: Kind, releaseVersion: string, cut?: string, cutCommit?: string, forceFreeze = false): Output {
   const target = kind === 'release' ? releaseVersion : nextDevVersion(releaseVersion);
   const source = kind === 'release' ? `${releaseVersion}-dev.N` : releaseVersion;
   fetchMain(repo);
@@ -183,7 +183,8 @@ function landing(repo: string, kind: Kind, releaseVersion: string, cut?: string,
       }
     }
     const title = kind === 'release' ? `release: ${target}` : `version: ${target}`;
-    const land = spawnSync('bun', ['bin/elanous.mjs', 'pr', 'land', '--commit-message', title, '--title', title, '--body', `Set package.json version to ${target}.`], {
+    const land = spawnSync('bun', ['bin/elanous.mjs', 'pr', 'land', '--commit-message', title, '--title', title, '--body', `Set package.json version to ${target}.`,
+      ...(forceFreeze ? ['--force-freeze', `release run version bump ${target}`] : [])], {
       cwd: worktree, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024,
     });
     const transcript = `${land.stdout ?? ''}\n${land.stderr ?? ''}`;
@@ -211,6 +212,7 @@ function main(args: string[] = process.argv.slice(2), repo = process.cwd()): Out
   let version: string | null = null;
   let cut: string | undefined;
   let cutCommit: string | undefined;
+  let forceFreeze = false;
   try {
     if (args[0] !== 'release' && args[0] !== 'dev-bump') throw new Error('usage: version-node.ts <release|dev-bump> [--version <v>] [--cut <sha>] [--cut-commit <sha>] --json');
     kind = args[0];
@@ -224,8 +226,9 @@ function main(args: string[] = process.argv.slice(2), repo = process.cwd()): Out
     if (process.env.ELANOUS_GRAPH_CONTEXT) {
       const location = process.env.ELANOUS_GRAPH_CONTEXT;
       const context = JSON.parse(location.trimStart().startsWith('{') ? location : readFileSync(location, 'utf8')) as {
-        input?: { version?: unknown; cutCommit?: unknown }; outputs?: Record<string, { commit?: unknown } | undefined> };
+        input?: { version?: unknown; cutCommit?: unknown; forceFreeze?: unknown }; outputs?: Record<string, { commit?: unknown } | undefined> };
       if (!version && typeof context.input?.version === 'string') version = context.input.version;
+      forceFreeze = context.input?.forceFreeze === true;
       if (kind === 'release' && cutCommit === undefined && context.input?.cutCommit !== undefined) {
         if (typeof context.input.cutCommit !== 'string') throw new Error('cutCommit must be a commit SHA');
         cutCommit = context.input.cutCommit;
@@ -237,7 +240,7 @@ function main(args: string[] = process.argv.slice(2), repo = process.cwd()): Out
     if (!version) throw new Error('version required (--version or ELANOUS_GRAPH_CONTEXT.input.version)');
     nextDevVersion(version);
     if (kind === 'dev-bump' && cutCommit !== undefined) throw new Error('--cut-commit is only valid for release');
-    return landing(resolve(repo), kind, version, cut, cutCommit);
+    return landing(resolve(repo), kind, version, cut, cutCommit, forceFreeze);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     const worktree = /\[worktree: ([^\]]+)\]$/.exec(message)?.[1];

package/scripts/release-story/draft.ts

@@ -86,18 +86,25 @@ function manualTexts(dir: string): string[] {
   return texts;
 }
 
-function linkedClaims(stateDir: string, version: string, ids: Set<string>): { sentences: string[]; error?: string } {
+type StoryClaim = { id: string; sentence: string; command: string | null; firstPublicCandidate: boolean };
+
+function linkedClaims(stateDir: string, version: string, ids: Set<string>): { claims: StoryClaim[]; error?: string } {
   const ledger = new ClaimsLedger({ stateDir });
   try {
-    if (!existsSync(stateDir)) return { sentences: [], error: '상태 경로 없음' };
-    if (!statSync(stateDir).isDirectory()) return { sentences: [], error: '상태 경로가 폴더가 아님' };
-    if (!existsSync(ledger.path)) return { sentences: [], error: '원장 없음' };
-    const sentences = [...ledger.list({ status: 'verified' }), ...ledger.list({ status: 'public' })]
-      .filter((row) => ledger.get(row.id).links.some((link) => link.version === version && ids.has(link.cell)))
-      .map((row) => row.claim);
-    return { sentences };
+    if (!existsSync(stateDir)) return { claims: [], error: '상태 경로 없음' };
+    if (!statSync(stateDir).isDirectory()) return { claims: [], error: '상태 경로가 폴더가 아님' };
+    if (!existsSync(ledger.path)) return { claims: [], error: '원장 없음' };
+    const claims = [...ledger.list({ status: 'verified' }), ...ledger.list({ status: 'public' })]
+      .map((row): StoryClaim | null => {
+        const detail = ledger.get(row.id);
+        if (!detail.links.some((link) => link.version === version && ids.has(link.cell))) return null;
+        return { id: row.id, sentence: row.claim, command: detail.evidence.at(-1)?.command ?? null,
+          firstPublicCandidate: !detail.history.some((entry) => entry.event === 'publish')
+            && !detail.links.some((link) => link.version !== version && link.version !== null) };
+      }).filter((claim): claim is StoryClaim => claim !== null);
+    return { claims };
   } catch (error) {
-    return { sentences: [], error: error instanceof Error ? error.message : String(error) };
+    return { claims: [], error: error instanceof Error ? error.message : String(error) };
   }
 }
 
@@ -117,15 +124,34 @@ export function draftReleaseStory(options: DraftOptions): DraftResult {
   const candidates = green.filter((item) => !mentions.some((text) => text.includes(item.id)));
   const evidence = linkedClaims(options.stateDir ?? effectiveInstanceRoot(), version, new Set(publicCells.map((item) => item.id)));
   const changes = [...userLines, ...publicCells.map((item) => firstPhrase(item.title))];
+  const numeric = evidence.claims.find((claim) => claim.firstPublicCandidate && /\d/.test(claim.sentence) && claim.command);
+  const kindPattern = /\bnew\b|새로운|신규|새 종류/i;
+  const kindFromNext = userLines.find((line) => kindPattern.test(line));
+  const kindFromCell = publicCells.map((item) => firstPhrase(item.title)).find((line) => kindPattern.test(line));
+  const kindFromClaim = evidence.claims.find((claim) => kindPattern.test(claim.sentence));
+  const newKind = kindFromNext ? { text: kindFromNext, source: 'release/next.md', command: null }
+    : kindFromCell ? { text: kindFromCell, source: 'green 칸', command: null }
+    : kindFromClaim ? { text: kindFromClaim.sentence, source: `소구점 ${kindFromClaim.id}`, command: kindFromClaim.command } : null;
+  const card = numeric ? { kind: '첫 공개 숫자 후보', text: numeric.sentence, source: `소구점 ${numeric.id}`, command: numeric.command }
+    : newKind ? { kind: '새 종류 후보', ...newKind } : null;
   const announcement = [
-    `# ${version} 판 공지 초안`, '', '## 무엇이 달라졌나',
+    `# ${version} 판 공지 초안`, '', '## 대표 카드 · CMO 확인 전',
+    ...(card ? [`- ${card.kind}: ${card.text}`, `- 출처: ${card.source}`, `- 재측정: ${card.command ?? '확인 명령 없음 — 게시 전 확인'}`]
+      : ['- 후보 없음 — CMO가 이번 판의 대표 문장을 고른다']),
+    '- 첫 공개 여부·새 종류 여부는 앞 판의 공개 문장과 대조한 뒤 CMO가 확정한다.',
+    '', '## 무엇이 달라졌나',
     ...(changes.length ? changes.map((line) => `- ${line}`) : ['- 사용자 쪽 변경 없음']),
     '', '## 근거',
-    ...(evidence.error ? [`근거: 소구점 원장 못 읽음(${evidence.error})`] : evidence.sentences.length ? evidence.sentences.map((claim) => `- ${claim}`) : ['근거: 연결된 소구점 없음']),
+    ...(evidence.error ? [`근거: 소구점 원장 못 읽음(${evidence.error})`] : evidence.claims.length ? evidence.claims.map((claim) => `- ${claim.sentence}`) : ['근거: 연결된 소구점 없음']),
+    '', '## CMO 게시 판단 · 초안은 게시가 아니다',
+    '- 착지·출처: release/next.md와 green 칸의 공개 상태, 연결된 검증 소구점을 대조한다. 근거가 없거나 원장을 못 읽었으면 보류한다.',
+    '- 사실·톤: 숫자는 근거 명령으로 재측정하고 첫 공개·새 종류는 앞 판 공개 문장과 대조한다. 브랜드 규칙과 금지 표현을 확인한다.',
+    '- 채널·결정: 공지·사이트·매뉴얼 문장의 대상과 영어 원문을 대조하고 CMO가 게시/수정/보류와 이유를 기록한다. 실제 바깥 게시는 역할 파일의 사람 결정 관문을 따른다.',
     '',
   ].join('\n');
   const siteChanges = [...userLines, ...publicCells.map((item) => firstPhrase(item.title)).filter((title) => !/[가-힣]/.test(title))];
-  const siteNews = [`# What's new in ${version}`, '', ...siteChanges.slice(0, 3).map((line) => `- ${line}`), '', `Release: ${version}`, ''].join('\n');
+  const siteCard = card && !/[가-힣]/.test(card.text) ? [`## Lead card candidate (CMO review required)`, card.text, ''] : [];
+  const siteNews = [`# What's new in ${version}`, '', ...siteCard, ...siteChanges.slice(0, 3).map((line) => `- ${line}`), '', `Release: ${version}`, ''].join('\n');
   const manual = [`# ${version} 매뉴얼 갱신 후보`, '', ...candidates.map((item: ChecklistItem) => `- ${item.id} · ${firstPhrase(item.title)} · 매뉴얼 언급 없음`), ''].join('\n');
   const outDir = options.outDir ?? join(effectiveInstanceRoot(), 'release', version, 'story');
   mkdirSync(outDir, { recursive: true });
@@ -150,7 +176,7 @@ export function draftReleaseStory(options: DraftOptions): DraftResult {
     files.push(file);
   }
   const result: DraftResult = { version, status: 'drafted', userLines: userLines.length, internalDropped, greenCells: green.length,
-    claims: evidence.sentences.length, manualCandidates: candidates.length, brandFindings, ...(brandUnmeasured ? { brandUnmeasured } : {}), files };
+    claims: evidence.claims.length, manualCandidates: candidates.length, brandFindings, ...(brandUnmeasured ? { brandUnmeasured } : {}), files };
   debug.log('release.story', 'drafted', { version, userLines: result.userLines, internalDropped, greenCells: result.greenCells,
     claims: result.claims, manualCandidates: result.manualCandidates, brandFindings, ...(brandUnmeasured ? { brandUnmeasured } : {}) });
   return result;
@@ -161,7 +187,9 @@ export function runReleaseStory(context: GraphContext = readGraphContext(), draf
   try {
     if (context.outputs.publish?.outcome !== 'ok' || context.outputs.verify?.outcome !== 'ok')
       throw new Error('published release and verification required');
-    const result = draft({ version });
+    // 판 노트 원천은 기본이 저장소의 release/next.md — 시험·재현은 env 로 다른 파일을 준다(실제 next.md 는 판마다 비워진다).
+    const nextPath = process.env.ELANOUS_RELEASE_NEXT_PATH?.trim();
+    const result = draft({ version, ...(nextPath ? { nextPath } : {}) });
     if (result.status === 'drafted') {
       const root = effectiveInstanceRoot();
       const requestsPath = join(root, 'seat-requests', 'requests.jsonl');