elanous 0.2.6 → 0.2.8

package/src/intake-plane/intake-sources.ts

@@ -0,0 +1,202 @@
+import { randomUUID } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { findTrack } from '../autopilot/mission-phase-track.js';
+import { appendGithubStarSnapshots, collectGithubStars, ghApiSearchRepos, type SearchGithubRepos } from './collect-github.js';
+import { ingestIntakeItems, parseRawIntakeJsonl, type IntakeSource, type RegisteredIntakeSourceKind, type RawIntakeItem } from './items.js';
+
+export type SourceKind = 'github-query' | 'rss' | 'command';
+export interface RegisteredIntakeSource {
+  id: string;
+  seat: string;
+  kind: SourceKind;
+  spec: string;
+  every: string;
+  until?: string;
+  why?: string;
+  lastRunAt?: string;
+}
+
+export function canonicalSeat(value: string): string {
+  const seat = findTrack(value.trim());
+  if (!seat) throw new Error(`알 수 없는 자리: ${value}`);
+  return seat.id;
+}
+
+export function cadenceMs(every: string): number {
+  const match = /^([1-9]\d*)([hdw])$/.exec(every);
+  if (!match) throw new Error(`--every 는 Nh · Nd · Nw 형식이어야 한다: ${every}`);
+  const ms = Number(match[1]) * ({ h: 3600_000, d: 86_400_000, w: 604_800_000 }[match[2]!] ?? 0);
+  if (!Number.isSafeInteger(ms)) throw new Error(`--every 가 너무 크다: ${every}`);
+  return ms;
+}
+
+function untilMs(until: string): number {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(until) || !Number.isFinite(Date.parse(`${until}T00:00:00Z`))
+    || new Date(`${until}T00:00:00Z`).toISOString().slice(0, 10) !== until) throw new Error(`--until 날짜 형식 오류: ${until}`);
+  return Date.parse(`${until}T00:00:00Z`);
+}
+
+export function expiredSource(source: RegisteredIntakeSource, now: Date): boolean {
+  return source.until !== undefined && now.getTime() >= untilMs(source.until);
+}
+
+export function sourceIsDue(source: RegisteredIntakeSource, now: Date): boolean {
+  return !expiredSource(source, now) && (source.lastRunAt === undefined
+    || Date.parse(source.lastRunAt) + cadenceMs(source.every) <= now.getTime());
+}
+
+export function sourcesFile(stateDir: string): string { return join(stateDir, 'intake', 'sources.json'); }
+
+function readSources(stateDir: string): RegisteredIntakeSource[] {
+  const file = sourcesFile(stateDir);
+  if (!existsSync(file)) return [];
+  const parsed: unknown = JSON.parse(readFileSync(file, 'utf8'));
+  if (!Array.isArray(parsed)) throw new Error(`원천 등록부 모양 오류: ${file}`);
+  return parsed as RegisteredIntakeSource[];
+}
+
+function saveSources(stateDir: string, sources: RegisteredIntakeSource[]): void {
+  const file = sourcesFile(stateDir);
+  mkdirSync(join(stateDir, 'intake'), { recursive: true });
+  const temp = `${file}.${randomUUID()}.tmp`;
+  try {
+    const fd = openSync(temp, 'wx', 0o600);
+    try { writeFileSync(fd, JSON.stringify(sources, null, 2) + '\n'); } finally { closeSync(fd); }
+    chmodSync(temp, 0o600);
+    renameSync(temp, file);
+  } catch (error) {
+    if (existsSync(temp)) unlinkSync(temp);
+    throw error;
+  }
+}
+
+function commandArgv(spec: string): string[] {
+  // Shell syntax and interpreter wrappers are rejected; the allowed invocation uses execFileSync without a shell.
+  if (!spec.trim() || /["'\\`$;|&<>(){}\[\]*?\r\n]/.test(spec)) throw new Error('command spec 은 셸 구문 없이 실행 파일과 인자만 허용한다');
+  const argv = spec.trim().split(/\s+/);
+  // Allow-list, not deny-list (review R3): any other program (`nodejs scripts/x.ts`, a renamed wrapper) could emit
+  // private memos without a privacy mark. 1st edition: only the elanous CLI itself, whose intake commands mark privacy.
+  const executable = argv[0]!.split('/').pop()!.toLowerCase();
+  if (executable !== 'elanous' && executable !== 'eln') throw new Error('command 원천은 1판에서 elanous CLI(elanous·eln)만 받는다');
+  if (argv.some((arg) => /collect-telegram-saved/i.test(arg))) throw new Error('개인 메모(collect-telegram-saved)는 command 원천으로 등록할 수 없다');
+  return argv;
+}
+
+export function addSource(input: RegisteredIntakeSource, stateDir = effectiveInstanceRoot()): RegisteredIntakeSource {
+  const seat = canonicalSeat(input.seat);
+  if (!['github-query', 'rss', 'command'].includes(input.kind)) throw new Error(`알 수 없는 원천 종류: ${input.kind}`);
+  cadenceMs(input.every);
+  if (input.until !== undefined) untilMs(input.until);
+  if (!input.id?.trim() || !/^[\w.-]+$/.test(input.id)) throw new Error('원천 id 는 영문·숫자·_·-·. 만 허용한다');
+  if (!input.spec?.trim()) throw new Error('원천 spec 이 비었다');
+  if (input.kind === 'rss') {
+    let protocol = '';
+    try { protocol = new URL(input.spec).protocol; } catch { /* validation below */ }
+    if (protocol !== 'http:' && protocol !== 'https:') throw new Error('RSS spec 은 HTTP(S) URL 이어야 한다');
+  }
+  if (input.kind === 'command') commandArgv(input.spec);
+  const sources = readSources(stateDir);
+  if (sources.some((source) => source.id === input.id)) throw new Error(`이미 등록된 원천 id: ${input.id}`);
+  const source = { ...input, seat };
+  saveSources(stateDir, [...sources, source]);
+  return source;
+}
+
+export function listSources(filter: { seat?: string } = {}, stateDir = effectiveInstanceRoot()): RegisteredIntakeSource[] {
+  const seat = filter.seat === undefined ? undefined : canonicalSeat(filter.seat);
+  return readSources(stateDir).filter((source) => seat === undefined || source.seat === seat);
+}
+
+export function removeSource(id: string, stateDir = effectiveInstanceRoot()): boolean {
+  const sources = readSources(stateDir);
+  if (!sources.some((source) => source.id === id)) return false;
+  saveSources(stateDir, sources.filter((source) => source.id !== id));
+  return true;
+}
+
+export function dueSources(now: Date = new Date(), stateDir = effectiveInstanceRoot()): RegisteredIntakeSource[] {
+  return listSources({}, stateDir).filter((source) => sourceIsDue(source, now));
+}
+
+export interface RunDueDeps {
+  stateDir?: string;
+  searchGithub?: SearchGithubRepos;
+  fetchFeed?: (url: string) => Promise<string>;
+  runCommand?: (command: string) => Promise<string>;
+  ingest?: typeof ingestIntakeItems;
+}
+
+function xmlText(value: string): string {
+  return value.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1').replace(/<[^>]+>/g, '')
+    .replace(/&(?:amp|lt|gt|quot|apos|#(\d+)|#x([a-f\d]+));/gi, (entity, dec: string | undefined, hex: string | undefined) => {
+      if (dec || hex) return String.fromCodePoint(Number.parseInt(dec ?? hex!, dec ? 10 : 16));
+      return ({ '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"', '&apos;': "'" } as Record<string, string>)[entity.toLowerCase()] ?? entity;
+    }).trim();
+}
+
+export function parseFeed(xml: string): RawIntakeItem[] {
+  // A login page or broken XML is a failure, not «0 items» — otherwise lastRunAt moves and the retry waits a whole cycle (review R3).
+  const head = xml.replace(/^\uFEFF/, '').replace(/<\?xml[^>]*\?>/i, '').replace(/<!--[\s\S]*?-->/g, '').trimStart();
+  if (!/^<(?:rss|feed|rdf:RDF)\b/i.test(head)) throw new Error('RSS/Atom 피드가 아니다(루트가 rss·feed·rdf:RDF 아님)');
+  const entries = xml.match(/<(?:item|entry)\b[^>]*>[\s\S]*?<\/(?:item|entry)>/gi) ?? [];
+  return entries.map((entry) => {
+    const field = (name: string): string => xmlText(entry.match(new RegExp(`<${name}\\b[^>]*>([\\s\\S]*?)<\\/${name}>`, 'i'))?.[1] ?? '');
+    const link = entry.match(/<link\b[^>]*\bhref=["']([^"']+)["'][^>]*\/?\s*>/i)?.[1] ?? field('link');
+    return { url: xmlText(link), title: field('title'), text: field('description') || field('summary') || field('content'), kind: 'rss' as const };
+  }).filter((entry) => !!entry.url);
+}
+
+export async function runDue({ now = new Date(), seat, deps = {} }: { now?: Date; seat?: string; deps?: RunDueDeps } = {}): Promise<{ ran: Array<{ id: string; items: number; error?: string }> }> {
+  const stateDir = deps.stateDir ?? effectiveInstanceRoot();
+  const selectedSeat = seat === undefined ? undefined : canonicalSeat(seat);
+  const ran: Array<{ id: string; items: number; error?: string }> = [];
+  for (const source of dueSources(now, stateDir).filter((source) => selectedSeat === undefined || source.seat === selectedSeat)) {
+    try {
+      let raws: RawIntakeItem[];
+      let githubSnapshots: { day: string; repo: string; stars: number }[] | undefined;
+      let intakeSource: IntakeSource | RegisteredIntakeSourceKind;
+      if (source.kind === 'github-query') {
+        const collected = await collectGithubStars(stateDir, deps.searchGithub ?? ghApiSearchRepos, {
+          queries: [source.spec], day: now.toISOString().slice(0, 10), dryRun: true,
+        });
+        githubSnapshots = collected.repos.map((repo) => ({ day: collected.day, repo: repo.repo, stars: repo.stars }));
+        raws = collected.repos.map((repo) => ({ url: repo.url, title: repo.title, text: repo.text, kind: 'repo',
+          signals: { stars: repo.stars, ...(repo.starsDelta === undefined ? {} : { starsDelta: repo.starsDelta }),
+            ...(repo.starsPerDay === undefined ? {} : { starsPerDay: repo.starsPerDay }) } }));
+        intakeSource = 'github';
+      } else if (source.kind === 'rss') {
+        const feed = await (deps.fetchFeed ?? (async (url: string) => {
+          const response = await fetch(url, { signal: AbortSignal.timeout(30_000) });
+          if (!response.ok) throw new Error(`RSS HTTP ${response.status}`);
+          return response.text();
+        }))(source.spec);
+        raws = parseFeed(feed);
+        intakeSource = 'rss';
+      } else {
+        const argv = commandArgv(source.spec);
+        const stdout = await (deps.runCommand ?? (async () => execFileSync(argv[0]!, argv.slice(1), { encoding: 'utf8', timeout: 600_000, maxBuffer: 16 * 1024 * 1024 })))(source.spec);
+        const parsed = parseRawIntakeJsonl(stdout);
+        if (parsed.bad) throw new Error(`잘못된 JSONL ${parsed.bad}줄`);
+        if (parsed.raws.some((raw) => (raw as RawIntakeItem & { privacy?: string; source?: string }).privacy === 'user-private'
+          || ['memo', 'telegram-saved'].includes((raw as RawIntakeItem & { source?: string }).source ?? ''))) {
+          throw new Error('개인 메모(user-private)는 command 원천에서 받을 수 없다');
+        }
+        raws = parsed.raws;
+        intakeSource = 'command';
+      }
+      const items = (deps.ingest ?? ingestIntakeItems)(stateDir, intakeSource, raws.map((raw) => ({ ...raw, seat: source.seat })), now.toISOString()).shaped;
+      if (githubSnapshots) appendGithubStarSnapshots(stateDir, githubSnapshots);
+      // Re-read after each run so one failure cannot overwrite another source's successful timestamp.
+      const current = readSources(stateDir);
+      const found = current.find((entry) => entry.id === source.id);
+      if (found) saveSources(stateDir, current.map((entry) => entry.id === source.id ? { ...entry, lastRunAt: now.toISOString() } : entry));
+      ran.push({ id: source.id, items });
+    } catch (error) {
+      ran.push({ id: source.id, items: 0, error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return { ran };
+}

package/src/intake-plane/items.ts

@@ -4,19 +4,22 @@ import { createHash } from 'node:crypto';
 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';
 
 export const INTAKE_SOURCES = ['x', 'youtube', 'github', 'telegram-saved', 'telegram-bot', 'memo', 'pwa'] as const;
+export type RegisteredIntakeSourceKind = 'rss' | 'command';
 export type IntakeSource = typeof INTAKE_SOURCES[number];
-export type IntakeKind = 'video' | 'repo' | 'post' | 'article' | 'note';
+export type IntakeKind = 'video' | 'repo' | 'post' | 'article' | 'note' | 'rss';
 export type IntakePrivacy = 'public' | 'user-private';
 export const INTAKE_STATUSES = ['new', 'queued', 'absorbed', 'checked', 'routed', 'discarded', 'deferred'] as const;
 export type IntakeStatus = typeof INTAKE_STATUSES[number];
 
 export interface IntakeItem {
   id: string;
-  source: IntakeSource;
+  source: IntakeSource | RegisteredIntakeSourceKind;
   /** 같은 항목이 다른 입력원에서도 왔으면 여기 모인다 — «두 입력원에서 동시에 뜬 것»이 신호다. */
-  sources: IntakeSource[];
+  sources: (IntakeSource | RegisteredIntakeSourceKind)[];
+  seat?: string;
   url?: string;
   kind: IntakeKind;
   title?: string;
@@ -34,6 +37,7 @@ export interface IntakeItem {
 
 /** 수집기가 내는 한 줄 — 모양 맞추기 전. */
 export interface RawIntakeItem {
+  seat?: string;
   url?: string;
   title?: string;
   text?: string;
@@ -76,13 +80,23 @@ export function canonicalUrl(raw: string): string | undefined {
   return `https://${host}${path}${q}`;
 }
 
-export function intakeItemId(source: IntakeSource, raw: Pick<RawIntakeItem, 'url' | 'text'>): string {
+function normalizedSeat(seat: unknown): string | undefined {
+  if (seat === undefined) return undefined;
+  if (typeof seat !== 'string') throw new Error(`알 수 없는 자리: ${String(seat)}`);
+  const track = findTrack(seat.trim());
+  if (!track) throw new Error(`알 수 없는 자리: ${seat}`);
+  return track.id;
+}
+
+export function intakeItemId(source: IntakeSource | RegisteredIntakeSourceKind, raw: Pick<RawIntakeItem, 'url' | 'text'> & { seat?: string }): string {
+  const seat = normalizedSeat(raw.seat);
   const url = raw.url ? canonicalUrl(raw.url) : undefined;
   const basis = url ?? `${source}:${(raw.text ?? '').trim().slice(0, 200)}`;
-  return createHash('sha256').update(basis).digest('hex').slice(0, 16);
+  // Unassigned items retain their original IDs; assigned items have an independent lifecycle per seat.
+  return createHash('sha256').update(seat ? JSON.stringify([seat, basis]) : basis).digest('hex').slice(0, 16);
 }
 
-function kindFor(source: IntakeSource, url: string | undefined): IntakeKind {
+function kindFor(source: IntakeSource | RegisteredIntakeSourceKind, url: string | undefined): IntakeKind {
   if (url?.startsWith('https://www.youtube.com/')) return 'video';
   if (url?.startsWith('https://github.com/')) return 'repo';
   if (url?.startsWith('https://x.com/')) return 'post';
@@ -91,12 +105,13 @@ function kindFor(source: IntakeSource, url: string | undefined): IntakeKind {
 }
 
 /** 개인 메모 입력원은 user-private — 원문을 바깥 LLM 에 보내지 않는다(RFC §3.4). PWA 칸에 사람이 쓴 글도 같다(RFC-pwa-intake-front-door). */
-export function privacyFor(source: IntakeSource): IntakePrivacy {
+export function privacyFor(source: IntakeSource | RegisteredIntakeSourceKind): IntakePrivacy {
   return source === 'telegram-saved' || source === 'memo' || source === 'pwa' ? 'user-private' : 'public';
 }
 
 /** ① 모양 맞추기 — 수집기 한 줄 → IntakeItem. 비어 있으면(URL·본문 둘 다 없음) null. */
-export function shapeIntakeItem(source: IntakeSource, raw: RawIntakeItem, now: string): IntakeItem | null {
+export function shapeIntakeItem(source: IntakeSource | RegisteredIntakeSourceKind, raw: RawIntakeItem, now: string): IntakeItem | null {
+  const seat = normalizedSeat(raw.seat);
   const url = raw.url ? canonicalUrl(raw.url) : undefined;
   const text = raw.text?.trim() || undefined;
   if (!url && !text) return null;
@@ -104,9 +119,10 @@ export function shapeIntakeItem(source: IntakeSource, raw: RawIntakeItem, now: s
   const signals: Record<string, number> = {};
   for (const [k, v] of Object.entries(raw.signals ?? {})) if (Number.isFinite(v)) signals[`${source}.${k}`] = v;
   return {
-    id: intakeItemId(source, { url, text }),
+    id: intakeItemId(source, { url, text, seat }),
     source,
     sources: [source],
+    ...(seat ? { seat } : {}),
     ...(url ? { url } : {}),
     kind: raw.kind ?? kindFor(source, url),
     ...(raw.title?.trim() ? { title: raw.title.trim().slice(0, 300) } : {}),
@@ -155,7 +171,7 @@ const SETTLED: ReadonlySet<IntakeStatus> = new Set(['absorbed', 'discarded', 'ro
  * ② 중복 없애기 — 같은 id 는 새 항목을 만들지 않고 신호·입력원을 합친다.
  * 이미 흡수·버림·갈래가 끝난 것은 «seen» 으로 세고 상태를 되돌리지 않는다(다시 올리지 않는다).
  */
-export function ingestIntakeItems(instanceRoot: string, source: IntakeSource, raws: RawIntakeItem[], now = new Date().toISOString(),
+export function ingestIntakeItems(instanceRoot: string, source: IntakeSource | RegisteredIntakeSourceKind, raws: RawIntakeItem[], now = new Date().toISOString(),
   log: (event: string, data: Record<string, unknown>) => void = (e, d) => { debug.log('intake.normalize', e, d); }): IngestResult {
   const { items: existing, badLines } = loadIntakeLedger(instanceRoot);
   const result: IngestResult = { shaped: 0, added: 0, merged: 0, seen: 0, skipped: 0, badLines };
@@ -203,9 +219,9 @@ export function markIntakeItem(instanceRoot: string, id: string, patch: { status
   return true;
 }
 
-export function listIntakeItems(instanceRoot: string, filter: { status?: IntakeStatus; source?: IntakeSource } = {}): IntakeItem[] {
+export function listIntakeItems(instanceRoot: string, filter: { status?: IntakeStatus; source?: IntakeSource; seat?: string } = {}): IntakeItem[] {
   return [...loadIntakeLedger(instanceRoot).items.values()]
-    .filter((i) => (!filter.status || i.status === filter.status) && (!filter.source || i.sources.includes(filter.source)))
+    .filter((i) => (!filter.status || i.status === filter.status) && (!filter.source || i.sources.includes(filter.source)) && (!filter.seat || i.seat === filter.seat))
     .sort((a, b) => b.lastSeenAt.localeCompare(a.lastSeenAt));
 }
 

package/src/intake-plane/seat-answer.ts

@@ -0,0 +1,96 @@
+// EV12d — 계획기가 맞는 그래프를 못 고르면(«요청에 맞는 설치된 실행 그래프가 없습니다») «문서 요청 실패» 대신
+// 그 자리가 직접 답한다: 역할 파일(내부 문서 `<id>`) ⊕ 그 자리가 owner 인 체크리스트 칸 ⊕ 최근 요청 몇 줄을
+// 맥락으로 LLM 한 번 → 같은 채널 회신(본문). 맥락에 없는 것은 «모른다»고 답하게 한다(지어내지 않는다).
+import { existsSync, readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { debug } from '../debug/log.js';
+import { ExecRequestStore, type ExecRequest } from '../exec-requests/store.js';
+import { devVersion, listChecklist, type ChecklistItem } from '../release-loop/checklist.js';
+import { resolveSeat } from '../seat-address/seat-address.js';
+
+const ROLE_CHARS = 6_000;
+
+/** Cut by code points, never inside a surrogate pair. A `.slice` through an emoji (🎉 · 🟢) leaves a lone surrogate and
+ *  the model API rejects the whole request («Codex API 400: Bad Request» · 10-02 07:4x — every «@CMO …» question failed). */
+function cut(text: string, max: number): string {
+  const chars = Array.from(text);
+  return chars.length > max ? chars.slice(0, max).join('') : text;
+}
+const ITEM_LIMIT = 25;
+const RECENT_LIMIT = 5;
+
+export interface SeatAnswerDeps {
+  readRole?: (seatId: string) => string | null;
+  ownedItems?: (seatId: string) => ChecklistItem[];
+  recentRequests?: () => ExecRequest[];
+  complete?: (prompt: string) => Promise<string>;
+}
+
+function defaultReadRole(seatId: string): string | null {
+  const path = fileURLToPath(new URL(`../../docs/roles/${seatId}.md`, import.meta.url));
+  return existsSync(path) ? readFileSync(path, 'utf8') : null;
+}
+
+function nextPatch(version: string): string | null {
+  const m = /^(\d+)\.(\d+)\.(\d+)/.exec(version);
+  return m ? `${m[1]}.${m[2]}.${Number(m[3]) + 1}` : null;
+}
+
+/** Items this seat owns in the dev version's checklist and the next one (where 10-28 work lives). */
+function defaultOwnedItems(seatId: string): ChecklistItem[] {
+  const versions = [devVersion().replace(/-.*$/, '')];
+  const next = nextPatch(versions[0]!);
+  if (next) versions.push(next);
+  const items: ChecklistItem[] = [];
+  for (const version of versions) {
+    try { items.push(...listChecklist(version).items.filter((item) => item.owner === seatId)); }
+    catch { /* a version without a checklist contributes nothing */ }
+  }
+  return items;
+}
+
+async function defaultComplete(prompt: string): Promise<string> {
+  const { streamLLM } = await import('../llm.js');
+  const { tierModel } = await import('../llm/model-defaults.js');
+  return streamLLM([{ role: 'user', content: prompt }], () => {}, { model: tierModel('better') });
+}
+
+const STATUS_MARK: Record<string, string> = { green: '🟢', yellow: '🟡', red: '🔴', done: '✅' };
+
+export function seatAnswerPrompt(input: { title: string; seatId: string; question: string; role: string | null; items: ChecklistItem[]; recent: ExecRequest[] }): string {
+  const items = input.items.slice(0, ITEM_LIMIT)
+    .map((item) => `${STATUS_MARK[item.status] ?? item.status} ${item.id} ${cut(item.title, 140)}${item.evidence ? ` — 근거: ${cut(item.evidence, 160)}` : ''}`)
+    .join('\n') || '(담당 칸 없음)';
+  const recent = input.recent.slice(0, RECENT_LIMIT)
+    .map((request) => `${request.createdAt.slice(0, 16)} ${request.status} · ${cut(request.text.replace(/\s+/g, ' '), 120)}`)
+    .join('\n') || '(최근 요청 없음)';
+  return [
+    `너는 엘라누스 팀의 ${input.title}(${input.seatId}) 자리다. 아래 «역할 문서 · 담당 칸 · 최근 요청»만 근거로 질문에 답한다.`,
+    '규칙: 한국어 존댓말 · 12줄 이내 · 맥락에 없는 사실·수치·일정은 지어내지 말고 «모른다/확인 필요»라고 쓴다 · 담당 칸을 인용할 땐 칸 ID 를 붙인다 · 내부 파일 경로·토큰·계정은 쓰지 않는다.',
+    `\n## 역할 문서\n${cut(input.role ?? '(역할 문서 없음)', ROLE_CHARS)}`,
+    `\n## 담당 칸(체크리스트 owner=${input.seatId})\n${items}`,
+    `\n## 최근 자리 요청\n${recent}`,
+    `\n## 질문\n${input.question}`,
+  ].join('\n');
+}
+
+/** The seat's own answer, or null when the seat is unknown or the model gave nothing usable. */
+export async function answerAsSeat(seatAddress: string, question: string, deps: SeatAnswerDeps = {}): Promise<{ title: string; text: string } | null> {
+  const seat = resolveSeat(seatAddress);
+  if (!seat?.title) return null;
+  const role = (deps.readRole ?? defaultReadRole)(seat.id);
+  const items = (deps.ownedItems ?? defaultOwnedItems)(seat.id);
+  const recent = (deps.recentRequests ?? (() => new ExecRequestStore().list()))();
+  const raw = await (deps.complete ?? defaultComplete)(seatAnswerPrompt({ title: seat.title, seatId: seat.id, question, role, items, recent }));
+  const text = raw.trim();
+  debug.log('intake.seat-doc', 'seat-answer', { seat: seat.id, roleFile: role !== null, items: items.length, recent: Math.min(recent.length, RECENT_LIMIT), chars: text.length });
+  return text ? { title: seat.title, text: cut(text, 3_500) } : null;
+}
+
+/** «No installed graph fits» — the planner's own failure wording, so the seat should answer instead. */
+export function isNoGraphFailure(result: { status: string; summary?: string; seats?: Array<{ graphId: string; reason?: string }> } | null): boolean {
+  if (!result || result.status !== 'failed' || !result.seats?.length) return false;
+  if (!result.seats.every((seat) => !seat.graphId)) return false;
+  const NO_GRAPH = /설치된 실행 그래프가 없습니다/;
+  return NO_GRAPH.test(result.summary ?? '') || result.seats.some((seat) => NO_GRAPH.test(seat.reason ?? ''));
+}

package/src/intake-plane/seat-doc-route.ts

@@ -0,0 +1,221 @@
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { MissionOrigin } from '../autopilot/mission-origin.js';
+import { debug } from '../debug/log.js';
+import { sendOutbound } from '../domains/outbound-alert.js';
+import { defaultSpillUpload } from '../storage/content-spill.js';
+import { getElanousConfigDir } from '../elanous-config-dir.js';
+import type { ExecRequest } from '../exec-requests/store.js';
+import { resolveDaemonEndpoint } from '../nexus/daemon-endpoint.js';
+import { parseSeatAddress, resolveSeat } from '../seat-address/seat-address.js';
+import { answerAsSeat, isNoGraphFailure } from './seat-answer.js';
+
+const POLL_MS = 5_000;
+const TIMEOUT_MS = 30 * 60_000;
+const DOC = /전략|한\s*장|원페이저|기획|보도자료|글|메모|초안|\b(?:one-pager|strategy|post|memo|draft)\b/i;
+const CODE = /구현|버그|고쳐|\b(?:fix|implement|PR)\b/i;
+const RESEARCH = /전략|시장|경쟁|\bstrategy\b/i;
+/** EV12a — a question or a request for status / a report is answered, never turned into a code goal. */
+const ASK = /상황|현황|진행|준비|어때|어떻게|알려|보고|정리|요약|공유|\?|？|\b(?:status|update|report|summary|summari[sz]e|how|what)\b/i;
+/** Only an explicit build/fix verb makes a question a code request («버그 현황 알려줘» is still a report). */
+const CODE_ACTION = /구현|고쳐|수정해|만들어\s*줘|\b(?:fix|implement)\b/i;
+
+type ExecSnapshot = Pick<ExecRequest, 'status' | 'summary' | 'results'> & { seats?: ExecRequest['seats'] };
+type Source = { title: string; url: string };
+
+export interface SeatDocDeps {
+  research?: (body: string) => Promise<Source[]>;
+  submitExec?: (text: string) => Promise<{ id: string }>;
+  getExec?: (id: string) => Promise<ExecSnapshot | null>;
+  getFile?: (path: string) => Promise<string>;
+  publishFile?: (content: string, key: string) => string | null;
+  sendOutbound?: typeof sendOutbound;
+  sleep?: (ms: number) => Promise<void>;
+  now?: () => number;
+  pwaUrl?: () => string | undefined;
+  log?: (event: 'submitted' | 'research' | 'settled' | 'delivered' | 'delivery-failed' | 'seat-answer', data: Record<string, unknown>) => void;
+  /** EV12d — the seat's own answer when no installed graph fits (default = role file ⊕ owned checklist ⊕ recent, one LLM call). */
+  seatAnswer?: (seatAddress: string, question: string) => Promise<{ title: string; text: string } | null>;
+}
+
+export function isSeatDocRequest(text: string): boolean {
+  const addressed = parseSeatAddress(text);
+  if (!addressed || !addressed.seats.every(seat => !!resolveSeat(seat))) return false;
+  if (DOC.test(addressed.body) && !CODE.test(addressed.body)) return true;
+  return ASK.test(addressed.body) && !CODE_ACTION.test(addressed.body);
+}
+
+/** CO1 — anything addressed to the COO seat that is not a code request goes to the planner, which splits it across
+ *  seats (the A5 exec-request path), instead of becoming a code goal. */
+export function isCooPlannerRequest(text: string): boolean {
+  const addressed = parseSeatAddress(text);
+  return !!addressed && addressed.seats.some(seat => resolveSeat(seat)?.title === 'COO')
+    && addressed.seats.every(seat => !!resolveSeat(seat)) && !!addressed.body.trim() && !CODE.test(addressed.body);
+}
+
+async function research(body: string): Promise<Source[]> {
+  const cli = fileURLToPath(new URL('../../bin/elanous.mjs', import.meta.url));
+  const child = Bun.spawn([process.execPath, cli, '--test', 'research', '--json', '--limit', '5', body], {
+    stdout: 'pipe', stderr: 'ignore',
+  });
+  const [out, code] = await Promise.all([new Response(child.stdout).text(), child.exited]);
+  if (code !== 0) throw new Error(`research exit ${code}`);
+  const payload = JSON.parse(out) as { output?: unknown; metadata?: { totalHits?: number; perEngine?: Record<string, { error?: string }> } };
+  if (typeof payload.output !== 'string') throw new Error('research JSON output missing');
+  const sources = [...payload.output.matchAll(/^- \[([^\]\n]+)\]\((https?:\/\/[^\s)]+)\)/gm)]
+    .slice(0, 5).map(([, title, url]) => ({ title: title!, url: url! }));
+  if (!sources.length && (!payload.metadata?.totalHits || Object.values(payload.metadata.perEngine ?? {}).some(engine => engine.error))) {
+    throw new Error('research unavailable');
+  }
+  return sources;
+}
+
+function daemonUrl(): string {
+  const base = resolveDaemonEndpoint({ purpose: 'write' })?.baseUrl;
+  if (!base) throw new Error('실행 요청 데몬을 찾을 수 없습니다');
+  return base;
+}
+
+async function execResponse(path: string, text?: string): Promise<Response> {
+  const token = readFileSync(join(getElanousConfigDir(), 'acp-token'), 'utf8').trim();
+  const response = await fetch(`${daemonUrl()}/v1/exec-requests${path}`, {
+    method: text === undefined ? 'GET' : 'POST',
+    headers: { Authorization: `Bearer ${token}`, ...(text === undefined ? {} : { 'Content-Type': 'application/json' }) },
+    ...(text === undefined ? {} : { body: JSON.stringify({ text }) }),
+  });
+  if (!response.ok) throw new Error(`실행 요청 HTTP ${response.status}`);
+  return response;
+}
+
+async function execApi(path: string, text?: string): Promise<ExecRequest> {
+  return await (await execResponse(path, text)).json() as ExecRequest;
+}
+
+async function execFile(path: string): Promise<string> {
+  return (await execResponse(path.slice('/v1/exec-requests'.length))).text();
+}
+
+function chatPwaUrl(): string | undefined {
+  const endpoint = resolveDaemonEndpoint({ purpose: 'write' });
+  return endpoint?.pwaUrl;
+}
+
+function accessiblePwaUrl(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  try {
+    const url = new URL(value);
+    // The owner opens the authenticated PWA, not the bearer-only /v1/exec-requests/files endpoint.
+    // A loopback address works on the daemon host, not on the sender's phone.
+    if (url.protocol !== 'https:' || !url.hostname || url.hostname === 'localhost'
+      || url.hostname === '127.0.0.1' || url.hostname === '0.0.0.0'
+      || url.username || url.password || url.pathname !== '/app/' || url.search || url.hash) return undefined;
+    return url.toString();
+  } catch { return undefined; }
+}
+
+async function fileLinks(id: string, result: ExecSnapshot, deps: SeatDocDeps): Promise<Map<string, string>> {
+  const links = new Map<string, string>();
+  for (const entry of result.results) {
+    if (entry.kind !== 'report' && entry.kind !== 'text') continue;
+    if (!entry.url.startsWith(`/v1/exec-requests/${encodeURIComponent(id)}/files/`)) continue;
+    try {
+      // The authenticated daemon route is the only source of bytes; a raw file path is never trusted.
+      const content = await (deps.getFile ?? execFile)(entry.url);
+      const ext = entry.kind === 'report' ? 'md' : 'txt';
+      const digest = createHash('sha256').update(content).digest('hex');
+      const key = `seat-doc/${encodeURIComponent(id)}/${digest}.${ext}`;
+      const url = (deps.publishFile ?? ((value, path) => defaultSpillUpload(value, path, ext)))(content, key);
+      if (url && /^https:\/\/[^/]+/.test(url)) links.set(entry.url, url);
+      else links.set(entry.url, `\n${content}`);
+    } catch (error) {
+      debug.log('intake.seat-doc', 'file-link-failed', { id, reason: String(error).slice(0, 200) });
+    }
+  }
+  return links;
+}
+
+function message(id: string, result: ExecSnapshot | null, withoutResearch: boolean, lookupAvailable: boolean, pwaUrl?: string, links = new Map<string, string>()): string {
+  const suffix = withoutResearch ? '\n조사 없이 진행했습니다.' : '';
+  const location = pwaUrl ? `PWA 에서 확인: ${pwaUrl} (접수번호 ${id})` : `PWA 에서 확인 (접수번호 ${id} · 외부 접속 주소 없음)`;
+  if (!result) return `${lookupAvailable ? '아직 도는 중' : '상태를 확인할 수 없어 확인을 종료했습니다'} · ${location}${suffix}`;
+  if (result.status === 'failed') {
+    const reason = result.summary || result.seats?.find(seat => seat.reason)?.reason || '실행 요청 실패';
+    return `문서 요청 실패 — ${reason.split('\n')[0]!.slice(0, 200)} · ${location}${suffix}`;
+  }
+  const summary = result.summary?.split('\n')[0]?.slice(0, 200) || '문서 요청 완료';
+  // File endpoints require an Authorization header even when opened from the same origin.
+  // Only send externally usable links for genuinely external artifacts; file names remain findable in the PWA.
+  const artifacts = result.results.map(entry => `${entry.title} (${entry.kind})${links.has(entry.url) ? ` · ${links.get(entry.url)}` : entry.kind === 'link' && /^https?:\/\//i.test(entry.url) ? ` · ${entry.url}` : ''}`);
+  return `${summary}\n${artifacts.join('\n')}${artifacts.length ? '\n' : ''}${location}${suffix}`;
+}
+
+export async function submitSeatDocRequest({ text, reportTo, deps = {} }: {
+  text: string; reportTo?: MissionOrigin; deps?: SeatDocDeps;
+}): Promise<{ id: string }> {
+  const log = deps.log ?? ((event: Parameters<NonNullable<SeatDocDeps['log']>>[0], data: Record<string, unknown>) => debug.log('intake.seat-doc', event, data));
+  const body = parseSeatAddress(text)?.body.trim() ?? text.trim();
+  let withoutResearch = false;
+  let requestText = text;
+  if (RESEARCH.test(body)) {
+    try {
+      const sources = (await (deps.research ?? research)(body)).slice(0, 5);
+      if (sources.length) requestText += `\n\n참고 자료\n${sources.map(source => `${source.title} · ${source.url}`).join('\n')}`;
+      log('research', { count: sources.length });
+    } catch (error) {
+      withoutResearch = true;
+      log('research', { failed: true, reason: String(error).slice(0, 200) });
+    }
+  }
+  const { id } = await (deps.submitExec ?? ((value) => execApi('', value)))(requestText);
+  if (!id) throw new Error('실행 요청 접수번호가 없습니다');
+  log('submitted', { id });
+
+  const watch = async () => {
+    const now = deps.now ?? Date.now;
+    const sleep = deps.sleep ?? ((ms: number) => new Promise<void>(resolve => setTimeout(resolve, ms)));
+    const deadline = now() + TIMEOUT_MS;
+    let result: ExecSnapshot | null = null;
+    let lookupAvailable = false;
+    let lastConfirmedStatus: ExecSnapshot['status'] | undefined;
+    while (now() < deadline) {
+      try {
+        const snapshot = await (deps.getExec ?? ((key) => execApi(`/${encodeURIComponent(key)}`)))(id);
+        if (!snapshot) throw new Error('실행 요청을 찾을 수 없습니다');
+        lookupAvailable = true;
+        lastConfirmedStatus = snapshot.status;
+        if (snapshot.status === 'done' || snapshot.status === 'failed') {
+          result = snapshot;
+          break;
+        }
+      } catch (error) {
+        lookupAvailable = false;
+        debug.log('intake.seat-doc', 'poll-error', { id, reason: String(error).slice(0, 200) });
+      }
+      if (now() < deadline) await sleep(Math.min(POLL_MS, Math.max(0, deadline - now())));
+    }
+    log('settled', { id, status: result?.status ?? (lookupAvailable ? 'timeout' : 'lookup-unavailable'), lastConfirmedStatus });
+    const links = result?.status === 'done' ? await fileLinks(id, result, deps) : new Map<string, string>();
+    let reply = message(id, result, withoutResearch, lookupAvailable, accessiblePwaUrl((deps.pwaUrl ?? chatPwaUrl)()), links);
+    if (isNoGraphFailure(result)) {
+      // EV12d — a question with no fitting graph gets the seat's own answer, not «문서 요청 실패».
+      const seat = result!.seats![0]!.seat;
+      try {
+        const answer = await (deps.seatAnswer ?? answerAsSeat)(seat, body);
+        if (answer) reply = `${answer.title} 답 (접수번호 ${id})\n${answer.text}`;
+        log('seat-answer', { id, seat, answered: !!answer });
+      } catch (error) {
+        log('seat-answer', { id, seat, answered: false, reason: String(error).slice(0, 200) });
+      }
+    }
+    try {
+      const sent = await (deps.sendOutbound ?? sendOutbound)(reply, 'report', reportTo);
+      log(sent ? 'delivered' : 'delivery-failed', { id });
+    } catch (error) {
+      log('delivery-failed', { id, reason: String(error).slice(0, 200) });
+    }
+  };
+  void watch();
+  return { id };
+}