elanous 0.2.17 → 0.2.18

package/src/intake-plane/adopt-gate.ts

@@ -0,0 +1,49 @@
+import { debug } from '../debug/log.js';
+
+export interface AdoptionCandidate {
+  readonly id: string;
+  readonly grade: 'P1' | 'P2' | 'P3' | 'P4';
+  readonly risk: number;
+  readonly money: number;
+  readonly security: number;
+  readonly license: string | null;
+  readonly touchesPatentCandidate: boolean;
+}
+
+export type AdoptShadowReason = 'grade' | 'risk' | 'money' | 'security' | 'license' | 'patent' | 'daily-cap';
+
+export interface AdoptShadowVerdict {
+  readonly id: string;
+  readonly adopt: boolean;
+  readonly reasons: readonly AdoptShadowReason[];
+}
+
+const ALLOWED_LICENSES: ReadonlySet<string> = new Set([
+  'MIT', 'Apache-2.0', 'BSD-2-Clause', 'BSD-3-Clause', 'ISC', 'MPL-2.0',
+]);
+
+export function judgeAdoption(candidate: AdoptionCandidate, adoptedToday: number): AdoptShadowVerdict {
+  const reasons: AdoptShadowReason[] = [];
+  if (candidate.grade !== 'P1' && candidate.grade !== 'P2') reasons.push('grade');
+  if (!(candidate.risk <= 1)) reasons.push('risk');
+  if (candidate.money !== 0) reasons.push('money');
+  if (candidate.security !== 0) reasons.push('security');
+  if (candidate.license === null || !ALLOWED_LICENSES.has(candidate.license)) reasons.push('license');
+  if (candidate.touchesPatentCandidate !== false) reasons.push('patent');
+  if (!(adoptedToday < 5)) reasons.push('daily-cap');
+  return { id: candidate.id, adopt: reasons.length === 0, reasons };
+}
+
+export function shadowAdopt(candidates: readonly AdoptionCandidate[]): AdoptShadowVerdict[] {
+  const verdicts: AdoptShadowVerdict[] = [];
+  let adoptedToday = 0;
+  for (const candidate of candidates) {
+    const verdict = judgeAdoption(candidate, adoptedToday);
+    if (verdict.adopt) adoptedToday++;
+    verdicts.push(verdict);
+    debug.log('intake.adopt', 'shadow-verdict', {
+      id: verdict.id, adopt: verdict.adopt, reasons: verdict.reasons,
+    });
+  }
+  return verdicts;
+}

package/src/intake-plane/check.ts

@@ -21,6 +21,7 @@ import { parse as parseYaml } from 'yaml';
 import { debug } from '../debug/log.js';
 import { openSurfaceEventsDb, recallEvents } from '../domains/surface-events.js';
 import { extractJsonBlock, skeletonFallback } from './decompose.js';
+import type { AdoptShadowVerdict } from './adopt-gate.js';
 
 export const INTAKE_CHECK_MODE = 'check' as const;
 
@@ -110,6 +111,7 @@ export interface IntakeCheckReport {
   /** 비교·시너지 제안 수(근거 없음 포함). */
   readonly proposalCount?: number;
   readonly proposals?: readonly IntakeCompareProposal[];
+  readonly adoptShadow?: readonly AdoptShadowVerdict[];
 }
 
 /** 선가공 렌즈 여섯. 🅞 원장 · PR #20009. */
@@ -1826,6 +1828,7 @@ export function intakeCheckReportJson(report: IntakeCheckReport): Record<string,
       proposalCount: report.proposalCount,
       proposals: report.proposals,
     } : {}),
+    ...(report.adoptShadow !== undefined ? { adoptShadow: report.adoptShadow } : {}),
   };
 }
 

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

@@ -6,14 +6,18 @@ import { execFileSync } from 'node:child_process';
 import { debug } from '../debug/log.js';
 import { ingestIntakeItems, intakeLedgerDir, type IngestResult, type RawIntakeItem } from './items.js';
 
-/** 한 판에 열 번 안쪽 — 검색 API 비율 제한(인증 시 분당 30회)을 시험 밖에서 상수로 묶는다. */
+/** 한 판에 열 번 이하 — 검색 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',
+  'topic:agent-framework',
+  'topic:computer-use',
+  'topic:local-llm',
+  'topic:claude-code',
+  'topic:codex',
+  'topic:agent-memory',
 ] as const;
 
 /** `--days` 기본. 최근 이 일수 안에 만들어졌거나 푸시된 저장소만 받는다. */
