elanous 0.2.14 → 0.2.16

package/src/intake-plane/check.ts

@@ -61,8 +61,22 @@ export interface IntakeCheckEvidence {
   readonly contrary?: boolean;
 }
 
+export interface IntakeReplacementCandidate {
+  readonly tool: string;
+  readonly paidDependency: string;
+  readonly status: '현장 시험 필요';
+  /** A comparison claim is not evidence that any of these checks have passed. */
+  readonly trial: {
+    readonly installation: '미검증';
+    readonly sampleRun: '미검증';
+    readonly license: '미검증';
+    readonly maintenanceStatus: '미검증';
+  };
+}
+
 export interface IntakeCheckItem {
   readonly fact: string;
+  readonly replacementCandidate?: IntakeReplacementCandidate;
   /** Source identity preserved from the supplied fact for card-backed goal evidence. */
   readonly sourceRef?: string;
   readonly originalClaims?: readonly string[];
@@ -1053,6 +1067,40 @@ function factKey(text: string): string {
   return text.replace(/\s+/g, ' ').trim().toLowerCase();
 }
 
+/** A stated possibility is a trial candidate, not proof of a working replacement. */
+function replacementCandidate(fact: string): IntakeReplacementCandidate | undefined {
+  if (!/(?:대체(?:하|한|할| 가능| 후보|재)|replace|replacement|alternative to)/i.test(fact)
+    || /(?:대체하지\s*(?:는|도|조차|를)?\s*(?:않|못)|대체\s*못|대체할\s*수\s*(?:는|도|가)?\s*없|대체(?:가|는| 후보가)?\s*(?:아니|불가)|cannot replace|can't replace|does not replace|not a replacement)/i.test(fact)) return undefined;
+  const paid = fact.match(/(?:유료|paid)\s*(?:(?:서비스|의존성|도구|툴|API|dependency|service|tool)\s*)?`?([a-z][\w.-]+)`?/i);
+  // firecrawl is a named paid-dependency example even when the claim omits the word "paid".
+  const paidDependency = paid?.[1] ?? fact.match(/(?:^|[^\w])`?(firecrawl)`?(?=$|[^\w])/i)?.[1];
+  if (!paidDependency) return undefined;
+  const names = [...fact.matchAll(/`([a-z][\w.-]+)`/gi)].map((match) => match[1]!);
+  const explicit = names.filter((name) => name.toLowerCase() !== paidDependency.toLowerCase());
+  const plain = fact.match(/^\s*([a-z][\w.-]+)\s*(?:가|이|는|은|으로|로|can\b|could\b|may\b)/i)?.[1];
+  const tool = explicit.length === 1 ? explicit[0] : explicit.length === 0 ? plain : undefined;
+  if (!tool || tool.toLowerCase() === paidDependency.toLowerCase() || tool.toLowerCase() === 'elanous') return undefined;
+  // Names appearing together do not establish the direction of replacement.
+  const clause = fact.replace(/`/g, '').replace(/(?:유료|paid)\s*(?:(?:서비스|의존성|도구|툴|API|dependency|service|tool)\s*)?/gi, '');
+  const escape = (name: string): string => name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const name = (value: string): string => `(?<![\\w.-])${escape(value)}(?![\\w.-])`;
+  const toolName = name(tool);
+  const dependencyName = name(paidDependency);
+  const replaces = (subject: string, object: string): boolean => [
+    new RegExp(`${subject}\\s*(?:이|가|은|는)?\\s+${object}\\s*(?:을|를)\\s*대체(?:하|한|할| 가능| 후보|재)`, 'i'),
+    new RegExp(`${object}\\s*(?:을|를)\\s+${subject}\\s*(?:이|가|은|는)\\s*대체(?:하|한|할| 가능| 후보|재)`, 'i'),
+    new RegExp(`${subject}\\s+(?:can |could |may )?replace(?:s|d)?\\s+${object}`, 'i'),
+    new RegExp(`${subject}\\s+(?:is |could be |may be )?(?:an? )?(?:replacement|alternative)\\s+to\\s+${object}`, 'i'),
+  ].some((pattern) => pattern.test(clause));
+  if (!replaces(toolName, dependencyName) || replaces(dependencyName, toolName)) return undefined;
+  return {
+    tool,
+    paidDependency,
+    status: '현장 시험 필요',
+    trial: { installation: '미검증', sampleRun: '미검증', license: '미검증', maintenanceStatus: '미검증' },
+  };
+}
+
 function isLens(value: string): value is PreprocessLens {
   return (PREPROCESS_LENSES as readonly string[]).includes(value);
 }
@@ -1414,8 +1462,17 @@ export function runIntakeCheck(
     }
     // src/index.ts intake check .action → runIntakeCheck / runIntakeCheckDocument → runIntakeCheck → judgeFact.
     const judged = judgeFact(fact, ruler, deps);
+    const candidate = replacementCandidate(fact.text);
+    const verdict = candidate && judged.verdict !== '못 쟀다' ? '판단 필요' : judged.verdict;
+    const current = candidate && judged.verdict !== '못 쟀다'
+      ? `${judged.current} · 대체 후보 ${candidate.tool} → ${candidate.paidDependency}: 설치·샘플 실행·라이선스·유지보수 상태 현장 시험 필요`
+      : judged.current;
     const item: IntakeCheckItem = {
       ...judged,
+      verdict,
+      current,
+      line: `${fact.text} → ${current} → ${verdict}`,
+      ...(candidate ? { replacementCandidate: candidate } : {}),
       quotes: [quote],
       ...(fact.sourceRef ? { sourceRef: fact.sourceRef } : {}),
       ...(fact.originalClaim ? { originalClaims: [fact.originalClaim] } : {}),
@@ -1711,6 +1768,11 @@ export function renderIntakeCheckReport(report: IntakeCheckReport): string {
   for (const item of report.items) {
     lines.push(item.line);
     lines.push(`  판정: ${item.verdict}`);
+    if (item.replacementCandidate) {
+      const candidate = item.replacementCandidate;
+      lines.push(`  대체 후보: ${candidate.tool} → 유료 의존성 ${candidate.paidDependency} (${candidate.status})`);
+      lines.push('  현장 시험: 설치 미검증 · 샘플 실행 미검증 · 라이선스 미검증 · 유지보수 상태 미검증');
+    }
     if (item.goalDraftPath) lines.push(`  골 초안: ${item.goalDraftPath}`);
     for (const quote of item.quotes) lines.push(`  인용: ${quote}`);
     for (const original of item.originalClaims ?? []) lines.push(`  원 주장: ${original}`);
@@ -1746,6 +1808,7 @@ export function intakeCheckReportJson(report: IntakeCheckReport): Record<string,
       current: item.current,
       verdict: item.verdict,
       line: item.line,
+      ...(item.replacementCandidate ? { replacementCandidate: item.replacementCandidate } : {}),
       quotes: item.quotes,
       evidence: item.evidence,
       patterns: item.patterns,

package/src/intake-plane/digest.ts

@@ -1,12 +1,13 @@
 // 흡수 하루 다이제스트 — 그날 흡수한 것을 사람이 «발견»하는 자리. 노트 절(마크다운) ⊕ 텔레그램 짧은 판.
 // 결정론만: 요약 한 줄은 각 노트가 이미 쓴 「한 줄 결론」을 뽑는다(LLM 을 다시 부르지 않는다).
 import { existsSync, readFileSync } from 'node:fs';
-import { basename, join, relative } from 'node:path';
+import { basename, join } 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 type DigestLensVerdict = '대체 후보' | '보강' | '경쟁 대조';
+export interface DigestEntry { id: string; sources: string[]; url?: string; note?: string; noteName?: string; oneLiner?: string; axis: string; impact?: { verdict: DigestLensVerdict; why: string; target: 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> = {
@@ -40,20 +41,46 @@ function readJsonl(file: string): Record<string, unknown>[] {
 /** 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;
 
+/** A «why» that only names paths (optionally behind a label like «경로:») is evidence, not a reason for us. */
+export function pathOnly(why: string): boolean {
+  const rest = why
+    .replace(/`?(?:[\w.-]+\/)*[\w.-]+\.[A-Za-z0-9]{1,6}(?::\d+)?`?/g, ' ')
+    .replace(/`?(?:[\w.-]+\/)+[\w.-]*`?/g, ' ')
+    .replace(/(?:경로|파일|근거|path|file|evidence)\s*[:：]?/gi, ' ')
+    .replace(/[\s,·:;()[\]\-–—]+/g, '');
+  return rest.length < 4;
+}
+
 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 out = intakeOutboxDir(root);
+  const relevant = new Map<string, NonNullable<DigestEntry['impact']>>();
+  // The lens (src/intake-plane/lens.ts) writes its verdicts to outbox/lens/<day>.jsonl; route folders carry none.
+  for (const folder of ['lens'] as const) {
+    for (const row of readJsonl(join(out, folder, `${day}.jsonl`))) {
+      if (typeof row.id !== 'string' || relevant.has(row.id)) continue;
+      const verdict = row.lensVerdict;
+      if (verdict !== '대체 후보' && verdict !== '보강' && verdict !== '경쟁 대조') continue;
+      const why = typeof row.why === 'string' ? row.why.trim() : '';
+      const target = typeof row.target === 'string' ? row.target.trim() : '';
+      // A check's fact/current or repo path is evidence, not a lens judgement or a reason for us.
+      if (!why || !target || pathOnly(why)) continue;
+      relevant.set(row.id, { verdict, why, target });
+    }
+  }
   const absorbed = items.map((i: IntakeItem): DigestEntry => {
     const note = [...i.outputs].reverse().find((o) => o.kind === 'note')?.ref;
     const md = note ? readFile(note) : undefined;
+    const impact = relevant.get(i.id);
     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') ? '내가 저장한 것' : '그 밖'),
+      ...(impact ? { impact } : {}),
     };
   });
-  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;
@@ -84,28 +111,45 @@ export function renderDigestMarkdown(d: IntakeDigest): string {
     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('');
-  }
+  const undecided = d.absorbed.filter((e) => !e.impact).length;
+  if (undecided) L.push(`렌즈 판정 못 함 ${undecided} — 원장 \`elanous intake items\``, '');
   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)}`);
+/** 텔레그램 — 흡수 렌즈가 대조한 항목만 SCQA 짧은 판으로 낸다. */
+export function renderDigestTelegram(d: IntakeDigest, _opts: { vaultRoot?: string; notePath?: string } = {}): string {
+  // «Touching» is decided by the lens verdict alone; a missing note summary only changes how S reads (ACP must-fix).
+  const touching = d.absorbed.filter((e) => e.impact);
+  const L = [`흡수 ${d.absorbed.length} → 우리에게 닿는 것 ${touching.length}`];
+  if (!touching.length) return L[0];
+  // At most three items are shown, each as its own S·C·A·link block so context and source stay paired;
+  // a later item sharing (verdict, target) says «위와 같은 행동» instead of repeating the A sentence (ACP must-fix).
+  // S must be the note's own summary: items without one still count as touching but are not shown (ACP must-fix).
+  const shownItems = touching.filter((e) => e.oneLiner?.trim()).slice(0, 3);
+  const actionSeen = new Set<string>();
+  const actionsUsed = new Set<string>();
+  for (const e of shownItems) {
+    const impact = e.impact!;
+    const key = `${impact.verdict}\u0000${impact.target}`;
+    const base = impact.verdict === '대체 후보' ? `${impact.target} lite Pod 실증 제안`
+      : impact.verdict === '보강' ? `칸 ${impact.target} 에 근거 추가`
+        : `${impact.target} 비교표 갱신`;
+    // Every item keeps its own concrete action; a repeat of (verdict, target) names which item it is, so no two A lines match.
+    const label = (e.oneLiner?.trim() || impact.why).slice(0, 24);
+    let action = actionSeen.has(key) ? `${base} — «${label}» 근거로` : base;
+    // Two identical labels still differ by their position in the list.
+    if (actionsUsed.has(action)) action = `${action} (${shownItems.indexOf(e) + 1})`;
+    actionsUsed.add(action);
+    actionSeen.add(key);
+    L.push('',
+      `S 무엇: ${e.oneLiner?.trim() || '노트 한 줄 요약 없음'}`,
+      `C 우리에게 왜: ${impact.why}`,
+      `A 그래서 무엇을 하나: ${action}`,
+      `🔗 원문 링크: ${e.url?.trim() || '링크 없음'}`,
+    );
   }
+  if (touching.length > shownItems.length) L.push('', `닿는 것 ${touching.length - shownItems.length}건 더(요약 없는 것 포함) · 원장 \`elanous intake items\``);
+  if (d.absorbed.length > touching.length) L.push('', `그 밖 ${d.absorbed.length - touching.length}건 · 참고`);
   return L.join('\n');
 }

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

