elanous 0.2.16 → 0.2.18

package/samples/workflows/templates/http-poll-then-alert.yaml

@@ -0,0 +1,30 @@
+name: http-poll-then-alert
+description: |
+  Hourly HTTP poll of an upstream API. When the response diverges from
+  the last seen value, fires the notify step. Useful for status pages /
+  feature flag dashboards / blog feeds.
+
+_meta:
+  template:
+    title: HTTP poll + alert
+    description: Cron hourly → HTTP fetch → diff → notify
+    tags: [schedule, http, monitor]
+
+nodes:
+  - id: tick
+    scheduleTrigger:
+      type: interval
+      interval: 3600000
+      enabled: true
+
+  - id: probe
+    http:
+      method: GET
+      url: https://status.example.com/api/status
+      timeout: 15000
+    depends_on: [tick]
+
+  - id: alert
+    bash: |
+      echo "status: $probe.output"
+    depends_on: [probe]

package/samples/workflows/templates/manual-quickstart.yaml

@@ -0,0 +1,21 @@
+name: manual-quickstart
+description: |
+  Two-node smoke for the very first PWA user — click ▶ "Run now" and
+  see the graph light up. Echoes the arguments and exits. Modify to
+  taste once you've confirmed the editor works.
+
+_meta:
+  template:
+    title: Manual quickstart
+    description: Manual ▶ → echo → done (first-touch smoke)
+    tags: [manual, starter]
+
+nodes:
+  - id: start
+    manualTrigger:
+      description: Click ▶ Run now to fire this workflow
+
+  - id: echo
+    bash: |
+      echo "hello from monad-agent: $ARGUMENTS"
+    depends_on: [start]

package/samples/workflows/templates/scheduled-daily-digest.yaml

@@ -0,0 +1,30 @@
+name: scheduled-daily-digest
+description: |
+  Daily 9am Seoul-time digest workflow.
+  Triggers: schedule cron 0 9 * * * Asia/Seoul.
+  Does: crawls a fixed search term → omni-digest summary → saves to Obsidian.
+  Edit this template to swap the search term / Obsidian target.
+
+_meta:
+  template:
+    title: Daily digest
+    description: Cron 9am → crawl → summarize → save
+    tags: [schedule, daily, digest]
+
+nodes:
+  - id: tick
+    scheduleTrigger:
+      type: cron
+      cron: 0 9 * * *
+      timezone: Asia/Seoul
+      enabled: true
+
+  - id: crawl
+    skill: omni-crawl
+    arguments: "latest AI agent news"
+    depends_on: [tick]
+
+  - id: save
+    skill: omni-digest
+    arguments: $crawl.output
+    depends_on: [crawl]

package/samples/workflows/templates/webhook-deploy-hook.yaml

@@ -0,0 +1,27 @@
+name: webhook-deploy-hook
+description: |
+  Production deploy webhook receiver. CI posts to /hooks/deploy with
+  the build artifact id; the workflow builds, runs tests, and notifies
+  on Slack/Discord depending on result.
+
+_meta:
+  template:
+    title: Webhook deploy hook
+    description: POST /hooks/deploy → build → notify
+    tags: [webhook, deploy, ci]
+
+nodes:
+  - id: receive
+    webhookTrigger:
+      method: POST
+      path: /hooks/deploy
+
+  - id: build
+    bash: |
+      echo "building $ARGUMENTS" && sleep 1 && echo ok
+    depends_on: [receive]
+
+  - id: notify
+    bash: |
+      echo "deploy result: $build.output"
+    depends_on: [build]

