elanous 0.2.5 → 0.2.7

package/src/domains/outbound-alert.ts

@@ -6,7 +6,8 @@
 
 import * as childProcess from 'node:child_process';
 import { existsSync, readFileSync, appendFileSync, mkdirSync, unlinkSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { dirname, join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { getElanousConfigDir } from '../elanous-config-dir.js';
 import { conatusEnv } from './conatus-env.js';
 import { spillLongContent } from '../storage/content-spill.js';
@@ -54,7 +55,7 @@ function recentSendBurst(): { recentCount: number; burst: boolean } {
 
 /** 발송 1건을 logs.db 에 관측(fail-open) — 발송 시각·mode·kind·밀림 판정. */
 function logSend(
-  mode: 'realtime' | 'deferred' | 'quiet-bypass' | 'flush',
+  mode: 'realtime' | 'quiet-bypass' | 'flush',
   kind: string,
   extra: Record<string, unknown> = {},
   opts?: { level?: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'critical' },
@@ -111,15 +112,16 @@ export function userRecentlyActive(now: Date = new Date()): boolean {
 
 /** 야간 보류 적재 (jsonl append — 크론 동시 실행에 안전). origin 있으면 함께 적재 —
  *  아침 flush 가 그 origin(발신 채널)으로 되돌려 발송(없으면 report 묶음). */
-function deferOutbound(text: string, kind: string, origin?: MissionOrigin | null, path = DEFERRED_PATH): void {
+function deferOutbound(text: string, kind: string, origin?: MissionOrigin | null, path = DEFERRED_PATH): boolean {
   try {
     mkdirSync(dirname(path), { recursive: true });
     const rec = { ts: new Date().toISOString(), kind, text, ...(origin ? { origin } : {}) };
     appendFileSync(path, JSON.stringify(rec) + '\n');
-    console.log(`[outbound] 야간 무음(00:00~06:30 KST) — 보류 적재 (${kind})`);
-    logSend('deferred', kind, { reason: 'quiet-hours' });  // 밀림 적재 관측
+    console.error(`[outbound] 야간 무음(00:00~06:30 KST) — 보류 적재 (${kind})`);
+    return true;
   } catch (e) {
-    console.log(`[outbound] 보류 적재 실패 — 콘솔 출력\n${text}`, e instanceof Error ? e.message : '');
+    console.error(`[outbound] 보류 적재 실패 — 콘솔 출력\n${text}`, e instanceof Error ? e.message : '');
+    return false;
   }
 }
 
@@ -139,8 +141,29 @@ function resolveBotToken(botId?: string): string | null {
   } catch { return null; }
 }
 
-/** origin(발신 채널)으로 직접 텔레그램 발송. telegram+chatId+토큰 해석 성공 시 true. */
+/** origin(발신 채널)으로 직접 발송. 실패하면 호출자가 report 폴백/재시도한다. */
 function deliverToOrigin(origin: MissionOrigin, text: string): boolean {
+  if (origin.channel === 'discord') {
+    if (!origin.channelId) return false;
+    try {
+      const token = resolveChannelBotToken('discord', getUserConfig())?.token;
+      if (!token) return false;
+      const channelId = origin.discordThreadId || origin.channelId;
+      const out = spillLongContent(text).text;
+      for (let start = 0; start < out.length;) {
+        let end = Math.min(start + 2000, out.length);
+        if (end < out.length && /[\uD800-\uDBFF]/.test(out[end - 1]!)) end--;
+        const response = curlPost(
+          `https://discord.com/api/v10/channels/${channelId}/messages`,
+          JSON.stringify({ content: out.slice(start, end) }),
+          [`Authorization: Bot ${token}`, 'Content-Type: application/json'],
+        );
+        if (typeof response?.id !== 'string' || !response.id) return false;
+        start = end;
+      }
+      return out.length > 0;
+    } catch { return false; }
+  }
   if (origin.channel !== 'telegram' || origin.chatId == null) return false;
   const token = resolveBotToken(origin.botId);
   if (!token) return false;
@@ -189,11 +212,13 @@ export function flushDeferred(path = DEFERRED_PATH): number {
   // origin 없는 것 = report 묶음(기존 동작·finance/크론 알림).
   const noOrigin = items.filter(i => !i.origin);
   if (noOrigin.length && deliver(fmt(noOrigin), 'report')) delivered += noOrigin.length;
-  // ★ origin 있는 것 = 발신 채널(botId+chatId)별 묶음으로 되돌려 발송(미션 알림 → 메인 Q&A 봇).
+  // origin 있는 것 = 발신 채널·스레드별로 묶어 서로 다른 수신자에게 섞이지 않게 발송.
   const groups = new Map<string, { origin: MissionOrigin; list: Item[] }>();
   for (const it of items) {
     if (!it.origin) continue;
-    const key = `${it.origin.botId ?? ''}:${it.origin.chatId ?? ''}`;
+    const key = it.origin.channel === 'discord'
+      ? JSON.stringify(['discord', it.origin.channelId, it.origin.discordThreadId ?? null])
+      : JSON.stringify([it.origin.channel, it.origin.botId ?? null, it.origin.chatId ?? null, it.origin.threadId ?? null]);
     if (!groups.has(key)) groups.set(key, { origin: it.origin, list: [] });
     groups.get(key)!.list.push(it);
   }
@@ -228,31 +253,45 @@ export function recordOutbound(text: string, kind: string): void {
 /** 발송 진입점 — 야간 무음 게이트(00:00~06:30 KST 보류) + 보류분 자동 플러시.
  *  origin(발신 채널) 이 주어지면 그 채널(메인 Q&A 봇 등)로 되돌려 발송 — 무음이면 origin 을
  *  함께 보류했다가 아침에 그 채널로 flush. origin 없거나 발송 실패 시 report 폴백(기존 동작). */
-export function sendOutbound(text: string, kind = 'alert', origin?: MissionOrigin | null): boolean {
+export function sendOutbound(text: string, kind = 'alert', origin?: (MissionOrigin & { surface?: string }) | null): boolean {
+  // Prefer the producer's surface; otherwise keep the caller's repository-relative path
+  // so two producers named index.ts cannot collapse into one sender.
+  const caller = new Error().stack?.split('\n')[2] ?? '';
+  const callerPath = caller.match(/(?:\(|\s)(file:\/\/[^\s()]+|\/[^\s()]+\.[cm]?[jt]s):\d+:\d+\)?/)?.[1];
+  const repoRoot = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+  const source = origin?.surface || (callerPath
+    ? relative(repoRoot, callerPath.startsWith('file://') ? fileURLToPath(callerPath) : callerPath).replace(/\\/g, '/')
+    : 'unknown');
+  const logOutcome = (event: 'sent' | 'deferred' | 'failed'): void => {
+    try { debug.log('outbound.send', event, { kind, source, chars: text.length }); } catch { /* fail-open */ }
+  };
   // ★ 무음 우회(대표 2026-07-14) — 사용자가 최근(기본 30분) genuine 인텐트(타이핑/버튼탭)를 냈으면
   //   깨어있으므로 야간 무음이어도 즉시 발송(사용자 발원 흐름의 결과물이 아침까지 묶이지 않게).
   //   우회 시 flushDeferred 로 그간 보류분도 함께 전달(사용자가 지금 볼 수 있음).
   if (inQuietHours() && !userRecentlyActive()) {
-    deferOutbound(text, kind, origin);
+    const queued = deferOutbound(text, kind, origin);
     recordOutbound(text, kind); // 보류도 논리적 발송 — 회상 대상(데몬 미경유라 클라 기록)
-    return true; // 보류 = 수락 (호출측 재시도/에러 루프 방지)
+    logOutcome(queued ? 'deferred' : 'failed');
+    return true; // 보류 시 수락 — 적재 오류에서도 기존 호출측 재시도 계약 유지
   }
   const bypass = inQuietHours();
-  if (bypass) console.log('[outbound] 야간 무음 우회 — 최근 사용자 활동(깨어있음) → 즉시 발송 + 보류분 flush');
+  if (bypass) console.error('[outbound] 야간 무음 우회 — 최근 사용자 활동(깨어있음) → 즉시 발송 + 보류분 flush');
   try { flushDeferred(); } catch { /* fail-soft */ }
   // ★ 발송 관측(대표 지시) — 발송 시각·mode·밀림(burst) 판정을 logs.db 에. burst=최근 2분 5건+
   //   (몰려 나가는 중 = 밀림 의심). `elanous logs --category outbound.send` 로 실시간/밀림 구분.
   const { recentCount, burst } = recentSendBurst();
   logSend(bypass ? 'quiet-bypass' : 'realtime', kind, { burst, recentCount, ...(burst ? { backlog: true } : {}) });
   // ★ origin 되돌림(무음 밖) — 발신 채널로 직접 발송. 성공 시 종료, 실패면 report 폴백.
-  if (origin && origin.channel === 'telegram' && origin.chatId != null && deliverToOrigin(origin, text)) {
+  if (origin && deliverToOrigin(origin, text)) {
     recordOutbound(text, kind);
+    logOutcome('sent');
     return true;
   }
   const path = deliver(text, kind);
   // 원장 기록은 정확히 1회. 데몬 경유(daemon)면 /v1/outbound 핸들러(outbound-report.ts)
   // 가 기록하므로 클라는 중복 금지 — 직접 폴백(direct·데몬 다운)만 클라가 기록.
   if (path === 'direct') recordOutbound(text, kind);
+  logOutcome(path === false ? 'failed' : 'sent');
   return path !== false;
 }
 
@@ -275,7 +314,7 @@ export function classifyDaemonResponse(j: unknown): DaemonPathClass {
 function logDaemonPath(classification: DaemonPathClass, kind: string, extra: Record<string, unknown> = {}): void {
   try { debug.log('outbound.send', 'daemon-path', { classification, kind, ...extra }); } catch { /* fail-soft */ }
   if (classification === 'ok') return;
-  try { console.log(`[outbound] daemon-path ${classification}`); } catch { /* fail-soft */ }
+  try { console.error(`[outbound] daemon-path ${classification}`); } catch { /* fail-soft */ }
 }
 
 /** elanous `/v1/outbound` 우선 → 실패 시 텔레그램 직접. 성공 경로 반환(원장 중복방지용). */
@@ -334,6 +373,6 @@ function sendTelegramDirect(text: string, kind?: string): boolean {
     tok = tok || env.TELEGRAM_BOT_TOKEN || '';
     chat = chat || env.TELEGRAM_CHAT_ID || '';
   }
-  if (!tok || !chat) { console.log('[outbound] 토큰/chat 미설정 — 콘솔 출력\n' + text); return false; }
+  if (!tok || !chat) { console.error('[outbound] 토큰/chat 미설정 — 콘솔 출력\n' + text); return false; }
   return sendTelegramRaw(tok, chat, text);
 }

package/src/exec-requests/planner.ts

@@ -0,0 +1,140 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parse as parseYaml } from 'yaml';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { defaultGraphsDir } from '../self-implement/graph-templates.js';
+import { handleGraphsGet } from '../nexus/api/graphs-api.js';
+import { debug } from '../debug/log.js';
+
+export interface InstalledGraph {
+  id: string;
+  title: string;
+  description: string;
+  path: string;
+  /** 플러그인 그래프가 받는 입력 키(`examples/*.json` 표본에서) — COO 가 inputs 를 채울 수 있게. */
+  inputKeys?: string[];
+}
+export interface ExecPlanItem {
+  seat: string;
+  title: string;
+  graphId: string;
+  inputs: Record<string, unknown>;
+  reason?: string;
+}
+
+/** 설치된 플러그인의 실행 그래프 — `<state>/plugins/<market>/<name>/<version>/graphs/{recipes.yaml, <id>.yaml}`
+ *  (`src/plugins/install/plugin-install.ts` 설치 경로). 이름마다 가장 새 버전 하나 · 제목·설명은 그래프 `loop` 가 없으면
+ *  `plugin.json` 의 name·description(COO 가 «무엇을 하는 그래프인지» 알게). 2026-10-01 실측: 이것을 안 봐서
+ *  한 줄이 자리로 나뉘어도 «맞는 설치 그래프 없음»이었다. */
+export function installedPluginGraphs(pluginsRoot = join(elanousStateRoot(), 'plugins')): { graphs: InstalledGraph[]; errors: string[] } {
+  const graphs: InstalledGraph[] = [];
+  const errors: string[] = [];
+  const dirs = (path: string): string[] => {
+    try { return readdirSync(path, { withFileTypes: true }).filter(e => e.isDirectory() && !e.name.startsWith('.')).map(e => e.name); }
+    catch { return []; }
+  };
+  for (const market of dirs(pluginsRoot)) {
+    for (const name of dirs(join(pluginsRoot, market))) {
+      const versions = dirs(join(pluginsRoot, market, name)).sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
+      const version = versions[0];
+      if (!version) continue;
+      const root = join(pluginsRoot, market, name, version);
+      const graphsDir = join(root, 'graphs');
+      if (!existsSync(join(graphsDir, 'recipes.yaml'))) continue;
+      let meta: { name?: string; description?: string } = {};
+      try { meta = JSON.parse(readFileSync(join(root, 'plugin.json'), 'utf8')) as typeof meta; } catch { errors.push(`${market}/${name}@${version}: plugin.json unreadable`); }
+      // 입력 키 — 플러그인이 입력 스키마를 따로 선언하지 않아 `examples/*.json` 첫 표본의 키를 쓴다(값은 가상이라 안 싣는다).
+      // 2026-10-01 실측: 키를 몰라 COO 가 `inputs:{}` 로 맡겼고 geo-check 가 «brand is required» 로 첫 노드에서 떨어졌다.
+      let inputKeys: string[] | undefined;
+      try {
+        const sample = readdirSync(join(root, 'examples')).filter(f => f.endsWith('.json')).sort()[0];
+        if (sample) {
+          const parsed = JSON.parse(readFileSync(join(root, 'examples', sample), 'utf8')) as unknown;
+          if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) inputKeys = Object.keys(parsed);
+        }
+      } catch { /* 표본 없음 · 망가짐 = 키 모름 */ }
+      let files: string[] = [];
+      try { files = readdirSync(graphsDir).filter(f => /\.ya?ml$/.test(f) && f !== 'recipes.yaml'); } catch { errors.push(`${market}/${name}@${version}: graphs unreadable`); }
+      for (const file of files) {
+        const path = join(graphsDir, file);
+        try {
+          const doc = parseYaml(readFileSync(path, 'utf8')) as { graph_id?: string; loop?: { title?: string; description?: string } };
+          const id = doc?.graph_id;
+          if (!id || !/^[a-z0-9-]+$/.test(id)) continue;
+          graphs.push({ id, title: doc.loop?.title ?? meta.name ?? id, description: doc.loop?.description ?? meta.description ?? '', path, ...(inputKeys ? { inputKeys } : {}) });
+        } catch { errors.push(`${market}/${name}@${version}: ${file} malformed`); }
+      }
+    }
+  }
+  return { graphs, errors };
+}
+
+export async function installedGraphs(coreDir = defaultGraphsDir(), mineDir = join(elanousStateRoot(), 'graphs')): Promise<InstalledGraph[]> {
+  const base = await coreAndMineGraphs(coreDir, mineDir);
+  // 플러그인은 mine 과 같은 상태 뿌리 아래(<root>/graphs ↔ <root>/plugins) — 시험의 임시 mine 은 운영 플러그인을 안 본다.
+  const plugins = installedPluginGraphs(join(dirname(mineDir), 'plugins'));
+  const seen = new Set(base.map(g => g.id));
+  const extra = plugins.graphs.filter(g => !seen.has(g.id));
+  debug.log('exec-requests', 'catalog', { coreAndMine: base.length, plugins: extra.length, pluginErrors: plugins.errors.slice(0, 5) });
+  return [...base, ...extra];
+}
+
+async function coreAndMineGraphs(coreDir: string, mineDir: string): Promise<InstalledGraph[]> {
+  const catalog = handleGraphsGet('/v1/graphs', coreDir, { coreDir, mineDir });
+  if (!catalog.ok) throw new Error('installed graph catalog unavailable');
+  const { graphs } = await catalog.json() as { graphs: Array<{ id: string; source: 'core' | 'mine' }> };
+  return graphs.flatMap(({ id, source }) => {
+    const dir = source === 'core' ? coreDir : mineDir;
+    if (!/^[a-z0-9-]+$/.test(id) || !existsSync(join(dir, 'recipes.yaml'))) return [];
+    let names: string[];
+    try { names = readdirSync(dir).filter(name => /\.ya?ml$/.test(name)); }
+    catch { return []; }
+    for (const name of names) {
+      const path = join(dir, name);
+      try {
+        const doc = parseYaml(readFileSync(path, 'utf8')) as { graph_id?: string; loop?: { title?: string; description?: string } };
+        if (doc?.graph_id === id) return [{ id, title: doc.loop?.title ?? id, description: doc.loop?.description ?? '', path }];
+      } catch { /* A malformed file is not an executable graph. */ }
+    }
+    return [];
+  });
+}
+
+export function seatTitles(path = fileURLToPath(new URL('../../scripts/coord-tracks.json', import.meta.url))): string[] {
+  const data = JSON.parse(readFileSync(path, 'utf8')) as { tracks: Array<{ title?: string }> };
+  return data.tracks.flatMap(track => track.title ? [track.title] : []);
+}
+
+export async function judgeExecPlan(text: string, graphs: readonly InstalledGraph[], seats: readonly string[]): Promise<unknown> {
+  const prompt = `COO 역할. 요청을 실행 가능한 자리별 그래프로 나눠 맡겨라. JSON 배열만 출력: [{"seat":"자리","title":"할 일","graphId":"설치된 그래프 ID 또는 빈 문자열","inputs":{}}]. 자리 이름은 주어진 목록에서만, 그래프 ID는 설치된 목록에서만 고른다. 맞는 그래프가 없으면 graphId=""로 표시한다. 그래프에 inputKeys 가 있으면 inputs 를 그 키로만 채우되 한 줄에서 알 수 있는 값만 넣는다(모르는 값은 넣지 않는다). 그 그래프가 꼭 받아야 할 값(예: 브랜드 이름 · 사진 파일)을 한 줄에서 얻을 수 없으면 graphId=""로 두고 title 끝에 « — <무엇> 필요»를 적는다. 없는 그래프나 산출을 지어내지 마라. 바깥 게시·발행·광고·결제는 승인 노드를 거치기 전 실행하면 안 된다.\n자리: ${JSON.stringify(seats)}\n실행 가능한 그래프: ${JSON.stringify(graphs.map(({ id, title, description, inputKeys }) => ({ id, title, description, ...(inputKeys ? { inputKeys } : {}) })))}\n한 줄: ${JSON.stringify(text)}`;
+  const { streamLLM } = await import('../llm.js');
+  const { tierModel } = await import('../llm/model-defaults.js');
+  const raw = await streamLLM([{ role: 'user', content: prompt }], () => {}, { model: tierModel('best') });
+  return JSON.parse(raw.replace(/^```(?:json)?\s*|\s*```$/g, '').trim()) as unknown;
+}
+
+export async function planExecRequest(text: string, deps: {
+  graphs?: () => Promise<InstalledGraph[]>;
+  seats?: () => string[];
+  judge?: typeof judgeExecPlan;
+} = {}): Promise<ExecPlanItem[]> {
+  const graphs = await (deps.graphs ?? installedGraphs)();
+  const seats = (deps.seats ?? seatTitles)();
+  const raw = await (deps.judge ?? judgeExecPlan)(text, graphs, seats);
+  if (!Array.isArray(raw) || raw.length === 0) throw new Error('COO 계획이 비었거나 배열이 아닙니다');
+  const known = new Map(graphs.map(graph => [graph.id, graph]));
+  return raw.map((item: unknown) => {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) throw new Error('COO 계획 항목 형식 오류');
+    const row = item as Record<string, unknown>;
+    if (typeof row.seat !== 'string' || !seats.includes(row.seat) || typeof row.title !== 'string' || !row.title.trim()
+      || typeof row.graphId !== 'string' || !row.inputs || typeof row.inputs !== 'object' || Array.isArray(row.inputs)) {
+      throw new Error('COO 계획 항목 형식 오류');
+    }
+    return {
+      seat: row.seat, title: row.title.trim(), graphId: row.graphId,
+      inputs: row.inputs as Record<string, unknown>,
+      ...(!known.has(row.graphId) ? { reason: `${row.seat}: 요청에 맞는 설치된 실행 그래프가 없습니다` } : {}),
+    };
+  });
+}

package/src/exec-requests/runner.ts

@@ -0,0 +1,338 @@
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, resolve, sep } from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { lastJsonObject, runGraph, type GraphRunState } from '../graph-runner/runner.js';
+import { installedGraphs, planExecRequest, type ExecPlanItem, type InstalledGraph } from './planner.js';
+import { ExecRequestStore, type ExecRequest, type ExecResult, type ExecSeat } from './store.js';
+
+export interface ExecRunnerDeps {
+  store?: ExecRequestStore;
+  graphs?: () => Promise<InstalledGraph[]>;
+  plan?: (text: string) => Promise<ExecPlanItem[]>;
+  run?: typeof runGraph;
+  root?: string;
+}
+
+const active = new Set<string>();
+const SEGMENT = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const kinds: Record<string, ExecResult['kind']> = {
+  '.pdf': 'pdf', '.mp4': 'video', '.mov': 'video', '.webm': 'video', '.png': 'image', '.jpg': 'image',
+  '.jpeg': 'image', '.webp': 'image', '.md': 'report', '.txt': 'text',
+};
+
+function safeFile(path: string, root: string, graphId: string, runId: string): string | null {
+  if (!SEGMENT.test(graphId) || !SEGMENT.test(runId)) return null;
+  // Only run-prefixed files or the run artifact directory, never a sibling run's output.
+  const allowed = join(root, 'graph-runs', graphId);
+  const candidate = isAbsolute(path) ? path : resolve(allowed, path);
+  try {
+    const real = realpathSync(candidate);
+    const base = realpathSync(allowed);
+    const runPrefix = `${runId}.json.`;
+    const local = dirname(real) === base && basename(real).startsWith(runPrefix)
+      && !/\.(?:decision\.json|tmp)$/.test(real);
+    const artifactsDir = join(allowed, `${runId}.json.artifacts`);
+    const realArtifactsDir = existsSync(artifactsDir) && statSync(artifactsDir).isDirectory()
+      ? realpathSync(artifactsDir) : null;
+    const inRunDirectory = realArtifactsDir === join(base, `${runId}.json.artifacts`)
+      && real.startsWith(`${realArtifactsDir}${sep}`);
+    if ((!local && !inRunDirectory) || !statSync(real).isFile()) return null;
+    return real;
+  } catch { return null; }
+}
+
+function publicLink(value: unknown): string | null {
+  if (typeof value !== 'string') return null;
+  try {
+    const url = new URL(value);
+    return (url.protocol === 'https:' || url.protocol === 'http:') && url.hostname && !url.username && !url.password ? value : null;
+  } catch { return null; }
+}
+
+function fileName(path: string, runId: string): string {
+  const digest = createHash('sha256').update(path).digest('hex');
+  return `${runId}--${digest}--${basename(path)}`;
+}
+
+function resultOf(output: Record<string, unknown>, seat: ExecSeat, id: string, root: string): ExecResult | null {
+  const candidate = typeof output.file === 'string' ? output.file : typeof output.path === 'string' ? output.path : null;
+  let url: string;
+  let kind: ExecResult['kind'];
+  let name: string;
+  if (candidate !== null) {
+    const path = safeFile(candidate, root, seat.graphId, seat.runId);
+    if (!path) return null;
+    const fileKind = kinds[basename(path).slice(basename(path).lastIndexOf('.')).toLowerCase()];
+    if (!fileKind) return null;
+    kind = fileKind;
+    name = basename(path);
+    url = `/v1/exec-requests/${id}/files/${encodeURIComponent(fileName(path, seat.runId))}`;
+  } else {
+    const link = publicLink(output.url);
+    if (!link) return null;
+    kind = 'link';
+    name = link;
+    url = link;
+  }
+  const sources = Array.isArray(output.sources) ? output.sources.flatMap((source: unknown) => {
+    if (!source || typeof source !== 'object') return [];
+    const entry = source as { title?: unknown; url?: unknown };
+    const sourceUrl = publicLink(entry.url);
+    return typeof entry.title === 'string' && sourceUrl ? [{ title: entry.title, url: sourceUrl }] : [];
+  }) : [];
+  return { seat: seat.seat, kind, title: typeof output.title === 'string' ? output.title : name,
+    url, ...(sources.length ? { sources } : {}) };
+}
+
+function syncRun(item: ExecRequest, seat: ExecSeat, state: GraphRunState, root: string): void {
+  const previous = seat.status;
+  seat.status = state.status === 'done' ? 'done' : state.status === 'failed' || state.status === 'budget-exceeded' ? 'failed' : 'running';
+  if (previous !== seat.status) debug.log('exec-requests', 'seat-status', { id: item.id, seat: seat.seat, from: previous, to: seat.status, graphId: seat.graphId, runId: seat.runId });
+  const claim = state.status === 'awaiting-approval' && state.pending
+    ? `${join(root, 'graph-runs', seat.graphId, `${seat.runId}.json`)}.${state.path.length}.decision.json` : '';
+  if (state.status === 'awaiting-approval' && state.pending && !state.pending.decision && !existsSync(claim)) {
+    if (!item.approvals.some(a => a.graphId === seat.graphId && a.runId === seat.runId)) {
+      item.approvals.push({ graphId: seat.graphId, runId: seat.runId, message: state.pending.message });
+    }
+  } else item.approvals = item.approvals.filter(a => a.graphId !== seat.graphId || a.runId !== seat.runId);
+  for (const node of state.nodes ?? []) {
+    const output = lastJsonObject(node.output);
+    if (!output) continue;
+    const entries = Array.isArray(output.artifacts) ? output.artifacts : [output];
+    for (const entry of entries) {
+      if (!entry || typeof entry !== 'object' || Array.isArray(entry)) continue;
+      const result = resultOf(entry as Record<string, unknown>, seat, item.id, root);
+      if (result && !item.results.some(existing => existing.seat === result.seat && existing.url === result.url)) item.results.push(result);
+    }
+  }
+  const summary = [...(state.nodes ?? [])].reverse().map(node => lastJsonObject(node.output)?.summary).find(value => typeof value === 'string');
+  if (typeof summary === 'string') item.summary = summary;
+  if (seat.status === 'failed') seat.reason = state.nodes?.at(-1)?.error ?? `그래프 런 ${state.status}`;
+}
+
+function aggregate(item: ExecRequest): void {
+  if (item.status === 'planning' || item.seats.length === 0) return;
+  if (item.seats.some(seat => seat.status === 'waiting' || seat.status === 'running')) item.status = 'running';
+  else item.status = item.seats.some(seat => seat.status === 'failed') ? 'failed' : 'done';
+  // 실패면 요약은 «실패 사유»가 이긴다 — 먼저 끝난 자리의 산출 설명이 남아 있어도 덮는다(혼합 결과에서 성공처럼 보이지 않게).
+  if (item.status === 'failed') {
+    const reasons = item.seats.filter(seat => seat.status === 'failed').map(seat => seat.reason ?? `${seat.seat}: 그래프 실행 실패`);
+    if (reasons.length > 0) item.summary = reasons.join('; ');
+  }
+}
+
+export class ExecRequestRunner {
+  readonly store: ExecRequestStore;
+  private readonly root: string;
+  constructor(private readonly deps: ExecRunnerDeps = {}) {
+    this.store = deps.store ?? new ExecRequestStore();
+    this.root = deps.root ?? effectiveInstanceRoot();
+  }
+
+  /** 데몬 «시작» 때 한 번만 부른다(`startNexusHttpServer`). 생성자에서 부르면 모듈을 import 만 한 다른 프로세스
+   *  (시험·CLI·동시 서버)가 살아 있는 요청을 «재시작 중단»으로 실패 처리한다(리뷰 3라운드 must-fix). */
+  reconcileInterrupted(): void {
+    for (const item of this.store.list()) {
+      if (item.status !== 'planning' && item.status !== 'running') continue;
+      if (item.status === 'planning') {
+        item.status = 'failed';
+        item.summary = '데몬 재시작으로 COO 계획이 중단됐습니다';
+      } else {
+        if (item.seats.length === 0) {
+          item.status = 'failed';
+          item.summary = '데몬 재시작으로 자리 배정이 중단됐습니다';
+        }
+        for (const seat of item.seats) {
+          if (seat.status === 'done' || seat.status === 'failed') continue;
+          const reason = '데몬 재시작으로 그래프 실행이 중단됐습니다';
+          if (SEGMENT.test(seat.graphId) && SEGMENT.test(seat.runId)) {
+            try {
+              const file = join(this.root, 'graph-runs', seat.graphId, `${seat.runId}.json`);
+              const state = JSON.parse(readFileSync(file, 'utf8')) as GraphRunState;
+              if (state.graphId === seat.graphId && state.runId === seat.runId) {
+                if (state.status === 'done' || state.status === 'failed' || state.status === 'budget-exceeded'
+                  || (state.status === 'awaiting-approval' && state.pending)) {
+                  syncRun(item, seat, state, this.root);
+                  continue;
+                }
+              }
+            } catch { /* No trustworthy completed or approval-pending run to recover. */ }
+          }
+          const previous = seat.status;
+          seat.status = 'failed';
+          seat.reason = reason;
+          item.approvals = item.approvals.filter(a => a.graphId !== seat.graphId || a.runId !== seat.runId);
+          debug.log('exec-requests', 'seat-status', { id: item.id, seat: seat.seat, from: previous, to: 'failed', reason });
+        }
+        aggregate(item);
+        if (item.status === 'failed' && item.seats.length > 0) item.summary = item.seats.filter(seat => seat.status === 'failed')
+          .map(seat => seat.reason ?? `${seat.seat}: 그래프 실행 실패`).join('; ');
+      }
+      this.store.save(item);
+      if (item.status === 'failed') debug.log('exec-requests', 'failed', { id: item.id, reason: item.summary });
+    }
+  }
+
+  submit(text: string): ExecRequest {
+    const item = this.store.create(text);
+    void this.execute(item.id).catch(error => {
+      const current = this.store.get(item.id);
+      if (!current) return;
+      current.status = 'failed';
+      current.summary = error instanceof Error ? error.message : String(error);
+      this.store.save(current);
+      debug.log('exec-requests', 'failed', { id: item.id, reason: current.summary });
+    });
+    return item;
+  }
+
+  private async execute(id: string): Promise<void> {
+    const item = this.store.get(id);
+    if (!item) return;
+    const graphs = await (this.deps.graphs ?? installedGraphs)();
+    const plans = await (this.deps.plan ?? ((text: string) => planExecRequest(text, { graphs: async () => graphs })))(item.text);
+    const byId = new Map(graphs.map(graph => [graph.id, graph]));
+    item.seats = plans.map(plan => ({ seat: plan.seat, title: plan.title, status: plan.reason || !byId.has(plan.graphId) ? 'failed' : 'waiting', graphId: plan.graphId,
+      runId: plan.reason || !byId.has(plan.graphId) ? '' : randomUUID(), inputs: plan.inputs,
+      ...(plan.reason || !byId.has(plan.graphId) ? { reason: plan.reason ?? `${plan.seat}: 요청에 맞는 설치된 실행 그래프가 없습니다` } : {}) }));
+    item.status = 'running';
+    debug.log('exec-requests', 'planned', { id, seats: item.seats.map(seat => ({ seat: seat.seat, graphId: seat.graphId, status: seat.status })) });
+    this.store.save(item);
+    await Promise.all(item.seats.map(async (seat, index) => {
+      const graph = byId.get(seat.graphId);
+      if (!graph || seat.status === 'failed') return;
+      const starting = this.store.get(id)!;
+      starting.seats[index]!.status = 'running';
+      this.store.save(starting);
+      debug.log('exec-requests', 'started', { id, seat: seat.seat, graphId: seat.graphId, runId: seat.runId });
+      debug.log('exec-requests', 'seat-status', { id, seat: seat.seat, from: 'waiting', to: 'running' });
+      try {
+        const state = await (this.deps.run ?? runGraph)(graph.path, { input: seat.inputs, runId: seat.runId, deps: { root: this.root } });
+        const current = this.store.get(id)!;
+        syncRun(current, current.seats[index]!, state, this.root);
+        aggregate(current);
+        this.store.save(current);
+      } catch (error) {
+        const current = this.store.get(id)!;
+        current.seats[index]!.status = 'failed';
+        current.seats[index]!.reason = error instanceof Error ? error.message : String(error);
+        debug.log('exec-requests', 'seat-status', { id, seat: seat.seat, to: 'failed', reason: current.seats[index]!.reason });
+        aggregate(current);
+        this.store.save(current);
+      }
+    }));
+    const finished = this.store.get(id)!;
+    aggregate(finished);
+    this.store.save(finished);
+    if (finished.status === 'done' || finished.status === 'failed') debug.log('exec-requests', finished.status, { id, results: finished.results.length });
+  }
+
+  get(id: string): ExecRequest | null {
+    const item = this.store.get(id);
+    if (!item) return null;
+    if (item.status === 'planning' || item.status === 'done' || item.status === 'failed') return item;
+    for (const seat of item.seats) {
+      // An approved decision triggers a resume; failures are terminal and never retried on reads.
+      // A terminal seat is never re-synced from a stale awaiting-approval snapshot.
+      if (seat.status === 'done' || seat.status === 'failed' || !seat.runId || !SEGMENT.test(seat.graphId) || !SEGMENT.test(seat.runId)) continue;
+      const file = join(this.root, 'graph-runs', seat.graphId, `${seat.runId}.json`);
+      if (!existsSync(file)) continue;
+      try {
+        const state = JSON.parse(readFileSync(file, 'utf8')) as GraphRunState;
+        if (state.graphId !== seat.graphId || state.runId !== seat.runId) continue;
+        syncRun(item, seat, state, this.root);
+        if (state.status === 'awaiting-approval' && state.pending && !state.pending.decision) {
+          const decision = `${file}.${state.path.length}.decision.json`;
+          if (existsSync(decision)) {
+            item.approvals = item.approvals.filter(a => a.runId !== seat.runId);
+            const key = `${seat.graphId}/${seat.runId}`;
+            if (!active.has(key)) {
+              active.add(key);
+              const launch = async () => {
+                try {
+                  const graphs = await (this.deps.graphs ?? installedGraphs)();
+                  const graph = graphs.find(candidate => candidate.id === seat.graphId);
+                  if (!graph) throw new Error('설치된 그래프가 없습니다');
+                  const resumed = await (this.deps.run ?? runGraph)(graph.path, { resumeRunId: seat.runId, deps: { root: this.root } });
+                  const current = this.store.get(id);
+                  const target = current?.seats.find(s => s.runId === seat.runId);
+                  if (current && target) { syncRun(current, target, resumed, this.root); aggregate(current); this.store.save(current); }
+                } catch (error) {
+                  const reason = error instanceof Error ? error.message : String(error);
+                  const current = this.store.get(id);
+                  const target = current?.seats.find(s => s.graphId === seat.graphId && s.runId === seat.runId);
+                  if (current && target && target.status !== 'done') {
+                    target.status = 'failed';
+                    target.reason = `그래프 재개 실패: ${reason}`;
+                    current.approvals = current.approvals.filter(a => a.graphId !== seat.graphId || a.runId !== seat.runId);
+                    aggregate(current);
+                    this.store.save(current);
+                    debug.log('exec-requests', 'seat-status', { id, seat: seat.seat, to: 'failed', reason: target.reason });
+                  }
+                  debug.log('exec-requests', 'failed', { id, seat: seat.seat, reason });
+                } finally { active.delete(key); }
+              };
+              void launch();
+            }
+          }
+        }
+      } catch (error) { debug.log('exec-requests', 'failed', { id, seat: seat.seat, reason: String(error) }); }
+    }
+    const current = this.store.get(id) ?? item;
+    for (const seat of item.seats) {
+      const target = current.seats.find(candidate => candidate.runId && candidate.runId === seat.runId);
+      if (target && target.status !== 'done' && target.status !== 'failed') {
+        target.status = seat.status;
+        if (seat.reason) target.reason = seat.reason;
+      }
+    }
+    const approvals = new Map(current.approvals.map(approval => [`${approval.graphId}/${approval.runId}`, approval]));
+    for (const approval of item.approvals) approvals.set(`${approval.graphId}/${approval.runId}`, approval);
+    current.approvals = [...approvals.values()].filter(approval => {
+      const seat = current.seats.find(candidate => candidate.graphId === approval.graphId && candidate.runId === approval.runId);
+      if (!seat || seat.status === 'done' || seat.status === 'failed') return false;
+      const file = join(this.root, 'graph-runs', approval.graphId, `${approval.runId}.json`);
+      try {
+        const state = JSON.parse(readFileSync(file, 'utf8')) as GraphRunState;
+        return state.status === 'awaiting-approval' && !!state.pending && !state.pending.decision
+          && !existsSync(`${file}.${state.path.length}.decision.json`);
+      } catch { return false; }
+    });
+    for (const result of item.results) {
+      if (!current.results.some(existing => existing.url === result.url)) current.results.push(result);
+    }
+    if (item.summary && !current.summary) current.summary = item.summary;
+    aggregate(current);
+    this.store.save(current);
+    return current;
+  }
+
+  file(id: string, name: string): string | null {
+    // Artifact names may contain spaces and Unicode; only a single safe path component is accepted.
+    if (!name || name === '.' || name === '..' || name !== basename(name) || /[\\/\x00-\x1f\x7f]/.test(name)) return null;
+    const item = this.get(id);
+    const result = item?.results.find(entry => entry.url === `/v1/exec-requests/${id}/files/${encodeURIComponent(name)}`);
+    if (!result) return null;
+    const seat = item!.seats.find(entry => name.startsWith(`${entry.runId}--`) && entry.seat === result.seat);
+    if (!seat) return null;
+    try {
+      const state = JSON.parse(readFileSync(join(this.root, 'graph-runs', seat.graphId, `${seat.runId}.json`), 'utf8')) as GraphRunState;
+      if (state.graphId !== seat.graphId || state.runId !== seat.runId) return null;
+      for (const node of state.nodes ?? []) {
+        const output = lastJsonObject(node.output);
+        if (!output) continue;
+        for (const entry of Array.isArray(output.artifacts) ? output.artifacts : [output]) {
+          if (!entry || typeof entry !== 'object' || Array.isArray(entry)) continue;
+          const artifact = entry as Record<string, unknown>;
+          const candidate = typeof artifact.file === 'string' ? artifact.file : artifact.path;
+          if (typeof candidate !== 'string') continue;
+          const path = safeFile(candidate, this.root, seat.graphId, seat.runId);
+          if (path && fileName(path, seat.runId) === name) return path;
+        }
+      }
+    } catch { return null; }
+    return null;
+  }
+}