elanous 0.2.15 → 0.2.17

package/scripts/docs-cli-check.ts

@@ -2,7 +2,7 @@
 // 공개 문서에 적힌 `elanous …` 명령·하위 명령·플래그가 «실제 CLI» 에 있나 — 문서가 실제와 어긋나는 1순위 원인을 잡는다.
 //   bun scripts/docs-cli-check.ts [--json] [files…]      (기본 = release/public/내부 문서 `*` ⊕ README.md)
 // 🩸 계기(2026-09-25 🅢 RFC 피드백 ③): README·install.md 가 거짓이 된 원인이 전부 «설치기·doctor 가 바뀌었는데 문서가 모름»이었다.
-// 자 = `bun bin/elanous.mjs <cmd> [<sub>] [<subsub>] --help` 산출(원천) — 문서의 코드 블록과 인라인 코드에서 `elanous ` 로 시작하는 것만 본다.
+// 자 = `bun bin/elanous.mjs <cmd> [<sub>] [<subsub>] --help` 산출(원천) — 문서의 코드 블록과 인라인 코드에서 `elanous ` 또는 `bun bin/elanous.mjs ` 로 시작하는 것만 본다.
 // ⛔ 못 본 것은 «없다»로 적지 않는다: `--help` 가 실패하면 그 명령은 `unmeasured` 로 따로 센다.
 import { readdirSync, readFileSync, statSync } from 'node:fs';
 import { join, relative, resolve } from 'node:path';