package/scripts/__fixtures__/intake-news.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<rss version="2.0"><channel><title>AI타임스</title>
+<item><title><![CDATA[구글 RRSI, 하니스만 고쳐 에이전트 성능 향상]]></title><link>https://www.aitimes.com/news/articleView.html?idxno=215802</link><description><![CDATA[구글은 모델 학습 없이 코딩 에이전트의 성능을 높였다.]]></description><pubDate>Tue, 06 Oct 2026 06:00:00 GMT</pubDate></item>
+<item><title>프로야구 결승</title><link>https://www.aitimes.com/news/articleView.html?idxno=215803</link><description>올해 우승팀은 스포츠 팬들의 축하를 받았다.</description><pubDate>Tue, 06 Oct 2026 06:00:00 GMT</pubDate></item>
+<item><title>인공지능 기술 소식</title><link>https://www.aitimes.com/news/articleView.html?idxno=215804</link><description>일반적인 기술 행사 안내.</description><pubDate>Tue, 06 Oct 2026 06:00:00 GMT</pubDate></item>
+<item><title>로컬 LLM 연구</title><link>https://www.aitimes.com/news/articleView.html?idxno=215805</link><description>오래된 기사.</description><pubDate>Sun, 04 Oct 2026 06:00:00 GMT</pubDate></item>
+</channel></rss>

package/scripts/ci-public-export-import-gate.ts