@@ -32,6 +36,7 @@ export interface GithubStarRepo {
   stars: number;
   createdAt: string;
   pushedAt: string;
+  license?: string;
 }
 
 /** 질의 하나 → 저장소 목록. 실제 구현은 `gh api` · 시험은 가짜. */
@@ -43,6 +48,7 @@ export interface GithubStarSignals {
   stars: number;
   starsDelta?: number;
   starsPerDay?: number;
+  baselineDays?: number;
 }
 
 export interface CollectGithubQueryCount { query: string; received: number }
@@ -55,6 +61,8 @@ export interface CollectGithubRepoRow {
   stars: number;
   starsDelta?: number;
   starsPerDay?: number;
+  baselineDays?: number;
+  license?: string;
 }
 
 export interface CollectGithubResult {
@@ -99,6 +107,17 @@ export function precedingSnapshot(snaps: readonly StarSnapshot[], repo: string,
   return best;
 }
 
+/** 7일 전 또는 그 이전 중 가장 가까운 스냅숏; 없으면 직전 스냅숏. */
+export function surgeBaseline(snaps: readonly StarSnapshot[], repo: string, day: string): StarSnapshot | undefined {
+  const cutoff = new Date(Date.parse(`${day}T00:00:00.000Z`) - 7 * 86_400_000).toISOString().slice(0, 10);
+  let best: StarSnapshot | undefined;
+  for (const s of snaps) {
+    if (s.repo !== repo || s.day > cutoff) continue;
+    if (!best || s.day > best.day) best = s;
+  }
+  return best ?? precedingSnapshot(snaps, repo, day);
+}
+
 function utcDay(iso: string): string {
   const t = Date.parse(iso);
   if (!Number.isFinite(t)) return '';
@@ -128,7 +147,7 @@ export function signalsFromSnapshot(stars: number, prev: StarSnapshot | undefine
   if (!prev) return { stars };
   const span = Math.max(1, daysBetween(prev.day, day));
   const starsDelta = stars - prev.stars;
-  return { stars, starsDelta, starsPerDay: starsDelta / span };
+  return { stars, starsDelta, starsPerDay: starsDelta / span, baselineDays: span };
 }
 
 export function appendGithubStarSnapshots(root: string, rows: StarSnapshot[]): void {
@@ -154,13 +173,13 @@ export interface CollectGithubOpts {
   /** 스냅숏·비교의 «오늘». 생략하면 UTC 날짜. */
   day?: string;
   now?: () => Date;
-  /** 등록 원천이 질의 하나만 수집할 때; 생략 시 기존 관심 질의 전부. */
+  /** 등록 원천이 질의 하나만 수집할 때; 생략 시 관심 질의 전부 (최대 10개). */
   queries?: readonly string[];
 }
 
 /**
  * 관심 주제 질의마다 별 순 검색을 부르고, 최근 창 안의 저장소만 남긴 뒤 질의 사이에서 중복을 없앤다.
- * 저장소마다 오늘 별 수 스냅숏을 덧붙이고, 직전 스냅숏과 비교한 신호를 원장에 넣는다.
+ * 저장소마다 오늘 별 수 스냅숏을 덧붙이고, 7일 기준(없으면 직전) 스냅숏과 비교한 신호를 원장에 넣는다.
  * dryRun 이면 스냅숏·원장을 바꾸지 않는다.
  */
 export async function collectGithubStars(
@@ -175,7 +194,7 @@ export async function collectGithubStars(
   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 opts.queries ?? GITHUB_STAR_QUERIES) {
+  for (const query of (opts.queries ?? GITHUB_STAR_QUERIES).slice(0, 10)) {
     const rows = await search(`${query} created:>=${windowStart}`, perQuery);
     const recent = rows.filter((r) => isRecentRepo(r, day, days));
     queries.push({ query, received: recent.length });
@@ -186,20 +205,24 @@ export async function collectGithubStars(
   const repos: CollectGithubRepoRow[] = unique.map((repo) => {
     const prev = precedingSnapshot(prior, repo.fullName, day);
     const signals = signalsFromSnapshot(repo.stars, prev, day);
+    const surge = signalsFromSnapshot(repo.stars, surgeBaseline(prior, repo.fullName, day), day);
     return {
       repo: repo.fullName,
       url: repo.url,
       title: repo.fullName,
       text: repo.description,
       stars: signals.stars,
+      ...(repo.license !== undefined ? { license: repo.license } : {}),
       ...(signals.starsDelta !== undefined ? { starsDelta: signals.starsDelta } : {}),
-      ...(signals.starsPerDay !== undefined ? { starsPerDay: signals.starsPerDay } : {}),
+      ...(surge.starsPerDay !== undefined ? { starsPerDay: surge.starsPerDay } : {}),
+      ...(surge.baselineDays !== undefined ? { baselineDays: surge.baselineDays } : {}),
     };
-  });
+  }).sort((a, b) => (b.starsPerDay ?? -Infinity) - (a.starsPerDay ?? -Infinity) || b.stars - a.stars);
   const raws: RawIntakeItem[] = repos.map((row) => ({
     url: row.url,
     title: row.title,
-    text: row.text,
+    // 모든 행 첫 줄에 라이선스: SPDX · 확인된 부재는 «없음» · 응답이 알려 주지 않으면 «미상»(없음으로 읽지 않는다).
+    text: `라이선스: ${row.license ?? '미상'}\n${row.text}`,
     signals: {
       stars: row.stars,
       ...(row.starsDelta !== undefined ? { starsDelta: row.starsDelta } : {}),
@@ -226,23 +249,10 @@ interface GhSearchItem {
   stargazers_count?: number;
   created_at?: string;
   pushed_at?: string;
+  license?: { spdx_id?: string | null } | null;
 }
 
-/** `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[];
+export function reposFromGhSearchItems(items: GhSearchItem[], perQuery: number): GithubStarRepo[] {
   if (!Array.isArray(items)) return [];
   const repos: GithubStarRepo[] = [];
   for (const item of items) {
@@ -254,7 +264,29 @@ export const ghApiSearchRepos: SearchGithubRepos = async (query, perQuery) => {
       stars: Number(item.stargazers_count ?? 0),
       createdAt: item.created_at ?? '',
       pushedAt: item.pushed_at ?? '',
+      ...(item.license === null
+        ? { license: '없음' }
+        : typeof item.license?.spdx_id === 'string' && item.license.spdx_id
+          ? { license: item.license.spdx_id }
+          : {}),
     });
   }
   return repos.slice(0, perQuery);
+}
+
+/** `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 });
+  return reposFromGhSearchItems(JSON.parse(out) as GhSearchItem[], perQuery);
 };

package/src/intake-plane/discord-seat-work.ts

@@ -5,7 +5,7 @@ import { awaitGlobalPersonaLoad, getGlobalPersonaRegistry } from '../persona/glo
 import type { PersonaSource } from '../persona/mention-parser.js';
 import { dispatchCeoTask, type CeoCommandDeps } from '../seat-dispatch/ceo-commands.js';
 import { ceoTaskDeps, classifyCeoIntent } from '../seat-dispatch/ceo-intent.js';
-import { askSeat, parseSeatAsk, type SeatAskDeps } from '../seat-dispatch/seat-ask.js';
+import { askSeat, askSeatAs, parseSeatAsk, type SeatAskDeps } from '../seat-dispatch/seat-ask.js';
 import { parseSeatAddress, resolveSeat } from '../seat-address/seat-address.js';
 import { getUserConfig, type UserConfig } from '../user-config.js';
 import { answerAsSeat } from './seat-answer.js';
@@ -110,7 +110,13 @@ export async function handleDiscordSeatWork(
     const seatId = canonicalSeatId(seats[0].seat.id);
     if (auth && ['OP', 'TC', 'MK', 'UX'].includes(seatId)) {
       const intent = classifyCeoIntent(body);
-      if (intent === 'task') return sendTask(seatId, body, auth.cfg, auth.id);
+      if (intent === 'task') {
+        if (deps.askDeps) return askSeatAs(seatId as 'OP' | 'TC' | 'MK' | 'UX', body,
+          { channel: 'discord', channelId: msg.channelId, messageId: msg.messageId,
+            ...(msg.threadId ? { threadId: msg.threadId } : {}) },
+          deps.commandDeps ?? ceoTaskDeps(auth.cfg, auth.id), deps.askDeps);
+        return sendTask(seatId, body, auth.cfg, auth.id);
+      }
       const answer = await (deps.answer ?? answerAsSeat)(seats[0].name, body);
       debug.log('seat.dispatch', 'intent', { seat: seatId, intent, via: 'discord', outcome: answer ? 'answered' : 'intake' });
       if (answer) return answer.text;

package/src/intake-plane/requirement-funnel.ts

@@ -0,0 +1,316 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { normalizeClaim, type AddBriefItem } from '../briefing/brief-items.js';
+import { createRequire } from 'node:module';
+import { debug } from '../debug/log.js';
+import { listChecklist, setItem, type ChecklistItem } from '../release-loop/checklist.js';
+import { placeCell, type PlacementDeps } from '../release-loop/placement.js';
+import { listSchedules } from '../release-loop/release-schedule.js';
+import { getUserConfig } from '../user-config.js';
+import { dateKey } from '../time/format.js';
+import { cardIndexPath, CardStore, type TaskCard } from '../task-cards/card-store.js';
+import { loadIntakeLedger, type IntakeItem } from './items.js';
+import { parseRubric, rubricGrade, rubricScore } from '../release-loop/rubric.js';
+
+export type RequirementSource = 'directive' | 'intake' | 'grounding' | 'coordination' | 'linear';
+export interface RequirementCandidate {
+  id: string;
+  source: RequirementSource;
+  text: string;
+  link: string;
+  receivedAt: string;
+  priority?: 'P0' | 'P1' | 'P2';
+  risk?: number;
+  cost?: number;
+  security?: number;
+  license?: string;
+  patentPrivatePath?: boolean;
+  owner?: string;
+  deadlineVersion?: string;
+}
+export type IncomingRequirement = Omit<RequirementCandidate, 'source'>;
+export interface RequirementSources {
+  directives?: readonly DirectiveRow[];
+  intake?: readonly IntakeItem[];
+  grounding?: readonly IncomingRequirement[];
+  coordination?: readonly IncomingRequirement[];
+  linear?: readonly IncomingRequirement[];
+}
+export interface RequirementDecision {
+  candidate: RequirementCandidate;
+  sources: RequirementCandidate[];
+  status: 'adopted' | 'would-adopt' | 'proposal';
+  cellId?: string;
+  version?: string;
+  rubric: string;
+  reason?: string;
+}
+export interface RequirementFunnelResult {
+  counts: Record<RequirementSource, number>;
+  candidates: number;
+  decisions: RequirementDecision[];
+  unlinkedDirectives: RequirementCandidate[];
+  briefItems: AddBriefItem[];
+}
+export interface FunnelOptions {
+  sources: RequirementSources;
+  /** Older directives are only checked for unlinked P0 backlog, not counted as today's arrivals. */
+  historicalDirectives?: readonly DirectiveRow[];
+  cells: readonly { version: string; item: ChecklistItem }[];
+  now: Date;
+  mode?: 'shadow' | 'live';
+  /** Required for live external adoption; the unresolved daily limit has no implicit value. */
+  dailyCap?: number;
+  adoptedToday?: number;
+  allowedLicenses?: readonly string[];
+  placement?: PlacementDeps;
+  adopt?: (candidate: RequirementCandidate, version: string, cellId: string, evidence: string) => void;
+}
+
+/** How many of the last 24 hours' unlinked directives the single P0 brief line names (the full backlog is one count). */
+export const UNLINKED_DIRECTIVES_SHOWN = 5;
+/** ABSORB-ADOPT daily limit when config sets none (OP 10-06 22:59 · the cell's own number). */
+export const DEFAULT_DAILY_CAP = 5;
+/** Directive row fields the funnel reads — kept local because `src/directives/directive-index` is excluded from the public export. */
+export interface DirectiveRow { ts: string; track: string | null; text: string; source_file: string; line_no: number }
+
+/** Loads the private directive index at run time only (same pattern as decisions/proact-meter), so public builds bundle cleanly. */
+function openDirectiveIndex(stateDir: string): { dailyRequirements(since: string, until: string): DirectiveRow[]; close(): void } {
+  const spec = ['..', 'directives', 'directive-index.js'].join('/');
+  const mod = createRequire(import.meta.url)(spec) as { DirectiveIndex: new (o: { stateDir?: string }) => ReturnType<typeof openDirectiveIndex> };
+  return new mod.DirectiveIndex({ stateDir });
+}
+
+const oneLine = (value: string) => value.replace(/\s+/g, ' ').trim();
+const idFor = (source: RequirementSource, key: string) => createHash('sha256').update(`${source}:${key}`).digest('hex').slice(0, 16);
+
+export function directiveCandidates(rows: readonly DirectiveRow[]): RequirementCandidate[] {
+  return rows.map(row => ({ id: idFor('directive', `${row.source_file}:${row.line_no}`), source: 'directive',
+    text: oneLine(row.text), link: `${row.source_file}#L${row.line_no}`, receivedAt: row.ts,
+    priority: 'P2', owner: row.track && /^[A-Z]{2,8}$/.test(row.track) ? row.track : 'OP' }));
+}
+export function intakeCandidates(rows: readonly IntakeItem[]): RequirementCandidate[] {
+  return rows.map(row => ({ id: row.id, source: 'intake', text: oneLine(row.text || row.title || ''),
+    link: row.url || `intake:${row.id}`, receivedAt: row.observedAt }));
+}
+export function suppliedCandidates(source: 'grounding' | 'coordination' | 'linear', rows: readonly IncomingRequirement[]): RequirementCandidate[] {
+  return rows.map(row => ({ ...row, source, text: oneLine(row.text) }));
+}
+
+function linkFor(candidate: RequirementCandidate, cells: FunnelOptions['cells']): FunnelOptions['cells'][number] | undefined {
+  return cells.find(({ item }) => !!candidate.link && !!item.evidence && item.evidence.includes(candidate.link));
+}
+function gate(candidate: RequirementCandidate, options: FunnelOptions, used: number): string | null {
+  if (candidate.priority !== 'P1' && candidate.priority !== 'P2') return 'P1/P2 판정 없음';
+  if (candidate.priority === 'P1' && !candidate.deadlineVersion) return 'P1 마감 판 미확인';
+  if (candidate.risk === undefined || !Number.isFinite(candidate.risk) || candidate.risk > 1 || candidate.risk < 0) return '위험≤1 미확인';
+  if (candidate.cost !== 0) return '돈 0 미확인';
+  if (candidate.security !== 0) return '보안 0 미확인';
+  if (!candidate.license || !options.allowedLicenses?.includes(candidate.license)) return '허용 라이선스 미확인';
+  if (candidate.patentPrivatePath !== false) return '특허 비공개 경로 무접촉 미확인';
+  if (options.dailyCap === undefined || !Number.isSafeInteger(options.dailyCap) || options.dailyCap < 0) return '하루 상한 미설정';
+  if (used >= options.dailyCap) return '하루 상한 도달';
+  return null;
+}
+
+/** RUBRIC-PLACE: use the release placement engine's priority, deadline, capacity and predecessor checks, not an invented score. */
+export function runRequirementFunnel(options: FunnelOptions): RequirementFunnelResult {
+  const { sources, cells, now } = options;
+  const arrivals = [
+    ...directiveCandidates(sources.directives ?? []), ...intakeCandidates(sources.intake ?? []),
+    ...suppliedCandidates('grounding', sources.grounding ?? []),
+    ...suppliedCandidates('coordination', sources.coordination ?? []),
+    ...suppliedCandidates('linear', sources.linear ?? []),
+  ].filter(candidate => candidate.text && Number.isFinite(Date.parse(candidate.receivedAt)) && Date.parse(candidate.receivedAt) <= now.getTime());
+  const counts: RequirementFunnelResult['counts'] = { directive: 0, intake: 0, grounding: 0, coordination: 0, linear: 0 };
+  for (const candidate of arrivals) counts[candidate.source]++;
+  const groups = new Map<string, RequirementCandidate[]>();
+  for (const candidate of arrivals) {
+    const key = normalizeClaim(candidate.text);
+    groups.set(key, [...(groups.get(key) ?? []), candidate]);
+  }
+  const decisions: RequirementDecision[] = [];
+  let used = options.adoptedToday ?? 0;
+  for (const members of groups.values()) {
+    members.sort((a, b) => a.receivedAt.localeCompare(b.receivedAt));
+    const candidate = members.find(member => member.source === 'directive') ?? members[0]!;
+    const linked = members.map(member => linkFor(member, cells)).find(Boolean);
+    const evidence = members.map(member => `${member.link} (${member.receivedAt})`).join(' · ');
+    if (linked) {
+      decisions.push({ candidate, sources: members, status: 'adopted', cellId: linked.item.id, version: linked.version,
+        rubric: `RUBRIC-PLACE ${linked.item.priority ?? '미지정'} · ${linked.version}` });
+      continue;
+    }
+    const isDirective = members.some(member => member.source === 'directive');
+    const reason = isDirective ? null : gate(candidate, options, used);
+    if (reason) {
+      decisions.push({ candidate, sources: members, status: 'proposal', reason, rubric: `ABSORB-ADOPT · ${reason}` });
+      continue;
+    }
+    const cellId = candidate.id;
+    const priority = candidate.priority ?? 'P1';
+    const rubricInput = { id: cellId, title: candidate.text, owner: candidate.owner ?? 'OP', priority,
+      predecessors: [], ...(priority === 'P1' && candidate.deadlineVersion ? { deadlineVersion: candidate.deadlineVersion } : {}) };
+    let placement: ReturnType<typeof placeCell>;
+    try { placement = placeCell(rubricInput, { ...options.placement, now, dryRun: true }); }
+    catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      decisions.push({ candidate, sources: members, status: isDirective ? 'would-adopt' : 'proposal', reason,
+        rubric: `RUBRIC-PLACE · 판 배치 보류: ${reason}` });
+      continue;
+    }
+    const rubric = `RUBRIC-PLACE ${priority} · ${placement.version}: ${placement.reason}`;
+    if (options.mode === 'live') {
+      if (!options.adopt) throw new Error('편입 기록자가 설정되지 않았다');
+      options.adopt(candidate, placement.version, cellId, evidence);
+    }
+    decisions.push({ candidate, sources: members, status: options.mode === 'live' ? 'adopted' : 'would-adopt',
+      cellId, version: placement.version, rubric });
+    if (!isDirective) used++;
+  }
+  const unlinkedDirectives = [...directiveCandidates(options.historicalDirectives ?? []).filter(candidate =>
+    candidate.text && Number.isFinite(Date.parse(candidate.receivedAt)) && Date.parse(candidate.receivedAt) <= now.getTime()
+    && !linkFor(candidate, cells) && !arrivals.some(arrival => arrival.id === candidate.id)),
+    ...decisions.filter(decision => decision.status !== 'adopted')
+      .flatMap(decision => decision.sources.filter(source => source.source === 'directive'))]
+    .sort((a, b) => a.receivedAt.localeCompare(b.receivedAt));
+  const briefItems: AddBriefItem[] = [];
+  const summary = `들어온 요구 ${groups.size}(문별 지시 ${counts.directive} · 흡수 ${counts.intake} · 그라운딩 ${counts.grounding} · 조율 ${counts.coordination} · Linear ${counts.linear}) · 편입 ${decisions.filter(d => d.status === 'adopted').length} · 했을 것 ${decisions.filter(d => d.status === 'would-adopt').length} · 제안 ${decisions.filter(d => d.status === 'proposal').length}`;
+  if (arrivals.length || unlinkedDirectives.length) briefItems.push({ text: summary, domain: '흡수', priority: 'P1', source: 'requirement-funnel' });
+  for (const decision of decisions) {
+    const { candidate } = decision;
+    const status = decision.status === 'adopted' ? `편입 ${decision.cellId} · 판 ${decision.version}`
+      : decision.status === 'would-adopt' ? decision.version ? `했을 것 ${decision.cellId} · 판 ${decision.version}` : '편입 대상 · 판 배치 대기'
+        : `제안: ${decision.reason}`;
+    briefItems.push({ text: `${status} · ${candidate.text} · ${decision.rubric}`, domain: decision.status === 'proposal' ? '흡수' : '판',
+      priority: 'P1', source: 'requirement-funnel', evidence: decision.sources.map(member => `${member.link} (${member.receivedAt})`).join(' · ') });
+  }
+  // OP 10-06 22:59: the backlog can hold the whole directive history, so only the last 24 hours get named (one P0 line);
+  // the full backlog is a single count. Nothing recent → the count alone, at P1, so history cannot flood the brief.
+  if (unlinkedDirectives.length) {
+    const recent = unlinkedDirectives.filter(directive => now.getTime() - Date.parse(directive.receivedAt) <= 24 * 3_600_000);
+    const named = recent.slice(0, UNLINKED_DIRECTIVES_SHOWN);
+    const rest = recent.length - named.length;
+    const total = `전체 누계 ${unlinkedDirectives.length}`;
+    briefItems.push(recent.length
+      ? { text: `대표 지시 중 아직 칸 없는 것 — 최근 24시간 ${recent.length}: ${named.map(directive => `${directive.text} (${directive.receivedAt})`).join(' · ')}${rest > 0 ? ` · 외 ${rest}` : ''} · ${total}`,
+        domain: '판', priority: 'P0', source: 'requirement-funnel', evidence: named.map(directive => directive.link).join(' · ') }
+      : { text: `대표 지시 중 아직 칸 없는 것 — 최근 24시간 0 · ${total}`, domain: '판', priority: 'P1', source: 'requirement-funnel' });
+  }
+  return { counts, candidates: groups.size, decisions, unlinkedDirectives, briefItems };
+}
+
+/** Existing ledgers only; no source collector or sender is started here. */
+export function readRequirementFunnel(options: { stateDir?: string; now?: Date; mode?: 'shadow' | 'live'; dailyCap?: number;
+  allowedLicenses?: readonly string[]; grounding?: readonly IncomingRequirement[]; coordination?: readonly IncomingRequirement[];
+  linear?: readonly IncomingRequirement[]; placement?: PlacementDeps } = {}): RequirementFunnelResult {
+  const stateDir = options.stateDir ?? elanousStateRoot();
+  const now = options.now ?? new Date();
+  const config = (getUserConfig().raw.intake as { requirementFunnel?: { mode?: 'shadow' | 'live'; dailyCap?: number; allowedLicenses?: string[] } } | undefined)?.requirementFunnel;
+  const mode = options.mode ?? config?.mode ?? 'shadow';
+  if (mode !== 'shadow' && mode !== 'live') throw new Error(`알 수 없는 요구 깔때기 모드: ${mode}`);
+  const dailyCap = options.dailyCap ?? config?.dailyCap ?? DEFAULT_DAILY_CAP;
+  const allowedLicenses = options.allowedLicenses ?? config?.allowedLicenses;
+  let directives: DirectiveRow[] = [];
+  let historicalDirectives: DirectiveRow[] = [];
+  const since = new Date(Date.parse(`${dateKey(now, { timeZone: 'Asia/Seoul' })}T00:00:00+09:00`)).toISOString();
+  try {
+    const index = openDirectiveIndex(stateDir);
+    try {
+      directives = index.dailyRequirements(since, now.toISOString());
+      historicalDirectives = index.dailyRequirements('1970-01-01T00:00:00.000Z', since);
+    } finally { index.close(); }
+  } catch (error) {
+    // Public builds have no directive index; the other doors still report.
+    debug.log('intake.requirement-funnel', 'directives-unavailable', { error: error instanceof Error ? error.message : String(error) });
+  }
+  const schedules = listSchedules();
+  const cells = schedules.flatMap(schedule => listChecklist(schedule.version).items.map(item => ({ version: schedule.version, item })));
+  const ledger = loadIntakeLedger(stateDir);
+  const day = dateKey(now, { timeZone: 'Asia/Seoul' });
+  const todayCount = cells.filter(({ item }) => {
+    const adoptedAt = item.evidence?.match(/ABSORB-ADOPT@(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z)/)?.[1];
+    return adoptedAt && dateKey(adoptedAt, { timeZone: 'Asia/Seoul' }) === day;
+  }).length;
+  const cardRequests: Record<'coordination' | 'linear', IncomingRequirement[]> = { coordination: [], linear: [] };
+  if (existsSync(cardIndexPath(stateDir))) {
+    const cards = new CardStore(stateDir, true);
+    try {
+      for (const card of cards.listCards()) {
+        const section = card.sections.find(entry => entry.key === 'intake');
+        if (!section) continue;
+        let raw: unknown;
+        try { raw = JSON.parse(section.content); } catch { continue; }
+        if (!raw || typeof raw !== 'object') continue;
+        const input = raw as { source?: string; text?: string; ref?: string; replyTo?: { surface?: string } };
+        const source = input.source === 'linear' ? 'linear' : input.source === 'coordination' ? 'coordination' : null;
+        if (!source || !input.text) continue;
+        cardRequests[source].push({ id: card.goalId, text: oneLine(input.text.split('\n')[0] ?? ''),
+          link: input.ref || card.goalId, receivedAt: card.createdAt });
+      }
+    } finally { cards.close(); }
+  }
+  const fromQueue = (name: string): IncomingRequirement[] => {
+    const path = join(stateDir, 'intake', name);
+    if (!existsSync(path)) return [];
+    return readFileSync(path, 'utf8').split('\n').flatMap(line => {
+      if (!line.trim()) return [];
+      try {
+        const value: unknown = JSON.parse(line);
+        if (!value || typeof value !== 'object') return [];
+        const row = value as Partial<IncomingRequirement> & { path?: string };
+        const item = row.id ? ledger.items.get(row.id) : undefined;
+        const text = row.text ?? item?.text ?? item?.title;
+        const link = row.link ?? item?.url ?? row.path;
+        const receivedAt = row.receivedAt ?? (row as { at?: string }).at ?? item?.observedAt;
+        return typeof row.id === 'string' && typeof text === 'string' && typeof link === 'string' && typeof receivedAt === 'string'
+          ? [{ ...row, id: row.id, text, link, receivedAt }] : [];
+      } catch { return []; }
+    });
+  };
+  // The grounding queue and the card store are cumulative; only today's rows are today's arrivals.
+  const today = (rows: readonly IncomingRequirement[]) => rows.filter(row => Date.parse(row.receivedAt) >= Date.parse(since));
+  return runRequirementFunnel({ sources: { directives, intake: [...ledger.items.values()].filter(item => Date.parse(item.observedAt) >= Date.parse(since)),
+    grounding: today(options.grounding ?? fromQueue('outbox/grounding.jsonl')),
+    coordination: today(options.coordination ?? cardRequests.coordination), linear: today(options.linear ?? cardRequests.linear) }, historicalDirectives, cells, now, mode,
+    dailyCap, adoptedToday: todayCount, allowedLicenses, placement: { ...options.placement, schedules },
+    adopt: (candidate, version, cellId, evidence) => {
+      placeCell({ id: cellId, title: candidate.text, owner: candidate.owner ?? 'OP', priority: candidate.priority ?? 'P1',
+        predecessors: [], ...(candidate.deadlineVersion ? { deadlineVersion: candidate.deadlineVersion } : {}) }, { ...options.placement, now, schedules });
+      setItem(version, cellId, { evidence: `${evidence} · ABSORB-ADOPT@${now.toISOString()}` }, 'OP');
+    } });
+}
+
+// ── `intake candidates` — 읽기 전용 요구 후보 목록(지시·흡수·소원 · 명시 루브릭만 점수) ──
+export interface FunnelCandidate {
+  source: 'directive' | 'intake' | 'wish';
+  id: string;
+  title: string;
+  score: number | null;
+  grade: 'P1' | 'P2' | 'P3' | 'P4' | null;
+}
+/** The candidate list keys directives by session — the funnel's local `DirectiveRow` plus the index's `session_id`. */
+export type FunnelDirectiveRow = DirectiveRow & { session_id: string };
+
+function funnelCandidate(source: FunnelCandidate['source'], id: string, title: string, original: string): FunnelCandidate {
+  const rubric = parseRubric(original);
+  const score = rubric === null ? null : rubricScore(rubric);
+  return { source, id, title: title.split(/\r?\n/, 1)[0]!.slice(0, 80), score, grade: score === null ? null : rubricGrade(score) };
+}
+
+export function collectFunnelCandidates({ directives, intakeItems, cards }: {
+  directives: readonly FunnelDirectiveRow[];
+  intakeItems: readonly IntakeItem[];
+  cards: readonly TaskCard[];
+}): FunnelCandidate[] {
+  return [
+    ...directives.map((row) => funnelCandidate('directive', `${row.session_id}:${row.line_no}`, row.text, row.text)),
+    ...intakeItems.filter((item) => item.status !== 'discarded')
+      .map((item) => funnelCandidate('intake', item.id, item.title ?? item.text ?? item.url ?? '', [item.title, item.text, item.url].filter(Boolean).join('\n'))),
+    ...cards.filter((card) => card.status === 'open' && card.goalId.startsWith('wish:'))
+      .map((card) => funnelCandidate('wish', card.goalId, card.title, card.title)),
+  ].sort((a, b) => a.score === null && b.score === null ? 0
+    : a.score === null ? 1 : b.score === null ? -1 : b.score - a.score);
+}

package/src/knowledge/know-find.ts

@@ -1,6 +1,6 @@
 import { createRequire } from 'node:module';
 import { LessonLedger, type LessonRow } from '../lessons/lesson-ledger.js';
-import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
+import { DecisionLedger, type DecisionEntry, type SeatDecisionRecord } from '../decisions/decision-ledger.js';
 import { devVersion, listChecklist, type Checklist } from '../release-loop/checklist.js';
 import { debug } from '../debug/log.js';
 
@@ -31,6 +31,7 @@ export interface KnowResult {
 export interface KnowFindDeps {
   directives: (query: string) => DirectiveRow[];
   decisions: () => DecisionEntry[];
+  seatDecisions: () => SeatDecisionRecord[];
   checklist: (version: string) => Checklist;
   lessons: (query: string) => LessonRow[];
   versions: () => string[];
@@ -49,6 +50,7 @@ const defaults: KnowFindDeps = {
     try { return index.search(query); } finally { index.close(); }
   },
   decisions: () => new DecisionLedger().list({ status: 'all' }),
+  seatDecisions: () => new DecisionLedger().seatReport(),
   checklist: (version) => listChecklist(version),
   lessons: (query) => new LessonLedger().find(query),
   versions,
@@ -84,6 +86,13 @@ export function knowFind(query: string, deps: Partial<KnowFindDeps> = {}): KnowR
         ref: row.refs?.[0] ?? `decisions show ${row.id}` });
     }
   });
+  attempt('decision', () => {
+    for (const row of read.seatDecisions()) {
+      if (!matches([row.title, row.decision, row.delegation].join(' '), words)) continue;
+      rows.push({ source: 'decision', id: row.id, title: row.title, status: 'seat-posthoc',
+        at: row.decidedAt ?? row.recordedAt, current: false, ref: `decisions seat-report --seat ${row.seat}` });
+    }
+  });
   attempt('checklist', () => {
     for (const version of new Set(read.versions())) {
       for (const row of read.checklist(version).items) {