@@ -18,6 +18,12 @@ export interface FrontClassifierDecision extends IntakeFrontRouteDecision {
   urlRoute: UrlRouteDecision | null;
 }
 
+/** Only Telegram links explicitly routed to saved/absorbed work enter the event lane. */
+export function telegramAbsorbUrls(input: FrontClassifierInput, decision: FrontClassifierDecision): string[] {
+  if (input.surface !== 'telegram' || decision.track !== 'absorb' || !decision.urlRoute) return [];
+  return decision.urlRoute.urls;
+}
+
 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',

package/src/intake-plane/items.ts

@@ -5,6 +5,7 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { debug } from '../debug/log.js';
 import { findTrack } from '../autopilot/mission-phase-track.js';
+import { wasIntakeEventScheduled } from './route.js';
 
 export const INTAKE_SOURCES = ['x', 'youtube', 'github', 'telegram-saved', 'telegram-bot', 'memo', 'pwa'] as const;
 export type RegisteredIntakeSourceKind = 'rss' | 'command';
@@ -243,13 +244,13 @@ export function parseRawIntakeJsonl(text: string): { raws: RawIntakeItem[]; bad:
  */
 const STALE_QUEUED_MS = 24 * 3600_000;
 
-export function pickAbsorbQueue(instanceRoot: string, opts: { max: number; laneMax?: number; kind?: IntakeKind; dryRun?: boolean }, now = new Date().toISOString()): IntakeItem[] {
+export function pickAbsorbQueue(instanceRoot: string, opts: { max: number; laneMax?: number; kind?: IntakeKind; dryRun?: boolean }, now = new Date().toISOString(), taskStatus?: Parameters<typeof wasIntakeEventScheduled>[3]): IntakeItem[] {
   const userLeft = (i: IntakeItem) => i.sources.some((s) => s === 'telegram-saved' || s === 'memo');
   const score = (i: IntakeItem) => Math.max(0, ...Object.entries(i.signals).filter(([k]) => k.endsWith('.score')).map(([, v]) => v));
   const eligible = [...loadIntakeLedger(instanceRoot).items.values()]
     // queued 로 옮긴 뒤 흡수·표시가 없이 하루가 지난 것(흡수 도중 죽은 판)은 다시 고른다.
     .filter((i) => (i.status === 'new' || (i.status === 'queued' && Date.parse(now) - Date.parse(i.lastSeenAt) > STALE_QUEUED_MS))
-      && !!i.url && (!opts.kind || i.kind === opts.kind))
+      && !!i.url && !wasIntakeEventScheduled(instanceRoot, i.url, now, taskStatus) && (!opts.kind || i.kind === opts.kind))
     .sort((a, b) => Number(userLeft(b)) - Number(userLeft(a)) || b.sources.length - a.sources.length || score(b) - score(a) || b.lastSeenAt.localeCompare(a.lastSeenAt));
   const laneMax = opts.laneMax ?? 30;
   const lane = eligible.filter((i) => i.sources.includes('telegram-saved')).slice(0, Math.max(0, laneMax));

package/src/intake-plane/lens.ts

@@ -0,0 +1,177 @@
+// 흡수 렌즈 — outbox 항목마다 «우리에게 무엇인가»를 판정해 outbox/lens/<day>.jsonl 에만 남긴다.
+// 원 갈래(goals·manual·review·release)는 읽기만 한다. LLM 은 judge 한 번(id 당).
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { judge } from '../llm/judge-layer.js';
+import { intakeOutboxDir } from './route.js';
+
+export const LENS_VERDICTS = ['대체 후보', '보강', '경쟁 대조', '참고'] as const;
+export type LensVerdict = (typeof LENS_VERDICTS)[number];
+
+export const LENS_BRANCHES = ['goals', 'manual', 'review', 'release'] as const;
+export const LENS_DAILY_CAP = 20;
+export const LENS_FACT_CAP = 12;
+
+export interface LensRecord {
+  id: string;
+  at: string;
+  lensVerdict: LensVerdict;
+  why: string;
+  target: string;
+}
+
+export interface LensJudgeInput {
+  id: string;
+  facts: { fact: string; current: string }[];
+  url?: string;
+}
+
+export type LensJudge = (input: LensJudgeInput) => Promise<unknown>;
+
+export interface AnnotateIntakeLensDeps {
+  judge?: LensJudge;
+  now?: () => string;
+  log?: (event: string, data: Record<string, unknown>) => void;
+}
+
+export interface AnnotateIntakeLensResult {
+  judged: number;
+  skipped: number;
+  failed: number;
+  capped: boolean;
+}
+
+interface GroupedItem {
+  id: string;
+  facts: { fact: string; current: string }[];
+  url?: string;
+}
+
+function readJsonl(file: string): Record<string, unknown>[] {
+  if (!existsSync(file)) return [];
+  return readFileSync(file, 'utf8').split('\n').filter(Boolean).flatMap((line) => {
+    try { const row = JSON.parse(line) as unknown; return row && typeof row === 'object' && !Array.isArray(row) ? [row as Record<string, unknown>] : []; }
+    catch { return []; }
+  });
+}
+
+function isTestProcess(): boolean {
+  return process.env.NODE_ENV === 'test' || Boolean(process.env.ELANOUS_TEST_HOME);
+}
+
+function isLensVerdict(value: unknown): value is LensVerdict {
+  return typeof value === 'string' && (LENS_VERDICTS as readonly string[]).includes(value);
+}
+
+/** 스키마 밖이면 null — 기록하지 않는다. why 는 한 문장이다. */
+export function coerceLensVerdict(raw: unknown): Omit<LensRecord, 'id' | 'at'> | null {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+  const row = raw as Record<string, unknown>;
+  const why = typeof row.why === 'string' ? row.why.trim() : '';
+  const target = typeof row.target === 'string' ? row.target.trim() : '';
+  if (!isLensVerdict(row.lensVerdict) || !why || !target) return null;
+  if (/[\r\n]/.test(why)) return null;
+  return { lensVerdict: row.lensVerdict, why, target };
+}
+
+function groupOutbox(root: string, day: string): GroupedItem[] {
+  const out = intakeOutboxDir(root);
+  const order: string[] = [];
+  const groups = new Map<string, GroupedItem>();
+  for (const branch of LENS_BRANCHES) {
+    for (const row of readJsonl(join(out, branch, `${day}.jsonl`))) {
+      const id = typeof row.id === 'string' ? row.id.trim() : '';
+      const fact = typeof row.fact === 'string' ? row.fact.trim() : '';
+      const current = typeof row.current === 'string' ? row.current.trim() : '';
+      if (!id || !fact) continue;
+      let group = groups.get(id);
+      if (!group) {
+        group = { id, facts: [] };
+        groups.set(id, group);
+        order.push(id);
+      }
+      if (!group.url && typeof row.url === 'string' && row.url.trim()) group.url = row.url.trim();
+      if (group.facts.length < LENS_FACT_CAP) group.facts.push({ fact, current });
+    }
+  }
+  return order.map((id) => groups.get(id)!);
+}
+
+function judgedIds(file: string): Set<string> {
+  return new Set(readJsonl(file).flatMap((row) => typeof row.id === 'string' && row.id ? [row.id] : []));
+}
+
+function lensPrompt(item: GroupedItem): string {
+  const lines = item.facts.map((row, i) => `${i + 1}. fact: ${row.fact}\n   current: ${row.current || '(없음)'}`);
+  return [
+    'SYSTEM:',
+    '흡수 항목이 우리에게 무엇인가를 한 번만 판정한다. 경로를 나열하지 말고, 왜 우리에게 그 판정인지를 한 문장으로 말한다.',
+    'lensVerdict 는 다음 넷 중 하나다: 대체 후보 · 보강 · 경쟁 대조 · 참고.',
+    'target 은 닿는 우리 쪽 이름 하나(기능·칸·파일)다.',
+    'JSON 만 답한다: {"lensVerdict":"...","why":"...","target":"..."}',
+    '',
+    `id: ${item.id}`,
+    ...(item.url ? [`url: ${item.url}`] : []),
+    ...lines,
+  ].join('\n');
+}
+
+async function defaultJudge(item: GroupedItem): Promise<unknown> {
+  const decision = await judge({
+    site: 'intake.lens',
+    prompt: lensPrompt(item),
+    schema: (value) => coerceLensVerdict(value),
+  });
+  if (!decision.ok) {
+    if (decision.reason === 'schema') return null;
+    throw decision.error instanceof Error ? decision.error : new Error(String(decision.error));
+  }
+  return decision.value;
+}
+
+/** 그날 outbox 를 id 로 묶어 아직 없는 판정만 남긴다. 원 갈래 파일은 쓰지 않는다. */
+export async function annotateIntakeLens(
+  root: string,
+  day: string,
+  deps: AnnotateIntakeLensDeps = {},
+): Promise<AnnotateIntakeLensResult> {
+  const log = deps.log ?? ((event, data) => { debug.log('intake.lens', event, data); });
+  const empty = { judged: 0, skipped: 0, failed: 0, capped: false };
+  if (!deps.judge && isTestProcess()) {
+    log('skipped-test', {});
+    return empty;
+  }
+  const items = groupOutbox(root, day);
+  const file = join(intakeOutboxDir(root), 'lens', `${day}.jsonl`);
+  const done = judgedIds(file);
+  const pending = items.filter((item) => !done.has(item.id));
+  const capped = pending.length > LENS_DAILY_CAP;
+  const batch = pending.slice(0, LENS_DAILY_CAP);
+  if (capped) log('capped', { day, total: pending.length, judged: batch.length });
+  const judgeOne = deps.judge ?? ((input: LensJudgeInput) => defaultJudge(input));
+  const now = deps.now ?? (() => new Date().toISOString());
+  let judged = 0;
+  let failed = 0;
+  for (const item of batch) {
+    let raw: unknown;
+    try {
+      raw = await judgeOne({ id: item.id, facts: item.facts, ...(item.url ? { url: item.url } : {}) });
+    } catch (error) {
+      failed++;
+      log('judge-failed', { id: item.id, reason: error instanceof Error ? error.message : String(error) });
+      continue;
+    }
+    const verdict = coerceLensVerdict(raw);
+    if (!verdict) {
+      failed++;
+      log('judge-failed', { id: item.id, reason: 'schema' });
+      continue;
+    }
+    mkdirSync(join(intakeOutboxDir(root), 'lens'), { recursive: true });
+    const record: LensRecord = { id: item.id, at: now(), ...verdict };
+    appendFileSync(file, `${JSON.stringify(record)}\n`);
+    judged++;
+  }
+  return { judged, skipped: items.length - pending.length, failed, capped };
+}

package/src/intake-plane/route.ts

@@ -3,9 +3,13 @@
 // ⛔ 원장의 `text`(개인 메모일 수 있다)는 큐에 싣지 않는다 — 대조가 낸 사실·근거와 노트 경로만.
 import { execFileSync } from 'node:child_process';
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { Database } from 'bun:sqlite';
 import { join } from 'node:path';
 import { debug } from '../debug/log.js';
-import { intakeLedgerDir, loadIntakeLedger, markIntakeItem, type IntakeItem } from './items.js';
+import { getToxRuntimeDeps } from '../task-orchestrator/runtime-deps.js';
+import type { TaskStore } from '../task-orchestrator/store.js';
+import type { TaskStatus } from '../task-orchestrator/types.js';
+import { canonicalUrl, ingestIntakeItems, intakeItemId, intakeLedgerDir, loadIntakeLedger, markIntakeItem, type IntakeItem } from './items.js';
 
 /** `elanous intake check --json` 산출 중 갈래가 읽는 칸. */
 export interface IntakeCheckJson {
@@ -29,6 +33,146 @@ export const gitLastCommitOf: LastCommitOf = (tree, path) => {
 
 export function intakeOutboxDir(root: string): string { return join(intakeLedgerDir(root), 'outbox'); }
 
+export const INTAKE_EVENT_DEFERRED_REPLY = '일일 즉시 흡수 상한을 넘어 다음 일일 판으로 미뤘습니다.';
+export type IntakeEventResult = { status: 'scheduled' | 'deferred' | 'duplicate'; reason: string; url: string; reply?: string };
+
+// A lost claim must become eligible at the next daily pass; live tasks remain excluded.
+const INTAKE_EVENT_LEASE_MS = 23 * 3600_000;
+
+// A non-terminal task that has not been touched for this long is treated as a dead worker.
+const INTAKE_EVENT_TASK_STALE_MS = 2 * 3600_000;
+
+/** A probe may return the bare status, or the status with the task's last update (epoch ms). */
+export type IntakeEventTaskProbe = (id: string) => TaskStatus | { status: TaskStatus; updatedAt?: number } | undefined;
+
+function eventTaskStatus(taskId: string): { status: TaskStatus; updatedAt?: number } | undefined {
+  const deps = getToxRuntimeDeps();
+  const graphTask = deps.getGraph()?.getTask(taskId) ?? (deps.getStore?.() as TaskStore | null | undefined)?.getTask(taskId);
+  return graphTask ? { status: graphTask.status, updatedAt: graphTask.updatedAt } : undefined;
+}
+
+function probeStatus(probe: IntakeEventTaskProbe, id: string): { status?: TaskStatus; updatedAt?: number } {
+  const value = probe(id);
+  return typeof value === 'string' ? { status: value } : value ?? {};
+}
+
+type EventClaim = { status: string; task_id: string | null; claimed_at: string | null; day: string };
+
+function activeEventClaim(row: EventClaim, now: string, taskStatus: IntakeEventTaskProbe): boolean {
+  if (row.status !== 'scheduled' && row.status !== 'pending') return false;
+  const { status, updatedAt } = row.task_id ? probeStatus(taskStatus, row.task_id) : {};
+  if (status === 'done') return true;
+  if (status === 'failed' || status === 'cancelled' || status === 'superseded') return false;
+  const claimedAt = Date.parse(row.claimed_at ?? `${row.day}T00:00:00.000+09:00`);
+  const withinLease = Number.isFinite(claimedAt) && Date.parse(now) - claimedAt < INTAKE_EVENT_LEASE_MS;
+  if (!status) return withinLease;
+  // A status alone is not liveness: a crashed worker leaves «running» behind, so require a recent update.
+  if (updatedAt !== undefined && Number.isFinite(updatedAt)) return Date.parse(now) - updatedAt < INTAKE_EVENT_TASK_STALE_MS;
+  return withinLease;
+}
+
+/** Claim an event slot before posting. The unique URL and KST-day quota share one SQLite transaction. */
+export async function scheduleIntakeEvent(
+  root: string,
+  url: string,
+  opts: {
+    eventMax?: number;
+    now?: string;
+    post: (input: { url: string }) => Promise<{ taskId: string }>;
+  },
+): Promise<IntakeEventResult> {
+  const normalized = canonicalUrl(url);
+  if (!normalized) throw new Error('intake event requires an HTTP(S) URL');
+  const now = opts.now ?? new Date().toISOString();
+  const day = kstDay(now);
+  const id = intakeItemId('telegram-bot', { url: normalized });
+  const max = opts.eventMax ?? 10;
+  if (!Number.isSafeInteger(max) || max < 0) throw new RangeError('intake.eventMax must be a non-negative integer');
+  const existing = loadIntakeLedger(root).items.get(id);
+  if (existing && ['queued', 'absorbed', 'checked', 'routed', 'discarded'].includes(existing.status)) {
+    return { status: 'duplicate', url: normalized, reason: 'already-in-ledger' };
+  }
+  mkdirSync(intakeLedgerDir(root), { recursive: true });
+  const db = new Database(join(intakeLedgerDir(root), 'events.sqlite'), { create: true });
+  db.exec('PRAGMA busy_timeout = 5000');
+  try {
+    db.exec(`CREATE TABLE IF NOT EXISTS intake_events (
+      url TEXT PRIMARY KEY, day TEXT NOT NULL, status TEXT NOT NULL, task_id TEXT, claimed_at TEXT
+    )`);
+    const columns = db.query('PRAGMA table_info(intake_events)').all() as { name: string }[];
+    if (!columns.some((column) => column.name === 'claimed_at')) db.exec('ALTER TABLE intake_events ADD COLUMN claimed_at TEXT');
+    // One row per claim that reached the task queue — the KST-day quota counts these, not current statuses.
+    db.exec('CREATE TABLE IF NOT EXISTS intake_event_claims (url TEXT NOT NULL, day TEXT NOT NULL, claimed_at TEXT NOT NULL, PRIMARY KEY (url, claimed_at))');
+    const claim = db.transaction((): 'scheduled' | 'deferred' | 'duplicate' => {
+      const previous = db.query('SELECT status, task_id, claimed_at, day FROM intake_events WHERE url = ?').get(normalized) as EventClaim | null;
+      if (previous && activeEventClaim(previous, now, eventTaskStatus)) {
+        if (previous.task_id && eventTaskStatus(previous.task_id)?.status === 'done') {
+          db.query("UPDATE intake_events SET status = 'completed' WHERE url = ?").run(normalized);
+        }
+        return 'duplicate';
+      }
+      if (previous && previous.status !== 'failed' && previous.status !== 'expired'
+        && previous.status !== 'pending' && previous.status !== 'scheduled') {
+        return previous.status === 'deferred' ? 'deferred' : 'duplicate';
+      }
+      const count = db.query('SELECT count(*) AS n FROM intake_event_claims WHERE day = ?').get(day) as { n: number };
+      const status = count.n >= max ? 'deferred' : 'pending';
+      db.query(`INSERT INTO intake_events (url, day, status, claimed_at) VALUES (?, ?, ?, ?)
+        ON CONFLICT(url) DO UPDATE SET day = excluded.day, status = excluded.status, claimed_at = excluded.claimed_at, task_id = NULL`)
+        .run(normalized, day, status, now);
+      if (status === 'pending') db.query('INSERT OR IGNORE INTO intake_event_claims (url, day, claimed_at) VALUES (?, ?, ?)').run(normalized, day, now);
+      return status === 'pending' ? 'scheduled' : 'deferred';
+    })();
+    if (claim === 'duplicate') return { status: 'duplicate', url: normalized, reason: 'already-claimed' };
+    if (claim === 'deferred') {
+      ingestIntakeItems(root, 'telegram-bot', [{ url: normalized }], now);
+      debug.log('intake.event', 'deferred', { url: normalized, reason: 'event-max' });
+      return { status: 'deferred', url: normalized, reason: 'event-max', reply: INTAKE_EVENT_DEFERRED_REPLY };
+    }
+    let posted: { taskId: string };
+    try {
+      ingestIntakeItems(root, 'telegram-bot', [{ url: normalized }], now);
+      posted = await opts.post({ url: normalized });
+      if (!posted.taskId) throw new Error('intake event post returned no taskId');
+    } catch (error) {
+      db.query('DELETE FROM intake_events WHERE url = ? AND status = ? AND claimed_at = ?').run(normalized, 'pending', now);
+      db.query('DELETE FROM intake_event_claims WHERE url = ? AND claimed_at = ?').run(normalized, now);
+      throw error;
+    }
+    db.query("UPDATE intake_events SET status = 'scheduled', task_id = ? WHERE url = ? AND status = 'pending' AND claimed_at = ?")
+      .run(posted.taskId, normalized, now);
+    debug.log('intake.event', 'scheduled', { url: normalized, reason: 'telegram-absorb' });
+    return { status: 'scheduled', url: normalized, reason: 'telegram-absorb' };
+  } finally {
+    db.close();
+  }
+}
+
+/** Only an active task or a fresh claim excludes a URL from the daily queue. */
+export function wasIntakeEventScheduled(root: string, url: string, now = new Date().toISOString(), taskStatus: IntakeEventTaskProbe = eventTaskStatus): boolean {
+  const file = join(intakeLedgerDir(root), 'events.sqlite');
+  if (!existsSync(file)) return false;
+  const normalized = canonicalUrl(url);
+  if (!normalized) return false;
+  const db = new Database(file);
+  try {
+    const row = db.query('SELECT status, task_id, claimed_at, day FROM intake_events WHERE url = ?').get(normalized) as EventClaim | null;
+    if (!row || (row.status !== 'scheduled' && row.status !== 'pending')) return row?.status === 'completed';
+    if (activeEventClaim(row, now, taskStatus)) {
+      if (row.task_id && probeStatus(taskStatus, row.task_id).status === 'done') {
+        db.query("UPDATE intake_events SET status = 'completed' WHERE url = ?").run(normalized);
+      }
+      return true;
+    }
+    const status = row.task_id ? probeStatus(taskStatus, row.task_id).status : undefined;
+    db.query("UPDATE intake_events SET status = ? WHERE url = ? AND status IN ('pending', 'scheduled')")
+      .run(status === 'failed' || status === 'cancelled' || status === 'superseded' ? 'failed' : 'expired', normalized);
+    return false;
+  } finally {
+    db.close();
+  }
+}
+
 function appendJsonl(file: string, rows: unknown[]): void {
   if (!rows.length) return;
   mkdirSync(join(file, '..'), { recursive: true });