@@ -88,9 +88,14 @@ export async function exportImportCheck(changedFiles: readonly string[], root: s
   const tracked = trackedFiles(root);
   if (!tracked) return { measured: false, hits: [], unseen: 0, detail: 'git ls-files 실패' };
   let included: Set<string>;
+  let present: Set<string>;
   try {
     const { loadExportConfig, selectExportFiles } = await exportSelectors();
-    included = new Set(selectExportFiles(tracked, loadExportConfig(root)));
+    const config = loadExportConfig(root);
+    included = new Set(selectExportFiles(tracked, config));
+    // An import target also exists in the export when `replace` writes a public file at that path. Only targets use
+    // this — a replaced private original is not shipped, so it is not scanned as an importer.
+    present = new Set([...included, ...Object.keys(config.replace ?? {})]);
   } catch (error) {
     return { measured: false, hits: [], unseen: 0, detail: error instanceof Error ? error.message : '매니페스트를 못 읽었다' };
   }
@@ -108,7 +113,7 @@ export async function exportImportCheck(changedFiles: readonly string[], root: s
       const resolvedSpec = resolveSpecifier(file, specifier);
       if (!resolvedSpec) return;
       const target = candidatePaths(resolvedSpec).find((candidate) => trackedSet.has(candidate));
-      if (!target || included.has(target)) return;
+      if (!target || present.has(target)) return;
       const key = `${index}\0${target}`;
       if (seen.has(key)) return;
       seen.add(key);

package/scripts/ci-typecheck-changed.ts

@@ -1032,14 +1032,29 @@ export function runGate(io: Partial<GateIo> = {}): void {
 //   ⭐ 그래서 막는 자리는 «여기»뿐이다 — 인-프로세스 호출자(`pr-cli.ts`·`seams.ts`)는
 //      argv 를 안 넘기고, 만약 여기서 `process.argv` 를 «읽으면» 형제 게이트가 경고한 그 사고가 난다
 //      (`elanous pr land` 의 인자를 자기 인자로 읽는다 — `src/cli/pr-cli.ts` 의 `args: []` 주석).
-if (import.meta.main) {
-  const cliArgs = process.argv.slice(2);
-  if (cliArgs.length > 0) {
-    console.error(`[tsc-gate] ⛔ 이 게이트는 인자를 받지 않는다 — 준 인자 ${cliArgs.length}개를 «조용히 삼키지 않고» 막는다: ${cliArgs.join(' ')}`);
+if (import.meta.main) void (async () => {
+  // GATE-REMOTE (10-06): the only accepted arguments are the dispatch flags `--remote [host]` / `--local` — they choose
+  //   «where» the same commit is measured, never «what» (the base stays merge-base(origin/main) on both sides).
+  const { extractGateRemoteFlags, dispatchHeavyCheck } = await import('../src/self-implement/gate-remote.js');
+  const flags = extractGateRemoteFlags(process.argv.slice(2));
+  const cliArgs = flags.rest;
+  if (cliArgs.length > 0 || flags.error) {
+    if (flags.error) console.error(`[tsc-gate] ⛔ ${flags.error}`);
+    if (cliArgs.length > 0) console.error(`[tsc-gate] ⛔ 이 게이트는 인자를 받지 않는다(--remote/--local 제외) — 준 인자 ${cliArgs.length}개를 «조용히 삼키지 않고» 막는다: ${cliArgs.join(' ')}`);
     console.error('[tsc-gate]   기준은 언제나 merge-base(origin/main) 다. 다른 기준으로 재려면 «그 트리에 서서» 돌려라:');
     console.error('[tsc-gate]     git worktree add --detach <경로> <커밋> && cd <경로> && bun run scripts/ci-typecheck-changed.ts');
     console.error('[tsc-gate]   ⇒ 그러면 merge-base 가 그때와 «같아진다». 이것이 재현의 유일한 길이다.');
     process.exit(2);
   }
-  runGate();
-}
+  const repo = sh('git rev-parse --show-toplevel').trim();
+  const baseRef = process.env.TSC_BASE_REF;
+  const passEnv = (sha: (ref: string) => string) => (['NODE_OPTIONS', 'TSC_BASE_REF', 'TSC_HEAP_MB'] as const).filter((key) => process.env[key])
+    .map((key) => `${key}=${key === 'TSC_BASE_REF' && baseRef !== 'origin/main' ? sha(baseRef!) : process.env[key]}`);
+  // exitCode, not exit(): piped stdout/stderr drain before the process ends.
+  process.exitCode = await dispatchHeavyCheck({
+    tool: 'ci-typecheck-changed', repo, flags,
+    remoteArgv: (sha) => { const vars = passEnv(sha); return [...(vars.length ? ['env', ...vars] : []), 'bun', 'run', 'scripts/ci-typecheck-changed.ts', '--local']; },
+    refs: baseRef ? [baseRef] : [],
+    runLocal: () => { runGate(); return 0; },
+  });
+})();

package/scripts/discord-seat-probe.ts

@@ -56,7 +56,8 @@ export async function probeDiscordSeatWork(text: string, options: ProbeOptions =
       open: () => { const db = new Database(':memory:'); return { db, close: () => db.close() } as unknown as MsgStore; },
       dispatch: async (seatId, forwarded) => {
         capture('ask', seatId, forwarded);
-        return { channel: 'unknown', reply: '마른 실행 — 질문을 맡기지 않았습니다.' };
+        // Since #24523 a seat *task* also travels this ask path (so the answer can come back) — the wording covers both.
+        return { channel: 'unknown', reply: `마른 실행 — ${seatId}에 맡길 예정 (실제 맡김 없음).` };
       },
       send: async () => { throw new Error('dry Discord delivery unavailable'); },
     },
@@ -76,7 +77,7 @@ export async function probeDiscordSeatWork(text: string, options: ProbeOptions =
       ...options.liveDeps?.askDeps,
       dispatch: async (seatId, forwarded, deps, extra) => {
         capture('ask', seatId, forwarded);
-        return (options.liveDeps?.askDeps?.dispatch ?? dispatchCeoTask)(seatId, forwarded, deps, extra);
+        return (options.liveDeps?.askDeps?.dispatch ?? options.liveDeps?.dispatch ?? dispatchCeoTask)(seatId, forwarded, deps, extra);
       },
       // This CLI has no Discord transport: even live mode must not post to Discord.
       send: async () => { throw new Error('probe does not send Discord messages'); },

package/scripts/docs/generate-cli-anatomy.ts

@@ -0,0 +1,162 @@
+#!/usr/bin/env bun
+/** DOC-GEN — src/cli/ 의 정적 Commander 명령을 실행 없이 TypeScript AST 로 읽는다. */
+import { mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import ts from 'typescript';
+import { readCommit } from './generate-graph-anatomy.js';
+
+export interface RenderCliAnatomyInput {
+  readonly cliRoot: string;
+  readonly repoRoot: string;
+  readonly commit: string;
+  readonly generatedAt: string;
+}
+
+interface CommandRow {
+  readonly name: string;
+  readonly description: string;
+  readonly file: string;
+}
+
+function propertyCall(expression: ts.Expression, method: string): expression is ts.CallExpression & { expression: ts.PropertyAccessExpression } {
+  return ts.isCallExpression(expression) && ts.isPropertyAccessExpression(expression.expression)
+    && expression.expression.name.text === method;
+}
+
+function literal(expression: ts.Expression | undefined): string | undefined {
+  return expression && (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression))
+    ? expression.text : undefined;
+}
+
+function descriptionOf(command: ts.CallExpression): string {
+  let current: ts.Expression = command;
+  while (ts.isPropertyAccessExpression(current.parent) && current.parent.expression === current
+    && ts.isCallExpression(current.parent.parent) && current.parent.parent.expression === current.parent) {
+    const property = current.parent;
+    const call = current.parent.parent;
+    if (property.name.text === 'description') return literal(call.arguments[0]) ?? '';
+    if (property.name.text === 'command') break;
+    current = call;
+  }
+  return '';
+}
+
+function rowsInFile(source: string, file: string): CommandRow[] {
+  const ast = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  interface Scope {
+    readonly owner: ts.Node;
+    readonly parent?: Scope;
+    readonly bindings: Map<string, ts.VariableDeclaration | null>;
+  }
+  const scopes = new Map<ts.Node, Scope>();
+  const gather = (node: ts.Node, outer?: Scope): void => {
+    const createsScope = ts.isSourceFile(node) || ts.isBlock(node) || ts.isModuleBlock(node)
+      || ts.isCaseBlock(node) || ts.isCatchClause(node) || ts.isFunctionLike(node)
+      || ts.isForStatement(node) || ts.isForInStatement(node) || ts.isForOfStatement(node);
+    const scope: Scope = createsScope ? { owner: node, parent: outer, bindings: new Map() } : outer!;
+    scopes.set(node, scope);
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+      const list = node.parent;
+      const isVar = ts.isVariableDeclarationList(list) && (list.flags & ts.NodeFlags.BlockScoped) === 0;
+      let target = scope;
+      if (isVar) {
+        while (target.parent && !ts.isSourceFile(target.owner) && !ts.isFunctionLike(target.owner)) {
+          target = target.parent;
+        }
+      }
+      target.bindings.set(node.name.text, node);
+    }
+    if (ts.isFunctionLike(node)) {
+      for (const parameter of node.parameters) {
+        if (ts.isIdentifier(parameter.name)) scope.bindings.set(parameter.name.text, null);
+      }
+    }
+    if (ts.isCatchClause(node) && node.variableDeclaration && ts.isIdentifier(node.variableDeclaration.name)) {
+      scope.bindings.set(node.variableDeclaration.name.text, null);
+    }
+    ts.forEachChild(node, (child) => gather(child, scope));
+  };
+  gather(ast);
+
+  const commandName = (expression: ts.Expression, seen: ReadonlySet<ts.VariableDeclaration> = new Set()): string => {
+    if (ts.isParenthesizedExpression(expression)) return commandName(expression.expression, seen);
+    if (ts.isIdentifier(expression)) {
+      let scope = scopes.get(expression);
+      while (scope && !scope.bindings.has(expression.text)) scope = scope.parent;
+      const declaration = scope?.bindings.get(expression.text);
+      if (!declaration || !declaration.initializer || seen.has(declaration)) return '';
+      return commandName(declaration.initializer, new Set([...seen, declaration]));
+    }
+    if (propertyCall(expression, 'command')) {
+      const name = literal(expression.arguments[0]);
+      if (name === undefined) return '';
+      const parent = commandName(expression.expression.expression, seen);
+      return parent ? `${parent} ${name}` : name;
+    }
+    if (ts.isCallExpression(expression) && ts.isPropertyAccessExpression(expression.expression)) {
+      return commandName(expression.expression.expression, seen);
+    }
+    return '';
+  };
+
+  const rows: CommandRow[] = [];
+  const visit = (node: ts.Node): void => {
+    if (ts.isCallExpression(node) && propertyCall(node, 'command')) {
+      const name = literal(node.arguments[0]);
+      if (name !== undefined) rows.push({ name: commandName(node), description: descriptionOf(node), file });
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(ast);
+  return rows;
+}
+
+function cell(value: string): string {
+  return value.replace(/\|/g, '\\|').replace(/\r?\n/g, ' ');
+}
+
+/** 지정된 src/cli/ 바로 아래 .ts 만 읽으며 import/명령을 실행하지 않는다. */
+export function renderCliAnatomy(input: RenderCliAnatomyInput): string {
+  const rows = readdirSync(input.cliRoot, { withFileTypes: true })
+    .filter((entry) => entry.isFile() && entry.name.endsWith('.ts')
+      && !entry.name.endsWith('.test.ts') && !entry.name.endsWith('.spec.ts'))
+    .flatMap((entry) => {
+      const abs = join(input.cliRoot, entry.name);
+      return rowsInFile(readFileSync(abs, 'utf8'), relative(input.repoRoot, abs).replace(/\\/g, '/'));
+    })
+    .sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : a.file < b.file ? -1 : a.file > b.file ? 1 : 0);
+  return [
+    '# CLI anatomy',
+    '',
+    '> 이 문서는 생성물이다 — 손으로 고치지 마라',
+    '',
+    `- generatedAt: ${input.generatedAt}`,
+    `- commit: ${input.commit}`,
+    '',
+    '| 명령 | 설명 | 정의 파일 |',
+    '| --- | --- | --- |',
+    ...rows.map((row) => `| ${cell(row.name)} | ${cell(row.description)} | ${cell(row.file)} |`),
+    '',
+  ].join('\n');
+}
+
+export function defaultOutputPath(repoRoot: string): string {
+  return join(repoRoot, 'docs', 'generated', 'cli-anatomy.md');
+}
+
+function main(): void {
+  const repoRoot = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+  const argv = process.argv.slice(2);
+  const index = argv.indexOf('--out');
+  const outArg = index < 0 ? undefined : argv[index + 1];
+  if (index >= 0 && (!outArg || outArg.startsWith('--'))) throw new Error('--out 에는 경로가 필요하다');
+  const out = outArg ?? defaultOutputPath(repoRoot);
+  const markdown = renderCliAnatomy({ cliRoot: join(repoRoot, 'src', 'cli'), repoRoot,
+    commit: readCommit(repoRoot), generatedAt: new Date().toISOString() });
+  mkdirSync(dirname(out), { recursive: true });
+  writeFileSync(out, markdown);
+  process.stdout.write(`${out}\n`);
+}
+
+if (import.meta.main) main();

package/scripts/goals/authoring-metrics.ts

@@ -0,0 +1,73 @@
+#!/usr/bin/env bun
+import { readFileSync } from 'node:fs';
+import { inspectAskMarkers } from '../ask-marker-check.js';
+
+export interface AuthoringMeasurement {
+  readonly path: string;
+  readonly chars: number;
+  readonly bytes: number;
+  readonly sections: number;
+  readonly markerAxes: number;
+  readonly markerFailed: number;
+}
+
+type UnreadableMeasurement = { readonly path: string; readonly error: 'unreadable' };
+type AuthoringRow = AuthoringMeasurement | UnreadableMeasurement;
+
+export function measureAuthoring(path: string, text: string): AuthoringMeasurement {
+  const axes = inspectAskMarkers(text);
+  return {
+    path,
+    chars: text.length,
+    bytes: Buffer.byteLength(text, 'utf8'),
+    sections: text.split(/\r?\n/).filter((line) => /^#{1,6}\s/u.test(line)).length,
+    markerAxes: axes.length,
+    markerFailed: axes.filter((axis) => !(axis.marker && axis.extracted)).length,
+  };
+}
+
+export function median(numbers: readonly number[]): number | null {
+  if (numbers.length === 0) return null;
+  const sorted = [...numbers].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 1
+    ? sorted[middle]!
+    : (sorted[middle - 1]! + sorted[middle]!) / 2;
+}
+
+function main(argv: readonly string[]): number {
+  const json = argv.includes('--json');
+  const paths = argv.filter((argument) => argument !== '--json');
+  const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+  const rows: AuthoringRow[] = paths.map((path) => {
+    let text: string;
+    try {
+      text = decoder.decode(readFileSync(path));
+    } catch {
+      return { path, error: 'unreadable' };
+    }
+    return measureAuthoring(path, text);
+  });
+  const measured = rows.filter((row): row is AuthoringMeasurement => !('error' in row));
+  const summary = {
+    files: measured.length,
+    medianChars: median(measured.map((row) => row.chars)),
+    medianBytes: median(measured.map((row) => row.bytes)),
+  };
+
+  if (json) {
+    for (const row of rows) console.log(JSON.stringify(row));
+    console.log(JSON.stringify(summary));
+  } else {
+    console.log('path\tchars\tbytes\tsections\tmarkerAxes\tmarkerFailed\terror');
+    for (const row of rows) {
+      console.log('error' in row
+        ? `${row.path}\t\t\t\t\t\t${row.error}`
+        : `${row.path}\t${row.chars}\t${row.bytes}\t${row.sections}\t${row.markerAxes}\t${row.markerFailed}\t`);
+    }
+    console.log(`files\t${summary.files}\tmedianChars\t${summary.medianChars ?? '—'}\tmedianBytes\t${summary.medianBytes ?? '—'}`);
+  }
+  return rows.some((row) => 'error' in row) ? 1 : 0;
+}
+
+if (import.meta.main) process.exitCode = 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/landing-heal/must-fix-match.ts

@@ -1,4 +1,4 @@
-import { parse } from '../../src/agent-substrate/pr-comment-meta.js';
+import { expandRecords, parse } from '../../src/agent-substrate/pr-comment-meta.js';
 
 export type MustFixVerdict = 'resolved' | 'unresolved' | 'unknown';
 export interface ReviewRoundMatch {
@@ -12,12 +12,12 @@ export interface ReviewRoundMatch {
 const MUST_FIX_ROUND = /^Round \d+: reviewer requested \d+ must-fix change\(s\)\.$/m;
 
 export function classifyReviewRounds(comments: Array<{ body?: string }>): ReviewRoundMatch[] {
-  const reviews = comments.flatMap(({ body }) => {
-    if (!body) return [];
-    const meta = parse(body);
-    return meta?.role === 'reviewer' && meta.run && meta.round !== undefined
-      ? [{ body, run: meta.run, round: meta.round }] : [];
-  });
+  const reviews = comments.flatMap(({ body }) =>
+    body ? expandRecords(body).flatMap((record) => {
+      const meta = parse(record);
+      return meta?.role === 'reviewer' && meta.run && meta.round !== undefined
+        ? [{ body: record, run: meta.run, round: meta.round }] : [];
+    }) : []);
   // 항목은 «must-fix 요청» 라운드에서만 센다 — «review completed (warn)» 의 요약 본문에도 «- » 글머리가 들어 있다(#21983 실물).
   return reviews.flatMap(({ body, run, round }) => !MUST_FIX_ROUND.test(body) ? [] :
     [...body.matchAll(/^- (.+)$/gm)].map((item) => ({