elanous 0.2.5 → 0.2.7

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-doc-route.ts

@@ -0,0 +1,207 @@
+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';
+
+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', data: Record<string, unknown>) => void;
+}
+
+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>();
+    try {
+      const sent = await (deps.sendOutbound ?? sendOutbound)(message(id, result, withoutResearch, lookupAvailable,
+        accessiblePwaUrl((deps.pwaUrl ?? chatPwaUrl)()), links), 'report', reportTo);
+      log(sent ? 'delivered' : 'delivery-failed', { id });
+    } catch (error) {
+      log('delivery-failed', { id, reason: String(error).slice(0, 200) });
+    }
+  };
+  void watch();
+  return { id };
+}

package/src/intake-plane/submit-intake-work.ts

@@ -4,7 +4,7 @@
  *
  * - absorb → 흡수 원장(`ingestIntakeItems`) — URL 이 있으면 URL 마다, 없으면 글 한 덩이(PWA `absorbItemsFromText` 와 같은 규칙).
  * - tasks  → TOX(`dispatchTaskCreate`) — 외부 출처(텔레그램 등)는 `external` 로 실어 M1(backlog ⊕ 승인 대기)을 탄다.
- * - graph  → 하니스 ask(`handleHarnessAskPost` 를 요청 하나로 부른다 — 흐름을 복제하지 않는다).
+ * - graph  → 자리 문서 요청은 A5 실행 요청, 나머지는 하니스 ask(`handleHarnessAskPost`).
  * - ask-human → 실행하지 않는다. 고를 갈래를 돌려준다.
  *
  * 로그엔 원문이 아니라 길이만 남긴다(앞문 RFC · `user-private`).
@@ -16,6 +16,7 @@ import type { ExternalTaskSource } from '../task-orchestrator/types.js';
 import { TASK_DEFAULTS } from '../task-orchestrator/types.js';
 import { decideIntakeFrontRoute, type IntakeFrontRouteDecision } from './front-route-rules.js';
 import { ingestIntakeItems, intakeItemId, type IntakeSource, type RawIntakeItem } from './items.js';
+import { isCooPlannerRequest, isSeatDocRequest, submitSeatDocRequest, type SeatDocDeps } from './seat-doc-route.js';
 
 export type IntakeWorkTrack = 'absorb' | 'tasks' | 'graph';
 
@@ -40,6 +41,8 @@ export interface SubmitIntakeWorkDeps {
   ingest?: typeof ingestIntakeItems;
   createTask?: (input: CreateTaskInput) => Promise<{ taskId?: string; deduplicated?: boolean; output: string }>;
   askHarness?: (text: string, origin?: MissionOrigin) => Promise<{ acceptanceId?: string; error?: string }>;
+  seatDoc?: typeof submitSeatDocRequest;
+  seatDocDeps?: SeatDocDeps;
   handleHarnessAskPost?: typeof import('../nexus/api/harness-api.js').handleHarnessAskPost;
   log?: (event: string, data: Record<string, unknown>) => void;
 }
@@ -130,6 +133,11 @@ export async function submitIntakeWork(
       return { ok: true, track: 'tasks', taskId: res.taskId, deduplicated: res.deduplicated ?? false };
     }
     const reportTo = input.origin.kind === 'external' ? input.origin.reportTo : undefined;
+    if (isSeatDocRequest(text) || isCooPlannerRequest(text)) {
+      const { id } = await (deps.seatDoc ?? submitSeatDocRequest)({ text, reportTo, deps: deps.seatDocDeps });
+      log('submitted', { ...base, acceptanceId: id });
+      return { ok: true, track: 'graph', acceptanceId: id };
+    }
     const res = await (deps.askHarness ? deps.askHarness(text, reportTo) : defaultAskHarness(text, reportTo, deps.handleHarnessAskPost));
     if (!res.acceptanceId) {
       log('failed', { ...base, reason: res.error ?? 'no-acceptance-id' });

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

@@ -0,0 +1,72 @@
+import { debug } from '../debug/log.js';
+import { parseSeatAddress, resolveSeat } from '../seat-address/seat-address.js';
+import {
+  submitIntakeWork,
+  type SubmitIntakeWorkDeps,
+} from './submit-intake-work.js';
+import type { TelegramWorkMessage } from './telegram-work.js';
+
+export interface TelegramSeatWorkDeps extends SubmitIntakeWorkDeps {
+  submit?: typeof submitIntakeWork;
+}
+
+/** Addressed Telegram work goes through graph intake, not the chat turn. */
+export async function handleTelegramSeatWork(
+  text: string,
+  msg: TelegramWorkMessage,
+  deps: TelegramSeatWorkDeps = {},
+): Promise<string | null> {
+  if (!text.startsWith('@')) return null;
+  const address = parseSeatAddress(text);
+  if (!address) return null;
+
+  const seats = address.seats.map((name) => ({ name, seat: resolveSeat(name) }));
+  const names = address.seats;
+  debug.log('seat-address.telegram', 'parsed', { seats: names });
+  const unknown = seats.filter(({ seat }) => !seat).map(({ name }) => `@${name}`);
+  if (unknown.length) {
+    debug.log('seat-address.telegram', 'rejected', { seats: names, reason: 'unknown-seat' });
+    return `어느 좌석을 말씀하시나요? ${unknown.join(', ')}은(는) 등록된 좌석이 아닙니다. 좌석을 확인해 다시 보내 주세요.`;
+  }
+  const body = address.body.trim();
+  if (!body) {
+    debug.log('seat-address.telegram', 'rejected', { seats: names, reason: 'empty-body' });
+    return '어떤 일을 맡길까요? 좌석 주소 뒤에 요청 내용을 적어 다시 보내 주세요.';
+  }
+
+  const reportTo = {
+    channel: 'telegram' as const,
+    chatId: msg.chatId,
+    ...(msg.botId ? { botId: msg.botId } : {}),
+    ...(msg.threadId ? { threadId: msg.threadId } : {}),
+  };
+  const replies: string[] = [];
+  for (const { seat } of seats) {
+    if (!seat) continue;
+    const label = seat.title ?? seat.id;
+    let result: Awaited<ReturnType<typeof submitIntakeWork>>;
+    try {
+      result = await (deps.submit ?? submitIntakeWork)({
+        text: `@${label} ${body}`,
+        track: 'graph',
+        origin: {
+          kind: 'external', ledgerSource: 'telegram-bot', provider: 'telegram',
+          ref: `telegram:${msg.chatId}:${msg.messageId}`, reportTo,
+        },
+      }, deps);
+    } catch (error) {
+      // 접수 문이 던져도 사람은 같은 대화에서 결과를 받는다(리뷰 must-fix: 예외 시 응답 누락).
+      debug.log('seat-address.telegram', 'rejected', { seats: [label], reason: 'submission-threw' });
+      replies.push(`@${label} 접수 실패 — ${String(error instanceof Error ? error.message : error).split('\n')[0]!.slice(0, 200)}`);
+      continue;
+    }
+    if (result.ok && result.track === 'graph') {
+      debug.log('seat-address.telegram', 'enqueued', { seats: [label] });
+      replies.push(`@${label} 접수번호: ${result.acceptanceId}`);
+    } else {
+      debug.log('seat-address.telegram', 'rejected', { seats: [label], reason: 'submission-failed' });
+      replies.push(`@${label} 접수 실패 — ${result.ok ? '접수번호가 없습니다' : result.reason.split('\n')[0]!.slice(0, 200)}`);
+    }
+  }
+  return replies.join('\n');
+}