elanous 0.2.16 → 0.2.18

package/src/intake-plane/digest.ts

@@ -8,7 +8,7 @@ import { intakeOutboxDir, kstDay } from './route.js';
 
 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 } }
+export interface IntakeDigest { day: string; absorbed: DigestEntry[]; goals: { fact: string; url?: string }[]; news?: { title: string; url: string; summary: string[]; implication: string[] }[]; shadowSuggestions?: { fact: string; url?: string; verdict: 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: '그 밖',
@@ -82,12 +82,24 @@ export function buildIntakeDigest(root: string, day: string, readFile: (p: strin
     };
   });
   const goals = readJsonl(join(out, 'goals', `${day}.jsonl`)).map((g) => ({ fact: String(g.fact ?? ''), ...(g.url ? { url: String(g.url) } : {}) }));
+  const lensRows = readJsonl(join(out, 'lens', `${day}.jsonl`));
+  const news = lensRows.flatMap((row) =>
+    typeof row.title === 'string' && typeof row.url === 'string' && Array.isArray(row.summary) && Array.isArray(row.implication)
+      ? [{ title: row.title, url: row.url, summary: row.summary.filter((s): s is string => typeof s === 'string'), implication: row.implication.filter((s): s is string => typeof s === 'string') }]
+      : []);
+  const shadowSuggestions = lensRows.flatMap((row) =>
+    Array.isArray(row.suggestions) ? row.suggestions.flatMap((raw: unknown) => {
+      if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return [];
+      const suggestion = raw as Record<string, unknown>;
+      if (suggestion.status !== '제안' || typeof suggestion.fact !== 'string' || !suggestion.fact.trim()) return [];
+      return [{ fact: suggestion.fact, ...(typeof row.url === 'string' ? { url: row.url } : {}), verdict: typeof suggestion.verdict === 'string' ? suggestion.verdict : '판단 필요' }];
+    }) : []);
   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,
+    day, absorbed, goals, ...(news.length ? { news } : {}), ...(shadowSuggestions.length ? { shadowSuggestions } : {}), 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 } } : {}),
@@ -98,7 +110,8 @@ export function buildIntakeDigest(root: string, day: string, readFile: (p: strin
 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'); }
+  if (!d.absorbed.length) L.push('오늘 흡수한 것이 없다.', '');
+  if (!d.absorbed.length && !d.news?.length) 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) {
@@ -106,11 +119,25 @@ export function renderDigestMarkdown(d: IntakeDigest): string {
     for (const e of rows) L.push(`- ${e.noteName ? `[[${e.noteName}]]` : e.url ?? e.id} — ${e.oneLiner ?? '(요약 줄 없음)'}`);
     L.push('');
   }
+  if (d.news?.length) {
+    L.push(`### 📰 관심 뉴스 (${d.news.length})`, '');
+    for (const article of d.news.slice(0, 10)) {
+      L.push(`- [${article.title}](${article.url})`);
+      for (const line of article.summary) L.push(`  - ${line}`);
+      for (const line of article.implication) L.push(`  - 엘라누스 함의: ${line}`);
+    }
+    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.shadowSuggestions?.length) {
+    L.push(`### 📰 뉴스 칸 제안 — 그림자, 판 미등록 (${d.shadowSuggestions.length})`, '');
+    for (const s of d.shadowSuggestions.slice(0, 10)) L.push(`- [${s.verdict}] ${s.fact}${s.url ? ` · [원본](${s.url})` : ''}`);
+    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/\``, '');
@@ -122,7 +149,15 @@ export function renderDigestTelegram(d: IntakeDigest, _opts: { vaultRoot?: strin
   // «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];
+  // 관심 뉴스는 최대 셋 — 기사마다 S(요약 첫 줄) · A(엘라누스 함의 첫 줄) · 링크를 한 덩어리로(NEWS-INTAKE).
+  for (const article of (d.news ?? []).slice(0, 3)) {
+    L.push(`📰 ${article.title}`);
+    if (article.summary[0]) L.push(`S: ${article.summary[0]}`);
+    if (article.implication[0]) L.push(`A: ${article.implication[0]}`);
+    L.push(article.url);
+  }
+  if (d.shadowSuggestions?.length) L.push(`뉴스 칸 제안 ${d.shadowSuggestions.length}건 (그림자·판 미등록): ${d.shadowSuggestions.slice(0, 3).map((s) => `[${s.verdict}] ${s.fact}${s.url ? ` ${s.url}` : ''}`).join(' · ')}`);
+  if (!touching.length) return L.join('\n');
   // 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).

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) {

package/src/loops/budget.ts

@@ -61,3 +61,39 @@ export function decideSpawn({ seat, running, caps, gate, injectedCap }: SpawnBud
     ? { allow: true, reason: 'within-cap', cap }
     : { allow: false, reason: 'seat-cap', cap };
 }
+
+/** SEAT-CAP-STALE: why a run or a queue row is left out of a seat's running count (counting only — nothing is stopped). */
+export type SeatCapExclusionReason = 'stale' | 'soft-stopped' | 'unknown-seat' | 'dead-row';
+export const SEAT_CAP_STALE_RUN_MINUTES = 30;
+export const SEAT_CAP_UNKNOWN_SEAT_CAP = 2;
+/** A just-launched row has no process yet; it keeps its seat for this long. */
+export const SEAT_CAP_LAUNCH_GRACE_MINUTES = 5;
+
+export type SeatCapSubject =
+  | { kind: 'run'; seat?: OrchestratorSeat; progressAt?: number; stopReason?: string }
+  | { kind: 'row'; status: string; receipt: 'started' | 'finished' | 'not-started' | null; live: boolean; launchedAt?: number };
+
+export type SeatCapExclusion = { reason: SeatCapExclusionReason; idleMin: number | null } | null;
+
+/**
+ * Pure judgement: null = the subject holds a seat. A run without a seat goes to the unknown-seat bucket; a run whose
+ * supervisor already stopped (awaiting harvest) or whose last progress is older than staleRunMinutes is excluded; a
+ * launched row with no live process past the launch grace is a dead row. A run with no progress signal still counts.
+ */
+export function seatCapExclusion(subject: SeatCapSubject, now: number,
+  { staleRunMinutes = SEAT_CAP_STALE_RUN_MINUTES, launchGraceMinutes = SEAT_CAP_LAUNCH_GRACE_MINUTES }:
+  { staleRunMinutes?: number; launchGraceMinutes?: number } = {}): SeatCapExclusion {
+  const minutes = (at: number | undefined): number | null =>
+    at !== undefined && Number.isFinite(at) ? Math.max(0, Math.floor((now - at) / 60_000)) : null;
+  if (subject.kind === 'row') {
+    if (subject.status !== 'launched' && subject.status !== 'launching') return null;
+    if (subject.live || subject.receipt === 'finished' || subject.receipt === 'not-started') return null;
+    const idle = minutes(subject.launchedAt);
+    return idle !== null && now - subject.launchedAt! >= launchGraceMinutes * 60_000 ? { reason: 'dead-row', idleMin: idle } : null;
+  }
+  const idle = minutes(subject.progressAt);
+  if (!subject.seat) return { reason: 'unknown-seat', idleMin: idle };
+  if (subject.stopReason) return { reason: 'soft-stopped', idleMin: idle };
+  if (idle !== null && now - subject.progressAt! >= staleRunMinutes * 60_000) return { reason: 'stale', idleMin: idle };
+  return null;
+}

package/src/loops/orchestrator/finish-rate.ts

@@ -1,8 +1,9 @@
 import { execFileSync } from 'node:child_process';
-import { readdirSync, realpathSync, statSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { debug } from '../../debug/log.js';
 import { loadRunLedger, resolveFederatedRunLedgerTargets } from '../../self-implement/run-ledger.js';
+import { withFileLockSync } from '../../storage/file-lock.js';
 import type { LogTarget } from '../../cli/logs-cli.js';
 
 const DAY_MS = 24 * 60 * 60 * 1_000;
@@ -24,6 +25,77 @@ export type FinishMetrics = {
 export type FinishAdvice = { finishSlots: number; launchSlots: number; state: 'healthy' | 'backlogged' | 'unknown'; reasons: string[] };
 export type FinishThresholds = { landingRate?: number; staleDrafts?: number; conflictRatio?: number };
 
+export type FinishTrend = 'worsening' | 'improving' | 'flat' | 'unknown';
+export type FinishTrendInput = Pick<FinishMetrics, 'landingRate' | 'staleDrafts' | 'conflictRatio'>;
+export type FinishHistoryRow = {
+  hour: string; at: string; launched: number | null; landed: number | null;
+  landingRate: number | null; staleDrafts: number | null; conflictRatio: number | null; trend: FinishTrend;
+};
+
+/** FINISH-RATE 추세 — landingRate 는 내려가면 나쁨 · staleDrafts·conflictRatio 는 올라가면 나쁨.
+ *  양쪽 다 유한한 숫자인 지표만 비교한다(못 잰 값은 좋음도 나쁨도 아니다) · 임의 임계 없음.
+ *  나쁨 수 > 좋음 수 = worsening · 작으면 improving · 같으면 flat · 비교한 지표가 0 이면 unknown. */
+export function finishTrend(previous: FinishTrendInput | null, current: FinishTrendInput): FinishTrend {
+  if (!previous) return 'unknown';
+  let compared = 0, worse = 0, better = 0;
+  for (const key of ['landingRate', 'staleDrafts', 'conflictRatio'] as const) {
+    const before = previous[key], after = current[key];
+    if (typeof before !== 'number' || !Number.isFinite(before) || typeof after !== 'number' || !Number.isFinite(after)) continue;
+    compared++;
+    const delta = key === 'landingRate' ? before - after : after - before;
+    if (delta > 0) worse++;
+    else if (delta < 0) better++;
+  }
+  if (compared === 0) return 'unknown';
+  return worse > better ? 'worsening' : worse < better ? 'improving' : 'flat';
+}
+
+export function finishHistoryPath(root: string): string {
+  return join(root, 'harness', 'finish-history.jsonl');
+}
+
+/** «한 시간 한 줄» 이력 — 같은 UTC 시간 줄이 이미 있으면 안 쓴다(null) · trend 는 지금보다 이른 가장 최근 시간 줄 대비.
+ *  읽을 수 없는 줄은 건너뛴다(이력 한 줄이 깨졌다고 측정을 멈추지 않는다). 쓰기 실패는 호출자에게 던진다. */
+export function recordFinishHistory(root: string, metrics: FinishMetrics, now: Date): FinishHistoryRow | null {
+  const path = finishHistoryPath(root);
+  const hour = now.toISOString().slice(0, 13);
+  mkdirSync(join(root, 'harness'), { recursive: true });
+  // 확인과 덧붙이기를 한 잠금 안에서 — 같은 root 를 쓰는 두 틱이 같은 시간에 둘 다 «없음»을 보고 두 줄을 쓰지 않게.
+  const row = withFileLockSync(`${path}.lock`, (): FinishHistoryRow | null => {
+    const rows: FinishHistoryRow[] = [];
+    let text = '';
+    if (existsSync(path)) {
+      text = readFileSync(path, 'utf8');
+      for (const line of text.split('\n')) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line) as FinishHistoryRow;
+          if (parsed && typeof parsed.hour === 'string') rows.push(parsed);
+        } catch { /* a broken line is skipped */ }
+      }
+    }
+    if (rows.some((existing) => existing.hour === hour)) return null;
+    // 앞 시간 = 지금보다 이른 줄 중 «가장 최근 UTC 시간»(파일 순서가 아니다 — 늦게 덧붙은 옛 시간 줄이 있을 수 있다) · 같은 시간이면 마지막 줄.
+    let previous: FinishHistoryRow | null = null;
+    for (const existing of rows) if (existing.hour < hour && (!previous || existing.hour >= previous.hour)) previous = existing;
+    const next: FinishHistoryRow = {
+      hour, at: now.toISOString(), launched: metrics.launched, landed: metrics.landed,
+      landingRate: metrics.landingRate, staleDrafts: metrics.staleDrafts, conflictRatio: metrics.conflictRatio,
+      trend: finishTrend(previous, metrics),
+    };
+    // 부분 쓰기로 끝 개행이 없으면 먼저 보정한다 — 새 줄이 깨진 꼬리에 붙어 둘 다 못 읽게 되지 않게.
+    appendFileSync(path, `${text && !text.endsWith('\n') ? '\n' : ''}${JSON.stringify(next)}\n`);
+    return next;
+  });
+  if (!row) return null;
+  try {
+    debug.log('loop.orchestrator', 'finish-history', {
+      hour, trend: row.trend, landingRate: row.landingRate, staleDrafts: row.staleDrafts, conflictRatio: row.conflictRatio,
+    });
+  } catch { /* the row is written; observation is fail-soft */ }
+  return row;
+}
+
 type Start = { runId: string; startedAt: string };
 type StartObservation = { starts: readonly Start[]; unreadable: readonly { runId: string; reason: string }[]; unreadableDirectories?: number };
 type Pr = { number: number; headRefName: string; mergedAt?: string; createdAt?: string; mergeable?: string; labels?: { name: string }[] };

package/src/loops/orchestrator/grid-place.ts

@@ -0,0 +1,11 @@
+interface GridCell { kind?: string }
+export interface GridHost { name: string; capabilities: ReadonlySet<string>; available: boolean }
+
+/** A proposal only: the caller owns the host inventory and the actual launch. */
+export function placeOnGrid(cell: GridCell, hosts: readonly GridHost[]): { host: string; reason?: never } | { host: null; reason: string } {
+  const kind = cell.kind ?? 'unknown';
+  const host = hosts.find(candidate => candidate.available && candidate.capabilities.has(kind));
+  if (host) return { host: host.name };
+  return { host: null, reason: hosts.some(candidate => candidate.capabilities.has(kind))
+    ? `no available host for ${kind}` : `no host with ${kind} capability` };
+}