@@ -21,10 +21,10 @@ export function extractElanousCommands(file: string, text: string): DocCommand[]
     if (/^\s*(```|~~~)/.test(raw)) { inFence = !inFence; return; }
     const candidates: string[] = [];
     if (inFence) candidates.push(raw.replace(/#.*$/, ''));
-    for (const m of raw.matchAll(/`(elanous [^`]+)`/g)) candidates.push(m[1]!);
+    for (const m of raw.matchAll(/`((?:bun bin\/elanous\.mjs |elanous )[^`]+)`/g)) candidates.push(m[1]!);
     for (const c of candidates) {
       for (const seg of c.split(/&&|\|\||;|\|/)) {
-        const m = /^(?:(?:\$\s+|>\s+|sudo\s+|[A-Za-z_][A-Za-z0-9_]*=\S+\s+))*elanous\s+(.+)$/.exec(seg.trim());
+        const m = /^(?:(?:\$\s+|>\s+|sudo\s+|[A-Za-z_][A-Za-z0-9_]*=\S+\s+))*(?:bun bin\/elanous\.mjs |elanous\s+)(.+)$/.exec(seg.trim());
         if (!m) continue;
         const tokens = m[1]!.trim().split(/\s+/).filter(Boolean);
         const cmd = tokens[0];
@@ -86,7 +86,7 @@ export function checkCommands(refs: readonly DocCommand[], help: HelpRunner = de
       }
     }
     for (const f of ref.flags) {
-      if (!new RegExp(`(^|[\\s,])${f}(\\b|[\\s,=<\\[])`, 'm').test(flagsHelp)) findings.push({ kind: 'unknown-flag', ref, detail: `${f} (${flagsPath})` });
+      if (!new RegExp(`(^|[\\s,])${f.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(\\b|[\\s,=<\\[])`, 'm').test(flagsHelp)) findings.push({ kind: 'unknown-flag', ref, detail: `${f} (${flagsPath})` });
     }
   }
   return findings;

package/scripts/goals/goal-census.ts

@@ -0,0 +1,343 @@
+#!/usr/bin/env bun
+/**
+ * GOAL-LIFE① — docs/goals 전수 분류(이관 전 측정).
+ *
+ * GitHub API·gh 를 부르지 않는다. git 이력과 파일 시스템만 읽고,
+ * docs/goals 아래 어떤 파일도 쓰지 않는다.
+ *
+ *   bun scripts/goals/goal-census.ts [--json] [--out <path>]
+ */
+import { spawnSync } from 'node:child_process';
+import { readdirSync, statSync, writeFileSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+import { debug } from '../../src/debug/log.js';
+
+export type GoalKind = 'GOAL' | 'ASK' | 'other';
+export type GoalClass = 'landed' | 'untracked' | 'tracked-no-pr';
+
+export interface GoalCensusEntry {
+  readonly path: string;
+  readonly classification: GoalClass;
+  readonly kind: GoalKind;
+  readonly bytes: number;
+  /** 추가 날짜 YYYY-MM-DD (KST). 미추적이면 파일 mtime. */
+  readonly addedDateKst: string;
+  readonly prNumber?: number;
+  readonly addCommit?: string;
+}
+
+export interface GoalCensusSummary {
+  readonly total: number;
+  readonly byClass: Record<GoalClass, number>;
+  readonly byKind: Record<GoalKind, number>;
+  readonly matrix: Record<GoalClass, Record<GoalKind, number>>;
+  readonly bytes: number;
+  readonly bytesByClass: Record<GoalClass, number>;
+  /** 월별 추가 수 — YYYY-MM (KST). */
+  readonly addedByMonth: Record<string, number>;
+}
+
+export interface GoalCensus {
+  readonly entries: readonly GoalCensusEntry[];
+  readonly summary: GoalCensusSummary;
+}
+
+export interface AddedCommit {
+  readonly hash: string;
+  readonly subject: string;
+  /** git %aI — ISO 8601 with offset. */
+  readonly authoredAt: string;
+}
+
+export interface CensusGoalsInput {
+  readonly repoRoot: string;
+  /** 경로(repo 상대, posix) → 그 파일을 처음 추가한 커밋. 없으면 미추적. */
+  readonly gitLog: (repoRoot: string) => ReadonlyMap<string, AddedCommit>;
+  /** repo 상대 미추적 경로. */
+  readonly listUntracked: (repoRoot: string) => readonly string[];
+  /** 테스트·대체 루트. 기본 docs/goals. */
+  readonly goalsDir?: string;
+}
+
+const CLASSES: readonly GoalClass[] = ['landed', 'untracked', 'tracked-no-pr'];
+const KINDS: readonly GoalKind[] = ['GOAL', 'ASK', 'other'];
+
+const PR_AT_END = /\(#(\d+)\)\s*$/;
+
+export function classifyKind(relPath: string): GoalKind {
+  const base = relPath.split('/').pop() ?? relPath;
+  if (base.startsWith('GOAL')) return 'GOAL';
+  if (base.startsWith('ASK')) return 'ASK';
+  return 'other';
+}
+
+export function prNumberFromSubject(subject: string): number | undefined {
+  const m = subject.match(PR_AT_END);
+  return m ? Number(m[1]) : undefined;
+}
+
+/** UTC ISO(또는 offset 포함) → KST YYYY-MM-DD. */
+export function kstDate(iso: string): string {
+  const t = Date.parse(iso);
+  if (Number.isNaN(t)) return iso.slice(0, 10);
+  const kst = new Date(t + 9 * 60 * 60 * 1000);
+  const y = kst.getUTCFullYear();
+  const m = String(kst.getUTCMonth() + 1).padStart(2, '0');
+  const d = String(kst.getUTCDate()).padStart(2, '0');
+  return `${y}-${m}-${d}`;
+}
+
+function emptyMatrix(): Record<GoalClass, Record<GoalKind, number>> {
+  const matrix = {} as Record<GoalClass, Record<GoalKind, number>>;
+  for (const c of CLASSES) {
+    matrix[c] = { GOAL: 0, ASK: 0, other: 0 };
+  }
+  return matrix;
+}
+
+function measureEntry(repoRoot: string, rel: string): { bytes: number; mtimeIso: string; files: string[] } {
+  const abs = resolve(repoRoot, rel);
+  const root = resolve(repoRoot);
+  try {
+    const st = statSync(abs);
+    if (!st.isDirectory()) return { bytes: st.size, mtimeIso: st.mtime.toISOString(), files: [rel] };
+    const files: string[] = [];
+    walkFiles(abs, root, files);
+    let bytes = 0;
+    for (const f of files) {
+      try { bytes += statSync(resolve(repoRoot, f)).size; } catch { /* skip missing */ }
+    }
+    return { bytes, mtimeIso: st.mtime.toISOString(), files };
+  } catch {
+    return { bytes: 0, mtimeIso: new Date(0).toISOString(), files: [] };
+  }
+}
+
+function earliestAddition(added: ReadonlyMap<string, AddedCommit>, prefix: string): AddedCommit | undefined {
+  let best: AddedCommit | undefined;
+  for (const [p, c] of added) {
+    if (!p.startsWith(prefix)) continue;
+    if (!best || c.authoredAt < best.authoredAt) best = c;
+  }
+  return best;
+}
+
+function walkFiles(dir: string, root: string, out: string[]): void {
+  let names: string[];
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    if (name === '.git') continue;
+    const abs = join(dir, name);
+    let st;
+    try {
+      st = statSync(abs);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory()) walkFiles(abs, root, out);
+    else if (st.isFile()) out.push(relative(root, abs).split('\\').join('/'));
+  }
+}
+
+/**
+ * `ls docs/goals` 와 같은 최상위 이름(파일·디렉터리 각 1).
+ * 디렉터리의 크기·착지 근거는 그 아래 파일을 모아 정한다.
+ */
+export function listGoalFiles(repoRoot: string, goalsDir = 'docs/goals'): string[] {
+  const abs = resolve(repoRoot, goalsDir);
+  let names: string[];
+  try {
+    names = readdirSync(abs);
+  } catch {
+    return [];
+  }
+  return names.filter((n) => n !== '.' && n !== '..').map((n) => `${goalsDir}/${n}`).sort();
+}
+
+export function summarize(entries: readonly GoalCensusEntry[]): GoalCensusSummary {
+  const byClass = { landed: 0, untracked: 0, 'tracked-no-pr': 0 } as Record<GoalClass, number>;
+  const byKind = { GOAL: 0, ASK: 0, other: 0 } as Record<GoalKind, number>;
+  const matrix = emptyMatrix();
+  const bytesByClass = { landed: 0, untracked: 0, 'tracked-no-pr': 0 } as Record<GoalClass, number>;
+  const addedByMonth: Record<string, number> = {};
+  let bytes = 0;
+  for (const e of entries) {
+    byClass[e.classification] += 1;
+    byKind[e.kind] += 1;
+    matrix[e.classification][e.kind] += 1;
+    bytesByClass[e.classification] += e.bytes;
+    bytes += e.bytes;
+    const month = e.addedDateKst.slice(0, 7);
+    addedByMonth[month] = (addedByMonth[month] ?? 0) + 1;
+  }
+  return { total: entries.length, byClass, byKind, matrix, bytes, bytesByClass, addedByMonth };
+}
+
+export function censusGoals(input: CensusGoalsInput): GoalCensus {
+  const goalsDir = input.goalsDir ?? 'docs/goals';
+  const prefix = goalsDir.endsWith('/') ? goalsDir : `${goalsDir}/`;
+  const files = listGoalFiles(input.repoRoot, goalsDir);
+  const added = input.gitLog(input.repoRoot);
+  const untracked = new Set(input.listUntracked(input.repoRoot).map((p) => p.split('\\').join('/')));
+
+  const entries: GoalCensusEntry[] = [];
+  for (const path of files) {
+    if (!path.startsWith(prefix)) continue;
+    const kind = classifyKind(path);
+    const measured = measureEntry(input.repoRoot, path);
+    const { bytes, mtimeIso } = measured;
+    const commit = added.get(path) ?? earliestAddition(added, `${path}/`);
+    const nestedUntracked = measured.files.length > 0
+      && measured.files.every((f) => untracked.has(f) || !added.has(f));
+    if (!commit || untracked.has(path) || nestedUntracked) {
+      entries.push({
+        path,
+        classification: 'untracked',
+        kind,
+        bytes,
+        addedDateKst: kstDate(mtimeIso),
+      });
+      continue;
+    }
+    const prNumber = prNumberFromSubject(commit.subject);
+    if (prNumber !== undefined) {
+      entries.push({
+        path,
+        classification: 'landed',
+        kind,
+        bytes,
+        addedDateKst: kstDate(commit.authoredAt),
+        prNumber,
+        addCommit: commit.hash,
+      });
+    } else {
+      entries.push({
+        path,
+        classification: 'tracked-no-pr',
+        kind,
+        bytes,
+        addedDateKst: kstDate(commit.authoredAt),
+        addCommit: commit.hash,
+      });
+    }
+  }
+  return { entries, summary: summarize(entries) };
+}
+
+/**
+ * 파일을 처음 추가한 커밋만. `git log --diff-filter=A` 한 번.
+ * 최신→과거 순이므로 같은 경로가 다시 나오면 나중 값(최초 추가)이 이긴다.
+ */
+export function gitLogAdditions(repoRoot: string, goalsDir = 'docs/goals'): Map<string, AddedCommit> {
+  const r = spawnSync(
+    'git',
+    [
+      '-C', repoRoot,
+      'log',
+      '--diff-filter=A',
+      '--name-only',
+      '--format=@@%H%x09%s%x09%aI',
+      '--',
+      goalsDir,
+    ],
+    { encoding: 'utf8', maxBuffer: 512 * 1024 * 1024 },
+  );
+  if (r.status !== 0) {
+    throw new Error(`git log failed: ${(r.stderr || '').trim()}`);
+  }
+  const out = new Map<string, AddedCommit>();
+  let current: AddedCommit | undefined;
+  for (const line of r.stdout.split('\n')) {
+    if (!line) continue;
+    if (line.startsWith('@@')) {
+      const body = line.slice(2);
+      const tab = body.indexOf('\t');
+      const tab2 = body.lastIndexOf('\t');
+      if (tab > 0 && tab2 > tab) {
+        current = {
+          hash: body.slice(0, tab),
+          subject: body.slice(tab + 1, tab2),
+          authoredAt: body.slice(tab2 + 1),
+        };
+      }
+      continue;
+    }
+    if (current) out.set(line, current);
+  }
+  return out;
+}
+
+/** 작업 트리의 미추적 파일. `git ls-files --others --exclude-standard`. */
+export function gitListUntracked(repoRoot: string, goalsDir = 'docs/goals'): string[] {
+  const r = spawnSync(
+    'git',
+    ['-C', repoRoot, 'ls-files', '--others', '--exclude-standard', '--', goalsDir],
+    { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 },
+  );
+  if (r.status !== 0) {
+    throw new Error(`git ls-files failed: ${(r.stderr || '').trim()}`);
+  }
+  return r.stdout.split('\n').filter((p) => p.length > 0);
+}
+
+export function formatSummary(census: GoalCensus): string {
+  const { summary } = census;
+  const lines: string[] = [];
+  lines.push(`total ${summary.total}  bytes ${summary.bytes}`);
+  lines.push('class × kind');
+  const header = ['class', ...KINDS, 'bytes'].join('\t');
+  lines.push(header);
+  for (const c of CLASSES) {
+    const row = [
+      c,
+      ...KINDS.map((k) => String(summary.matrix[c][k])),
+      String(summary.bytesByClass[c]),
+    ];
+    lines.push(row.join('\t'));
+  }
+  lines.push('added by month (KST)');
+  const months = Object.keys(summary.addedByMonth).sort();
+  for (const month of months) lines.push(`${month}\t${summary.addedByMonth[month]}`);
+  return lines.join('\n') + '\n';
+}
+
+function parseArgs(argv: readonly string[]): { json: boolean; out?: string } {
+  let json = false;
+  let out: string | undefined;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--json') json = true;
+    else if (a === '--out') {
+      out = argv[i + 1];
+      i += 1;
+    } else if (a.startsWith('--out=')) out = a.slice('--out='.length);
+  }
+  return { json, out };
+}
+
+function main(argv: readonly string[]): void {
+  const repoRoot = resolve(import.meta.dir, '../..');
+  const args = parseArgs(argv);
+  const census = censusGoals({
+    repoRoot,
+    gitLog: (root) => gitLogAdditions(root),
+    listUntracked: (root) => gitListUntracked(root),
+  });
+  const { summary } = census;
+  debug.log('goals.census', 'scanned', {
+    total: summary.total,
+    landed: summary.byClass.landed,
+    untracked: summary.byClass.untracked,
+    trackedNoPr: summary.byClass['tracked-no-pr'],
+    bytes: summary.bytes,
+  });
+  const body = args.json ? JSON.stringify(census, null, 2) + '\n' : formatSummary(census);
+  if (args.out) writeFileSync(args.out, body);
+  process.stdout.write(body);
+}
+
+if (import.meta.main) main(process.argv.slice(2));

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/measure/author-section-contribution.ts

@@ -0,0 +1,84 @@
+import { Database } from 'bun:sqlite';
+import { readFileSync } from 'node:fs';
+
+export interface AuthorSummary {
+  authorRunId: string;
+  sectionChars: Record<string, number>;
+}
+
+export interface AssignedGoalEvent {
+  category: string;
+  event: string;
+  ts: string;
+  data: { authorRunId?: string; goalId?: string };
+}
+
+export interface ExecutionRun {
+  runId: string;
+  goalId: string;
+  startedAt: string;
+  outcome: string;
+}
+
+export interface SectionContribution {
+  authorRunId: string;
+  goalId: string;
+  runId: string;
+  section: string;
+  chars: number;
+  outcome: string;
+}
+
+/** Join an authored summary to the first execution starting after that author's assignment. */
+export function measureAuthorSectionContribution(
+  summaries: readonly AuthorSummary[],
+  events: readonly AssignedGoalEvent[],
+  runs: readonly ExecutionRun[],
+): SectionContribution[] {
+  const rows: SectionContribution[] = [];
+  for (const summary of summaries) {
+    const assignment = events.filter((event) => event.category === 'goal-author'
+      && event.event === 'goal-id-assigned'
+      && event.data?.authorRunId === summary.authorRunId
+      && typeof event.data.goalId === 'string'
+      && Number.isFinite(Date.parse(event.ts)))
+      .sort((left, right) => Date.parse(left.ts) - Date.parse(right.ts)
+        || left.data.goalId!.localeCompare(right.data.goalId!))[0];
+    if (!assignment) continue;
+    const assignedAt = Date.parse(assignment.ts);
+    const run = runs.filter((candidate) => candidate.goalId === assignment.data.goalId
+      && Number.isFinite(Date.parse(candidate.startedAt))
+      && Date.parse(candidate.startedAt) >= assignedAt)
+      .sort((left, right) => Date.parse(left.startedAt) - Date.parse(right.startedAt)
+        || left.runId.localeCompare(right.runId))[0];
+    if (!run) continue;
+    for (const [section, chars] of Object.entries(summary.sectionChars)) {
+      rows.push({ authorRunId: summary.authorRunId, goalId: run.goalId, runId: run.runId, section, chars, outcome: run.outcome });
+    }
+  }
+  return rows;
+}
+
+function readRunLedger(path: string): ExecutionRun[] {
+  const db = new Database(path, { readonly: true });
+  try {
+    const records = db.query('SELECT run_id, goal_id, doc FROM goal_run').all() as Array<{ run_id: string; goal_id: string; doc: string }>;
+    return records.map(({ run_id, goal_id, doc }) => {
+      const record = JSON.parse(doc) as { startedAt: string; outcome: string };
+      return { runId: run_id, goalId: goal_id, startedAt: record.startedAt, outcome: record.outcome };
+    });
+  } finally {
+    db.close();
+  }
+}
+
+if (import.meta.main) {
+  const [summaryFile, eventsFile, ledgerFile] = process.argv.slice(2);
+  if (!summaryFile || !eventsFile || !ledgerFile) throw new Error('usage: bun scripts/measure/author-section-contribution.ts <summaries.json> <events.jsonl> <goal-runs.db>');
+  const summaries = JSON.parse(readFileSync(summaryFile, 'utf8')) as AuthorSummary[];
+  const events = readFileSync(eventsFile, 'utf8').split('\n').filter(Boolean).map((line) => JSON.parse(line) as AssignedGoalEvent);
+  const rows = measureAuthorSectionContribution(summaries, events, readRunLedger(ledgerFile));
+  console.log('| authorRunId | goalId | runId | section | chars | outcome |');
+  console.log('| --- | --- | --- | --- | ---: | --- |');
+  for (const row of rows) console.log(`| ${row.authorRunId} | ${row.goalId} | ${row.runId} | ${row.section} | ${row.chars} | ${row.outcome} |`);
+}