elanous 0.2.0 → 0.2.5

package/src/intake-plane/collect-github.ts

@@ -0,0 +1,258 @@
+// 흡수 입력원 I3 — GitHub star 급상승 저장소를 읽기만 해 흡수 원장에 넣는다.
+// 네트워크(`gh api search/repositories`)는 주입 함수 하나로 감싼다. 시험은 그 함수를 가짜로 바꾼다.
+import { appendFileSync, mkdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { debug } from '../debug/log.js';
+import { ingestIntakeItems, intakeLedgerDir, type IngestResult, type RawIntakeItem } from './items.js';
+
+/** 한 판에 열 번 안쪽 — 검색 API 비율 제한(인증 시 분당 30회)을 시험 밖에서 상수로 묶는다. */
+export const GITHUB_STAR_QUERIES = [
+  'topic:ai-agents',
+  'topic:llm-agent',
+  'topic:coding-agent',
+  'topic:mcp',
+  'topic:video-generation',
+  '"ai agent" in:name,description',
+] as const;
+
+/** `--days` 기본. 최근 이 일수 안에 만들어졌거나 푸시된 저장소만 받는다. */
+export const DEFAULT_GITHUB_STAR_DAYS = 30;
+
+/**
+ * `--per-query` 기본. 질의마다 별 순 상위 이 개수만 받는다.
+ * 검색 API 한 페이지(최대 100)보다 작게 잡아 한 판의 응답을 한 호출로 끝낸다.
+ */
+export const DEFAULT_GITHUB_STAR_PER_QUERY = 20;
+
+export interface GithubStarRepo {
+  fullName: string;
+  url: string;
+  description: string;
+  stars: number;
+  createdAt: string;
+  pushedAt: string;
+}
+
+/** 질의 하나 → 저장소 목록. 실제 구현은 `gh api` · 시험은 가짜. */
+export type SearchGithubRepos = (query: string, perQuery: number) => Promise<GithubStarRepo[]>;
+
+export interface StarSnapshot { day: string; repo: string; stars: number }
+
+export interface GithubStarSignals {
+  stars: number;
+  starsDelta?: number;
+  starsPerDay?: number;
+}
+
+export interface CollectGithubQueryCount { query: string; received: number }
+
+export interface CollectGithubRepoRow {
+  repo: string;
+  url: string;
+  title: string;
+  text: string;
+  stars: number;
+  starsDelta?: number;
+  starsPerDay?: number;
+}
+
+export interface CollectGithubResult {
+  day: string;
+  days: number;
+  perQuery: number;
+  dryRun: boolean;
+  queries: CollectGithubQueryCount[];
+  repos: CollectGithubRepoRow[];
+  raws: number;
+  ingest?: IngestResult;
+}
+
+export function githubStarsFile(root: string): string {
+  return join(intakeLedgerDir(root), 'github-stars.jsonl');
+}
+
+export function readStarSnapshots(root: string): StarSnapshot[] {
+  try {
+    const text = readFileSync(githubStarsFile(root), 'utf8');
+    const out: StarSnapshot[] = [];
+    for (const line of text.split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        const o = JSON.parse(line) as StarSnapshot;
+        if (o && typeof o.repo === 'string' && typeof o.day === 'string' && Number.isFinite(o.stars)) out.push(o);
+      } catch { /* 깨진 줄은 건너뛴다 */ }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+
+/** 같은 저장소의 직전 스냅숏 — 오늘보다 앞선 날 중 가장 최근. 없으면 undefined. */
+export function precedingSnapshot(snaps: readonly StarSnapshot[], repo: string, day: string): StarSnapshot | undefined {
+  let best: StarSnapshot | undefined;
+  for (const s of snaps) {
+    if (s.repo !== repo || s.day >= day) continue;
+    if (!best || s.day > best.day) best = s;
+  }
+  return best;
+}
+
+function utcDay(iso: string): string {
+  const t = Date.parse(iso);
+  if (!Number.isFinite(t)) return '';
+  return new Date(t).toISOString().slice(0, 10);
+}
+
+function daysBetween(earlierDay: string, laterDay: string): number {
+  const a = Date.parse(`${earlierDay}T00:00:00.000Z`);
+  const b = Date.parse(`${laterDay}T00:00:00.000Z`);
+  if (!Number.isFinite(a) || !Number.isFinite(b)) return 0;
+  return Math.round((b - a) / 86_400_000);
+}
+
+/** 최근 `days` 일 안에 만들어졌거나 푸시됐으면 참. 날짜를 못 읽으면 버린다. */
+export function isRecentRepo(repo: Pick<GithubStarRepo, 'createdAt' | 'pushedAt'>, day: string, days: number): boolean {
+  const windowStart = new Date(Date.parse(`${day}T00:00:00.000Z`) - days * 86_400_000).toISOString().slice(0, 10);
+  const created = utcDay(repo.createdAt);
+  const pushed = utcDay(repo.pushedAt);
+  return (created !== '' && created >= windowStart) || (pushed !== '' && pushed >= windowStart);
+}
+
+/**
+ * 직전 스냅숏이 있으면 증가량과 하루당 증가를 싣는다. 없으면 두 칸을 두지 않는다(0 으로 채우지 않는다).
+ * 같은 날이면 분모는 1 로 둔다 — 0 으로 나누지 않는다.
+ */
+export function signalsFromSnapshot(stars: number, prev: StarSnapshot | undefined, day: string): GithubStarSignals {
+  if (!prev) return { stars };
+  const span = Math.max(1, daysBetween(prev.day, day));
+  const starsDelta = stars - prev.stars;
+  return { stars, starsDelta, starsPerDay: starsDelta / span };
+}
+
+function appendSnapshots(root: string, rows: StarSnapshot[]): void {
+  if (!rows.length) return;
+  mkdirSync(intakeLedgerDir(root), { recursive: true });
+  appendFileSync(githubStarsFile(root), rows.map((r) => JSON.stringify(r)).join('\n') + '\n');
+}
+
+function dedupeRepos(found: readonly GithubStarRepo[]): GithubStarRepo[] {
+  const byName = new Map<string, GithubStarRepo>();
+  for (const repo of found) {
+    const key = repo.fullName.toLowerCase();
+    if (!key || byName.has(key)) continue;
+    byName.set(key, repo);
+  }
+  return [...byName.values()];
+}
+
+export interface CollectGithubOpts {
+  days?: number;
+  perQuery?: number;
+  dryRun?: boolean;
+  /** 스냅숏·비교의 «오늘». 생략하면 UTC 날짜. */
+  day?: string;
+  now?: () => Date;
+}
+
+/**
+ * 관심 주제 질의마다 별 순 검색을 부르고, 최근 창 안의 저장소만 남긴 뒤 질의 사이에서 중복을 없앤다.
+ * 저장소마다 오늘 별 수 스냅숏을 덧붙이고, 직전 스냅숏과 비교한 신호를 원장에 넣는다.
+ * dryRun 이면 스냅숏·원장을 바꾸지 않는다.
+ */
+export async function collectGithubStars(
+  root: string,
+  search: SearchGithubRepos,
+  opts: CollectGithubOpts = {},
+): Promise<CollectGithubResult> {
+  const days = Math.max(1, opts.days ?? DEFAULT_GITHUB_STAR_DAYS);
+  const perQuery = Math.max(1, opts.perQuery ?? DEFAULT_GITHUB_STAR_PER_QUERY);
+  const day = opts.day ?? (opts.now ?? (() => new Date()))().toISOString().slice(0, 10);
+  const queries: CollectGithubQueryCount[] = [];
+  const found: GithubStarRepo[] = [];
+  // «급상승»은 최근에 생긴 저장소 중 별 순이다 — 전체 기간 별 순이면 활발한 거대 저장소가 매일 같은 목록으로 나온다(2026-09-26 검토).
+  const windowStart = new Date(Date.parse(`${day}T00:00:00.000Z`) - days * 86_400_000).toISOString().slice(0, 10);
+  for (const query of GITHUB_STAR_QUERIES) {
+    const rows = await search(`${query} created:>=${windowStart}`, perQuery);
+    const recent = rows.filter((r) => isRecentRepo(r, day, days));
+    queries.push({ query, received: recent.length });
+    found.push(...recent);
+  }
+  const unique = dedupeRepos(found);
+  const prior = readStarSnapshots(root);
+  const repos: CollectGithubRepoRow[] = unique.map((repo) => {
+    const prev = precedingSnapshot(prior, repo.fullName, day);
+    const signals = signalsFromSnapshot(repo.stars, prev, day);
+    return {
+      repo: repo.fullName,
+      url: repo.url,
+      title: repo.fullName,
+      text: repo.description,
+      stars: signals.stars,
+      ...(signals.starsDelta !== undefined ? { starsDelta: signals.starsDelta } : {}),
+      ...(signals.starsPerDay !== undefined ? { starsPerDay: signals.starsPerDay } : {}),
+    };
+  });
+  const raws: RawIntakeItem[] = repos.map((row) => ({
+    url: row.url,
+    title: row.title,
+    text: row.text,
+    signals: {
+      stars: row.stars,
+      ...(row.starsDelta !== undefined ? { starsDelta: row.starsDelta } : {}),
+      ...(row.starsPerDay !== undefined ? { starsPerDay: row.starsPerDay } : {}),
+    },
+  }));
+  const result: CollectGithubResult = {
+    day, days, perQuery, dryRun: !!opts.dryRun, queries, repos, raws: raws.length,
+  };
+  if (!opts.dryRun) {
+    appendSnapshots(root, repos.map((row) => ({ day, repo: row.repo, stars: row.stars })));
+    result.ingest = ingestIntakeItems(root, 'github', raws);
+  }
+  debug.log('intake.collect', 'github-stars', {
+    day, days, perQuery, queries: queries.length, repos: repos.length, dryRun: !!opts.dryRun,
+  });
+  return result;
+}
+
+interface GhSearchItem {
+  full_name?: string;
+  html_url?: string;
+  description?: string | null;
+  stargazers_count?: number;
+  created_at?: string;
+  pushed_at?: string;
+}
+
+/** `gh api search/repositories` 를 `sort=stars` 로 한 번 부른다. */
+export const ghApiSearchRepos: SearchGithubRepos = async (query, perQuery) => {
+  const perPage = Math.min(100, Math.max(1, perQuery));
+  const q = `${query} sort:stars`;
+  const out = execFileSync('gh', [
+    'api',
+    '-X', 'GET',
+    'search/repositories',
+    '-f', `q=${q}`,
+    '-f', 'sort=stars',
+    '-f', 'order=desc',
+    '-f', `per_page=${perPage}`,
+    '--jq', '.items',
+  ], { encoding: 'utf8', timeout: 30_000 });
+  const items = JSON.parse(out) as GhSearchItem[];
+  if (!Array.isArray(items)) return [];
+  const repos: GithubStarRepo[] = [];
+  for (const item of items) {
+    if (!item.full_name || !item.html_url) continue;
+    repos.push({
+      fullName: item.full_name,
+      url: item.html_url,
+      description: item.description ?? '',
+      stars: Number(item.stargazers_count ?? 0),
+      createdAt: item.created_at ?? '',
+      pushedAt: item.pushed_at ?? '',
+    });
+  }
+  return repos.slice(0, perQuery);
+};

package/src/intake-plane/collect-pod.ts

@@ -0,0 +1,100 @@
+import { randomUUID } from 'node:crypto';
+import { closeSync, existsSync, linkSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { resolveObsidianRoot } from '../acp/fs-roots.js';
+import { debug } from '../debug/log.js';
+import { assertVaultWriteAllowed } from '../obsidian/vault-write-guard.js';
+import { loadIntakeLedger, markIntakeItem } from './items.js';
+
+export interface CollectPodResult {
+  outcome: 'absorbed' | 'failed' | 'conflict' | 'invalid';
+  note?: string;
+  reason?: string;
+}
+
+type PodResult = { ok: true; url: string; note: string; rc: number } | { ok: false; url: string; rc: number; log: string };
+
+function validResult(value: unknown): value is PodResult {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const v = value as Record<string, unknown>;
+  if (typeof v.url !== 'string' || !v.url || typeof v.rc !== 'number' || !Number.isInteger(v.rc)) return false;
+  if (v.ok === true) return typeof v.note === 'string';
+  if (v.ok === false) return typeof v.log === 'string' && v.log.length > 0;
+  return false;
+}
+
+function validNote(note: string): boolean {
+  return note.length > 0 && !isAbsolute(note) && !note.startsWith('\\') && !note.includes('\\')
+    && note.endsWith('.md') && note.split('/').every((part) => part !== '' && part !== '.' && part !== '..');
+}
+
+function inside(path: string, root: string): boolean {
+  const rel = relative(root, path);
+  return rel === '' || (rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
+}
+
+/** Collect one Pod absorb artifact. Dry-run reports the outcome a write would have had, without writes. */
+export function collectPodAbsorb(root: string, opts: { dir: string; id: string; vaultRoot?: string; dryRun?: boolean; now?: string }): CollectPodResult {
+  const finish = (result: CollectPodResult): CollectPodResult => {
+    debug.log('intake.collect-pod', 'collected', { id: opts.id, outcome: result.outcome });
+    return result;
+  };
+  let result: unknown;
+  try { result = JSON.parse(readFileSync(join(opts.dir, 'result.json'), 'utf8')); }
+  catch { return finish({ outcome: 'invalid', reason: 'result.json missing or malformed' }); }
+  if (!validResult(result)) return finish({ outcome: 'invalid', reason: 'result.json shape' });
+  if (!loadIntakeLedger(root).items.has(opts.id)) return finish({ outcome: 'invalid', reason: 'id not in ledger' });
+  if (!result.ok) {
+    if (!opts.dryRun) markIntakeItem(root, opts.id, { status: 'deferred' }, opts.now);
+    return finish({ outcome: 'failed', reason: String(result.rc) });
+  }
+  if (!validNote(result.note)) return finish({ outcome: 'invalid', reason: 'invalid note path' });
+  const sourceRoot = resolve(opts.dir, 'vault');
+  const source = resolve(sourceRoot, result.note);
+  const vaultRoot = resolve(opts.vaultRoot ?? resolveObsidianRoot().root);
+  const abs = resolve(vaultRoot, result.note);
+  if (!inside(source, sourceRoot) || !inside(abs, vaultRoot)) return finish({ outcome: 'invalid', reason: 'invalid note path' });
+  try {
+    if (!statSync(source).isFile() || !inside(realpathSync(sourceRoot), realpathSync(opts.dir))
+      || !inside(realpathSync(source), realpathSync(sourceRoot))) {
+      return finish({ outcome: 'invalid', reason: 'note source missing or outside artifacts' });
+    }
+  } catch { return finish({ outcome: 'invalid', reason: 'note source missing or outside artifacts' }); }
+  // A pre-existing destination, including a broken symlink, is always a conflict.
+  try { lstatSync(abs); return finish({ outcome: 'conflict', note: abs }); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+  }
+  // Resolve existing ancestors before any write; reject symlinks that redirect outside the vault.
+  const existingParent = (path: string): string => existsSync(path) ? path : existingParent(dirname(path));
+  const anchor = existingParent(vaultRoot);
+  const vaultAnchor = realpathSync(anchor);
+  const parent = existingParent(dirname(abs));
+  if (!inside(realpathSync(parent), vaultAnchor)) {
+    return finish({ outcome: 'invalid', reason: 'destination outside vault' });
+  }
+  // Dry-run checks the guard too, but does not create directories, files or ledger entries.
+  assertVaultWriteAllowed(abs);
+  if (opts.dryRun) return finish({ outcome: 'absorbed', note: abs });
+  mkdirSync(dirname(abs), { recursive: true });
+  if (!inside(realpathSync(dirname(abs)), realpathSync(vaultRoot))) return finish({ outcome: 'invalid', reason: 'destination outside vault' });
+  const temp = join(dirname(abs), `.collect-pod-${randomUUID()}.tmp`);
+  const fd = openSync(temp, 'wx', 0o600);
+  try {
+    writeFileSync(fd, readFileSync(source));
+    closeSync(fd);
+    // Reserve the name without overwrite, then atomically replace only our own reservation.
+    assertVaultWriteAllowed(abs);
+    try { linkSync(temp, abs); }
+    catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'EEXIST') return finish({ outcome: 'conflict', note: abs });
+      throw error;
+    }
+    renameSync(temp, abs);
+  } finally {
+    try { closeSync(fd); } catch { /* already closed */ }
+    if (existsSync(temp)) unlinkSync(temp);
+  }
+  markIntakeItem(root, opts.id, { status: 'absorbed', output: { kind: 'note', ref: abs } }, opts.now);
+  return finish({ outcome: 'absorbed', note: abs });
+}

package/src/intake-plane/collect-telegram-saved.ts

@@ -0,0 +1,91 @@
+// 흡수 입력원 I4 — 텔레그램 «저장된 메시지»(me 대화)를 읽기만 한다. RFC-regular-external-intake §2 · §3.4 · §8-1.
+// ⛔ 사용자 세션은 계정 전체 권한이다(읽기 전용 토큰이 없다). 그래서 이 모듈은 `me` 대화 «읽기» 하나만 부르고,
+//    보내기·지우기 경로를 import 하지 않는다 · 호스트 전용(Pod 에 주입하지 않는다) · 관측엔 커서·건수만 남긴다.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { ingestIntakeItems, intakeLedgerDir, type IngestResult, type RawIntakeItem } from './items.js';
+
+export interface SavedMessage { id: number; date: string; text: string; urls: string[] }
+
+/** 커서 이후(id > minId)의 저장된 메시지를 오래된 것부터 최대 limit 개. 실제 구현은 GramJS · 시험은 가짜. */
+export type FetchSavedMessages = (minId: number, limit: number) => Promise<SavedMessage[]>;
+
+const URL_RE = /https?:\/\/[^\s<>"')\]]+/g;
+
+/** 메시지 한 개 → 원장 입력 줄. 링크가 있으면 링크마다 한 줄(메모 문장은 text 로) · 없으면 메모 한 줄. */
+export function savedMessageToRaws(m: SavedMessage): RawIntakeItem[] {
+  const urls = [...new Set([...m.urls, ...(m.text.match(URL_RE) ?? [])].map((u) => u.replace(/[.,;:!?]+$/, '')))];
+  const memo = m.text.replace(URL_RE, ' ').replace(/\s+/g, ' ').trim();
+  if (urls.length === 0) return memo ? [{ text: memo, kind: 'note', observedAt: m.date }] : [];
+  return urls.map((url) => ({ url, ...(memo ? { text: memo } : {}), observedAt: m.date }));
+}
+
+function cursorFile(root: string): string { return join(intakeLedgerDir(root), 'telegram-saved.cursor.json'); }
+
+export function readSavedCursor(root: string): number {
+  try { return Number(JSON.parse(readFileSync(cursorFile(root), 'utf8')).lastId) || 0; } catch { return 0; }
+}
+
+/** When the cursor last moved (= a run last found a new saved message). Undefined before the first message. */
+export function readSavedCursorAt(root: string): string | undefined {
+  try { const at = JSON.parse(readFileSync(cursorFile(root), 'utf8')).at; return typeof at === 'string' ? at : undefined; } catch { return undefined; }
+}
+
+function writeSavedCursor(root: string, lastId: number): void {
+  mkdirSync(intakeLedgerDir(root), { recursive: true });
+  writeFileSync(cursorFile(root), JSON.stringify({ lastId, at: new Date().toISOString() }) + '\n');
+}
+
+export interface CollectSavedResult { cursorBefore: number; cursorAfter: number; messages: number; raws: number; dryRun: boolean; ingest?: IngestResult }
+
+/**
+ * 커서 이후 메시지를 한 번에 최대 max 개 읽어 원장에 넣고 커서를 옮긴다.
+ * 첫 판(커서 0)은 가장 오래된 것부터 — 쌓인 링크를 하루 max 개씩 따라잡는다.
+ * dryRun 이면 원장·커서를 바꾸지 않는다.
+ */
+export async function collectTelegramSaved(root: string, fetch: FetchSavedMessages, opts: { max: number; dryRun?: boolean }): Promise<CollectSavedResult> {
+  const cursorBefore = readSavedCursor(root);
+  const messages = await fetch(cursorBefore, opts.max);
+  const raws = messages.flatMap(savedMessageToRaws);
+  const cursorAfter = messages.reduce((mx, m) => Math.max(mx, m.id), cursorBefore);
+  const result: CollectSavedResult = { cursorBefore, cursorAfter, messages: messages.length, raws: raws.length, dryRun: !!opts.dryRun };
+  if (!opts.dryRun) {
+    result.ingest = ingestIntakeItems(root, 'telegram-saved', raws);
+    if (cursorAfter > cursorBefore) writeSavedCursor(root, cursorAfter);
+  }
+  // ⛔ 본문·링크는 싣지 않는다 — 커서와 건수만.
+  debug.log('intake.collect', 'telegram-saved', { cursorBefore, cursorAfter, messages: messages.length, raws: raws.length, dryRun: !!opts.dryRun });
+  return result;
+}
+
+/** GramJS 사용자 세션으로 `me` 대화를 읽는 실제 구현. 자격이 없으면 이유를 담아 던진다(값은 싣지 않는다). */
+export async function gramjsFetchSaved(env: NodeJS.ProcessEnv = process.env): Promise<{ fetch: FetchSavedMessages; close: () => Promise<void> }> {
+  const apiId = Number(env.TELEGRAM_API_ID ?? 0);
+  const apiHash = env.TELEGRAM_API_HASH ?? '';
+  const session = env.TELEGRAM_USER_SESSION ?? '';
+  const missing = [!apiId && 'TELEGRAM_API_ID', !apiHash && 'TELEGRAM_API_HASH', !session && 'TELEGRAM_USER_SESSION'].filter(Boolean);
+  if (missing.length) throw new Error(`텔레그램 사용자 세션 자격이 없다: ${missing.join(' · ')} (docs/manual/MANUAL-telegram-unmanned-test-2026-07-21.md §1~§3)`);
+  const { TelegramClient } = await import('telegram');
+  const { StringSession } = await import('telegram/sessions');
+  const client = new TelegramClient(new StringSession(session), apiId, apiHash, { connectionRetries: 3 });
+  client.setLogLevel('error' as never);   // 연결 로그가 표준출력을 채우지 않게
+  await client.connect();
+  const fetch: FetchSavedMessages = async (minId, limit) => {
+    const msgs = await client.getMessages('me', { reverse: true, minId, limit });
+    return msgs.map((m) => {
+      const text = String(m.message ?? '');
+      const urls: string[] = [];
+      for (const e of (m.entities ?? []) as { className?: string; url?: string; offset?: number; length?: number }[]) {
+        if (e.className === 'MessageEntityTextUrl' && e.url) urls.push(e.url);
+        else if (e.className === 'MessageEntityUrl' && e.offset != null && e.length != null) urls.push(text.slice(e.offset, e.offset + e.length));
+      }
+      const webpage = (m.media as { webpage?: { url?: string } } | undefined)?.webpage?.url;
+      if (webpage) urls.push(webpage);
+      return { id: m.id, date: new Date((m.date ?? 0) * 1000).toISOString(), text, urls };
+    });
+  };
+  return { fetch, close: async () => { await client.disconnect(); } };
+}
+
+export function hasSavedCursor(root: string): boolean { return existsSync(cursorFile(root)); }

package/src/intake-plane/digest.ts

@@ -0,0 +1,111 @@
+// 흡수 하루 다이제스트 — 그날 흡수한 것을 사람이 «발견»하는 자리. 노트 절(마크다운) ⊕ 텔레그램 짧은 판.
+// 결정론만: 요약 한 줄은 각 노트가 이미 쓴 「한 줄 결론」을 뽑는다(LLM 을 다시 부르지 않는다).
+import { existsSync, readFileSync } from 'node:fs';
+import { basename, join, relative } from 'node:path';
+import { loadIntakeLedger, type IntakeItem } from './items.js';
+import { readSavedCursorAt } from './collect-telegram-saved.js';
+import { intakeOutboxDir, kstDay } from './route.js';
+
+export interface DigestEntry { id: string; sources: string[]; url?: string; note?: string; noteName?: string; oneLiner?: string; axis: string }
+export interface IntakeDigest { day: string; absorbed: DigestEntry[]; goals: { fact: string; url?: string }[]; review?: { fact: string; note?: string }[]; grounding: number; release: number; manual: number; savedSilence?: { days: number; lastNewAt: string } }
+
+const AXIS_LABEL: Record<string, string> = {
+  video_automation: '영상 자동화', agent_basics: '에이전트 기본', agent_applied: '에이전트 응용', unrelated: '그 밖',
+};
+
+/** 노트에서 요약 한 줄 — 「한 줄 결론」/「한줄 결론」 표지 다음의 첫 문장. 없으면 frontmatter·제목 뒤 첫 문단. */
+export function noteOneLiner(md: string): string | undefined {
+  const body = md.replace(/^---\n[\s\S]*?\n---\n?/, '');
+  const lines = body.split('\n');
+  const clean = (l: string) => l.replace(/^[#>*\-\s]+/, '').replace(/\*\*/g, '').replace(/\s{2,}$/, '').trim();
+  const i = lines.findIndex((l) => /한\s?줄\s?결론/.test(l));
+  if (i >= 0) {
+    const inline = clean(lines[i].split(/한\s?줄\s?결론\**\s*[:：]?/)[1] ?? '');
+    if (inline.length > 10) return inline.slice(0, 220);
+    for (const l of lines.slice(i + 1)) { const c = clean(l); if (c) return c.slice(0, 220); }
+  }
+  for (const l of lines) {
+    const c = clean(l);
+    if (c && !l.startsWith('#') && !/^(원문|참조|출처)/.test(c) && !c.startsWith('http')) return c.slice(0, 220);
+  }
+  return undefined;
+}
+
+function readJsonl(file: string): Record<string, unknown>[] {
+  if (!existsSync(file)) return [];
+  return readFileSync(file, 'utf8').split('\n').filter(Boolean).flatMap((l) => { try { return [JSON.parse(l)]; } catch { return []; } });
+}
+
+/** `day`(KST YYYY-MM-DD)에 흡수·갈래가 끝난 항목과 그날의 산출 큐를 모은다. */
+/** Saved Messages silent for more than two days → the digest says so (a quiet 0 must not look like «nothing to do»). */
+const SAVED_SILENCE_MS = 48 * 3600_000;
+
+export function buildIntakeDigest(root: string, day: string, readFile: (p: string) => string | undefined = (p) => (existsSync(p) ? readFileSync(p, 'utf8') : undefined), now: Date = new Date()): IntakeDigest {
+  const items = [...loadIntakeLedger(root).items.values()]
+    .filter((i) => (i.status === 'absorbed' || i.status === 'routed') && kstDay(i.lastSeenAt) === day && i.outputs.some((o) => o.kind === 'note'));
+  const absorbed = items.map((i: IntakeItem): DigestEntry => {
+    const note = [...i.outputs].reverse().find((o) => o.kind === 'note')?.ref;
+    const md = note ? readFile(note) : undefined;
+    return {
+      id: i.id, sources: i.sources, ...(i.url ? { url: i.url } : {}),
+      ...(note ? { note, noteName: basename(note, '.md') } : {}),
+      ...(md ? { oneLiner: noteOneLiner(md) } : {}),
+      axis: AXIS_LABEL[i.judgement?.axis ?? i.axis ?? ''] ?? (i.sources.includes('telegram-saved') ? '내가 저장한 것' : '그 밖'),
+    };
+  });
+  const out = intakeOutboxDir(root);
+  const goals = readJsonl(join(out, 'goals', `${day}.jsonl`)).map((g) => ({ fact: String(g.fact ?? ''), ...(g.url ? { url: String(g.url) } : {}) }));
+  const review = readJsonl(join(out, 'review', `${day}.jsonl`)).map((r) => ({ fact: String(r.fact ?? ''), ...(r.note ? { note: String(r.note) } : {}) }));
+  const grounding = readJsonl(join(out, 'grounding.jsonl')).filter((g) => typeof g.at === 'string' && kstDay(g.at) === day).length;
+  const lastNewAt = readSavedCursorAt(root);
+  const silentMs = lastNewAt ? now.getTime() - Date.parse(lastNewAt) : NaN;
+  return {
+    day, absorbed, goals, review, grounding,
+    release: readJsonl(join(out, 'release', `${day}.jsonl`)).length,
+    manual: readJsonl(join(out, 'manual', `${day}.jsonl`)).length,
+    ...(lastNewAt && silentMs > SAVED_SILENCE_MS ? { savedSilence: { days: Math.floor(silentMs / 86_400_000), lastNewAt } } : {}),
+  };
+}
+
+/** 노트 절 — 축별 묶음 · 노트 링크 · 한 줄 요약 · 골 후보. */
+export function renderDigestMarkdown(d: IntakeDigest): string {
+  const L: string[] = [`## 📰 오늘의 흡수 요약 (${d.absorbed.length})`, ''];
+  if (d.savedSilence) L.push(`> ⚠️ 텔레그램 «저장된 메시지»에서 새 글을 ${d.savedSilence.days}일째 못 받았다(마지막 새 글 수집 ${kstDay(d.savedSilence.lastNewAt)}) — 저장했는데 안 들어왔다면 저장한 곳(본인 «저장된 메시지»인지)을 확인한다.`, '');
+  if (!d.absorbed.length) { L.push('오늘 흡수한 것이 없다.', ''); return L.join('\n'); }
+  const byAxis = new Map<string, DigestEntry[]>();
+  for (const e of d.absorbed) (byAxis.get(e.axis) ?? byAxis.set(e.axis, []).get(e.axis)!).push(e);
+  for (const [axis, rows] of byAxis) {
+    L.push(`### ${axis} (${rows.length})`, '');
+    for (const e of rows) L.push(`- ${e.noteName ? `[[${e.noteName}]]` : e.url ?? e.id} — ${e.oneLiner ?? '(요약 줄 없음)'}`);
+    L.push('');
+  }
+  if (d.goals.length) {
+    L.push(`### 🔴 엘라누스에 없는 것 — 골 후보 (${d.goals.length})`, '');
+    for (const g of d.goals.slice(0, 10)) L.push(`- ${g.fact}${g.url ? ` · [원본](${g.url})` : ''}`);
+    L.push('');
+  }
+  if (d.review?.length) {
+    L.push(`### 🟡 사람이 가를 것 — 판단 필요 (${d.review.length})`, '', '> 근거가 실행 코드에 닿지만 «같은 것인가»는 결정론으로 못 가른다 — 노트의 🧭 절에서 판단한다.', '');
+    for (const r of d.review.slice(0, 10)) L.push(`- ${r.fact}${r.note ? ` · [[${basename(r.note, '.md')}]]` : ''}`);
+    if (d.review.length > 10) L.push(`- … 외 ${d.review.length - 10}건`);
+    L.push('');
+  }
+  L.push(`> 매뉴얼 후보 ${d.manual} · 릴리스 노트 맥락 ${d.release} · 그라운딩 후보 ${d.grounding} — 흡수 원장 \`elanous intake items\` · 큐 \`<인스턴스>/intake/outbox/\``, '');
+  return L.join('\n');
+}
+
+/** 텔레그램 짧은 판 — 수 · 한 줄 요약 다섯 · 골 후보 · 노트 자리. */
+export function renderDigestTelegram(d: IntakeDigest, opts: { vaultRoot?: string; notePath?: string } = {}): string {
+  const L = [`📰 *${d.day} 흡수 ${d.absorbed.length}편*`];
+  if (d.savedSilence) L.push(`⚠️ 저장된 메시지 새 글 ${d.savedSilence.days}일째 0 — 저장한 곳 확인`);
+  for (const e of d.absorbed.slice(0, 5)) L.push(`• ${e.oneLiner ?? e.noteName ?? e.url ?? e.id}`);
+  if (d.absorbed.length > 5) L.push(`… 외 ${d.absorbed.length - 5}편`);
+  if (d.goals.length) L.push('', `🔴 엘라누스에 없는 것 ${d.goals.length}건 — 골 후보`);
+  if (d.review?.length) L.push(`${d.goals.length ? '' : '\n'}🟡 사람이 가를 것 ${d.review.length}건 — 노트 🧭 절`);
+  if (opts.vaultRoot && opts.notePath) {
+    const vault = basename(opts.vaultRoot);
+    const file = relative(opts.vaultRoot, opts.notePath).replace(/\.md$/, '');
+    L.push('', `📂 obsidian://open?vault=${encodeURIComponent(vault)}&file=${encodeURIComponent(file)}`);
+  }
+  return L.join('\n');
+}

package/src/intake-plane/enrich-plugins.ts

@@ -152,7 +152,7 @@ async function productionFetchUrl(
   try {
     const res = await fetch(url, {
       headers: {
-        'user-agent': 'elanous-intake-enrich/1.0 (+https://github.com/ElanvitalAI/monad)',
+        'user-agent': 'elanous-intake-enrich/1.0 (+https://github.com/ElanvitalAI/elanous)',
         accept: 'text/html, text/plain;q=0.9, */*;q=0.5',
       },
       signal: ctrl.signal,

package/src/intake-plane/front-classifier.ts

@@ -0,0 +1,56 @@
+import { debug } from '../debug/log.js';
+import { detectUrlRoute, extractUrls, type UrlRouteDecision, type UrlRoutingConfig } from '../skills/url-router.js';
+import { decideIntakeFrontRoute, INTAKE_FRONT_IMPLEMENT_WORDS, type DecideIntakeFrontRouteInput, type IntakeFrontRouteDecision } from './front-route-rules.js';
+
+export const INTAKE_FRONT_QUESTION_WORDS = [
+  '뭐', '무엇', '어떻게', '왜', '언제', '어디', '누구', '몇', '어느', '할까', '인가요',
+  'what', 'how', 'why', 'when', 'where', 'who', 'which',
+] as const;
+
+type FrontInputKind = 'link' | 'instruction' | 'list' | 'question' | 'memo';
+
+export interface FrontClassifierInput extends DecideIntakeFrontRouteInput {
+  surface: 'pwa' | 'pwa-chat' | 'telegram' | 'tui' | 'external';
+}
+
+export interface FrontClassifierDecision extends IntakeFrontRouteDecision {
+  kind: FrontInputKind;
+  urlRoute: UrlRouteDecision | null;
+}
+
+const QUESTION_WORD_RE = new RegExp(
+  `(?:${INTAKE_FRONT_QUESTION_WORDS.map((word) => /^[a-z]+$/i.test(word) ? `(?<![\\p{L}\\p{N}_])${word}(?![\\p{L}\\p{N}_])` : word).join('|')})[.!?。？！]*$`,
+  'iu',
+);
+const IMPLEMENT_WORD_RE = new RegExp(INTAKE_FRONT_IMPLEMENT_WORDS.join('|'), 'iu');
+
+export function classifyFrontInput(
+  input: FrontClassifierInput,
+  deps: { urlRouting: UrlRoutingConfig },
+): FrontClassifierDecision {
+  const { text, surface, hint, consent } = input;
+  const route = decideIntakeFrontRoute({ text, hint, consent });
+  const urlRoute = detectUrlRoute(text, deps.urlRouting);
+  const trimmed = text.trim();
+  const urls = extractUrls(text);
+  const kind: FrontInputKind = route.reason === 'imperative-implement' || route.reason === 'url-implement'
+    || (urls.length > 0 && IMPLEMENT_WORD_RE.test(text.replace(/https?:\/\/\S+/gi, ' ')))
+    ? 'instruction'
+    : urls.length > 0
+      ? 'link'
+      : route.reason === 'list'
+        ? 'list'
+        : /[?？]$/.test(trimmed) || QUESTION_WORD_RE.test(trimmed)
+          ? 'question'
+          : 'memo';
+
+  debug.log('intake.front-classifier', 'classified', {
+    surface,
+    kind,
+    track: route.track,
+    urlKind: urlRoute?.kind ?? null,
+    textLength: text.length,
+  });
+
+  return { ...route, kind, urlRoute };
+}