elanous 0.2.9 → 0.2.11

package/src/domains/telegram-kind-route.ts

@@ -1,21 +1,77 @@
 // 발송 목적(kind) → 텔레그램 채널 역할 · 대상. 가벼운 모듈(telegram.ts 를 import 하지 않는다 — outbound-alert 순환 방지).
-// 표에 없는 kind 는 undefined → 부르는 쪽이 옛 reportChannel 로 간다(투자 알림 등 기존 동작 그대로).
+// 명시적으로 매매 kind 인 경우만 trading; 나머지는 system. 역할 채널이 없으면 다른 역할로 폴백하지 않는다.
 import type { UserConfig } from '../user-config.js';
-import { channelForRole, resolveTelegramChannels } from './telegram-channels.js';
+import { resolveChannelBotToken } from '../channel-bot-token.js';
+import { debug } from '../debug/log.js';
+import { resolveTelegramChannels } from './telegram-channels.js';
 
 export const DEFAULT_KIND_ROLES: Readonly<Record<string, string>> = {
+  report: 'report', alert: 'report', digest: 'report',
   intake: 'system', 'ops-report': 'system', 'ops-alert': 'system', 'ops-health': 'system',
+  regression: 'system', 'agent-mission': 'system', brief: 'system', 'op-report': 'system',
 };
 
-export function roleForKind(cfg: UserConfig, kind?: string): string | undefined {
-  if (!kind) return undefined;
-  return cfg.telegram.kindRoles?.[kind] ?? DEFAULT_KIND_ROLES[kind];
+/** Only named finance delivery kinds can use the trading/report bot. */
+export function isTradingKind(kind?: string): boolean {
+  return kind === 'report' || kind === 'alert' || kind === 'digest';
 }
 
-/** The channel for a purpose kind — only with explicit `telegram.channels` and a mapped role. */
+export function isOperationalKind(kind?: string): boolean {
+  return !isTradingKind(kind);
+}
+
+export function mainHomeTarget(cfg: UserConfig): { botToken: string; chatId: number } | null {
+  const botToken = operationsBotToken(cfg);
+  const chatId = cfg.telegram.homeChannel ?? cfg.telegram.allowedUsers[0];
+  return botToken && chatId != null && Number.isFinite(chatId) ? { botToken, chatId } : null;
+}
+
+export function logKindRouteFallback(kind: string | undefined, to: 'report-channel' | 'main-home' | 'conatus-env' | 'none', sameBot: boolean): void {
+  try { debug.log('telegram.kind-route', 'fallback', { kind, to, sameBot }); } catch { /* logging must not prevent delivery */ }
+}
+
+function operationsBotToken(cfg: UserConfig): string | undefined {
+  const main = resolveChannelBotToken('telegram', cfg);
+  const channels = cfg.telegram.channels?.length ? resolveTelegramChannels(cfg.telegram) : [];
+  const tradingTokens = new Set(channels.filter(c => c.roles.includes('report')).map(c => c.botToken));
+  // The report (trading) bot is never the operations bot — with or without a channels table (review must-fix · OUT1).
+  if (cfg.telegram.reportChannel?.botToken) tradingTokens.add(cfg.telegram.reportChannel.botToken);
+  if (main.source !== 'channels.main') return main.token && !tradingTokens.has(main.token) ? main.token : undefined;
+  // channels.main may mean "first channel", which can be the trading bot.
+  // Only a named operations channel (or the named main channel) with an
+  // operational role establishes identity; array order and role alone do not.
+  const tokens = new Set(channels
+    .filter(c => (c.name === 'ops' && c.roles.includes('system'))
+      || (c.name === 'main' && c.roles.some(r => r === 'system' || r === 'qa' || r === 'default')))
+    .filter(c => !tradingTokens.has(c.botToken))
+    .map(c => c.botToken));
+  return tokens.size === 1 ? tokens.values().next().value : undefined;
+}
+
+function isAllowedBot(cfg: UserConfig, kind: string | undefined, token: string): boolean {
+  const mainToken = operationsBotToken(cfg);
+  if (!mainToken) return false;
+  if (!isTradingKind(kind)) return token === mainToken;
+  const reportToken = cfg.telegram.reportChannel?.botToken;
+  return token !== mainToken && (!reportToken || token === reportToken);
+}
+
+export function roleForKind(cfg: UserConfig, kind?: string): string {
+  const fallback = isTradingKind(kind) ? 'report' : 'system';
+  if (!kind || !cfg.telegram.channels?.length) return fallback;
+  const override = cfg.telegram.kindRoles?.[kind];
+  if (!override) return fallback;
+  const channel = resolveTelegramChannels(cfg.telegram)
+    .find(c => c.roles.includes(override) && isAllowedBot(cfg, kind, c.botToken));
+  return channel ? override : fallback;
+}
+
+/** Exact role only: channelForRole's default/first fallback can cross bot boundaries. */
 export function kindRouteTarget(cfg: UserConfig, kind?: string): { botToken: string; chatId: number } | null {
+  if (!cfg.telegram.channels?.length) return null;
   const role = roleForKind(cfg, kind);
-  if (!role || !cfg.telegram.channels?.length) return null;
-  const ch = channelForRole(resolveTelegramChannels(cfg.telegram), role);
-  return ch?.botToken && Number.isFinite(ch.chatId) ? { botToken: ch.botToken, chatId: ch.chatId } : null;
+  const ch = resolveTelegramChannels(cfg.telegram)
+    .find(c => c.roles.includes(role) && isAllowedBot(cfg, kind, c.botToken));
+  if (!ch || !Number.isFinite(ch.chatId)) return null;
+  return { botToken: ch.botToken, chatId: ch.chatId };
 }

package/src/exec-requests/default-outputs.ts

@@ -0,0 +1,25 @@
+export const OUTPUT_KINDS = {
+  report: { fileName: 'report.md', cardTitle: '한 장 보고서', guidance: '보고·정리·요약·회고 → 한 장 보고서', words: ['보고', '정리', '요약', '회고', 'report', 'summary', 'summarize', 'recap', 'brief'] },
+  slides: { fileName: 'slides.md', cardTitle: '슬라이드', guidance: '발표·자료·덱·피치 → 슬라이드(장마다 --- 구분)', words: ['발표', '자료', '덱', '피치', 'presentation', 'slides', 'slide', 'deck', 'pitch'] },
+  research: { fileName: 'research.md', cardTitle: '조사 문서', guidance: '조사·비교·경쟁사·시장 → 조사 문서(출처 링크 칸 필수)', words: ['조사', '비교', '경쟁사', '시장', 'research', 'compare', 'comparison', 'competitor', 'competitors', 'market'] },
+  post: { fileName: 'post.md', cardTitle: '게시글 초안', guidance: '게시글·캡션·공지·SNS → 게시글 초안(게시는 승인 노드 뒤)', words: ['게시글', '캡션', '공지', 'SNS', 'post', 'caption', 'announcement', 'social media'] },
+  video: { fileName: '', cardTitle: '영상', guidance: '영상·릴스·쇼츠 → 영상(그래프가 있을 때만)', words: ['영상', '릴스', '쇼츠', 'video', 'reels', 'shorts'] },
+  answer: { fileName: '', cardTitle: '답', guidance: '단순한 질문 → 답 그대로(산출물 없음)', words: [] },
+} as const;
+
+export type OutputKind = keyof typeof OUTPUT_KINDS;
+
+export function pickDefaultOutput(text: string): { kind: OutputKind; fileName: string; cardTitle: string } {
+  const normalized = text.toLowerCase();
+  // Explicit artifact formats outrank activity words such as 정리, 요약 and 비교.
+  for (const kind of ['slides', 'post', 'video', 'research', 'report'] as const) {
+    const entry = OUTPUT_KINDS[kind];
+    if (entry.words.some(word => /[a-z]/i.test(word)
+      ? new RegExp(`(^|[^a-z])${word.toLowerCase()}(?=$|[^a-z])`).test(normalized)
+      : normalized.includes(word))) {
+      return { kind, fileName: entry.fileName, cardTitle: entry.cardTitle };
+    }
+  }
+  const kind = /(?:[?？]|뭐|어떻게)\s*$/.test(text) ? 'answer' : 'report';
+  return { kind, fileName: OUTPUT_KINDS[kind].fileName, cardTitle: OUTPUT_KINDS[kind].cardTitle };
+}

package/src/exec-requests/planner.ts

@@ -1,18 +1,20 @@
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { existsSync, readFileSync, readdirSync, statSync, type Dirent } from 'node:fs';
+import { dirname, join, resolve, sep } 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 { getElanousConfigDir } from '../elanous-config-dir.js';
+import type { ExecAttachment } from './store.js';
 import { debug } from '../debug/log.js';
+import { OUTPUT_KINDS, pickDefaultOutput, type OutputKind } from './default-outputs.js';
 
 export interface InstalledGraph {
   id: string;
   title: string;
   description: string;
   path: string;
-  /** 플러그인 그래프가 받는 입력 키(`examples/*.json` 표본에서) — COO 가 inputs 를 채울 수 있게. */
+  /** 코어 loop.inputs 또는 플러그인 examples/*.json 표본의 입력 키. */
   inputKeys?: string[];
 }
 export interface ExecPlanItem {
@@ -20,6 +22,8 @@ export interface ExecPlanItem {
   title: string;
   graphId: string;
   inputs: Record<string, unknown>;
+  /** Planner fills this for every returned row; older injected plan fixtures may omit it. */
+  output?: OutputKind;
   reason?: string;
   /** A5b — indexes of earlier items whose results this item needs (it starts after they finish). */
   after?: number[];
@@ -83,24 +87,41 @@ export async function installedGraphs(coreDir = defaultGraphsDir(), mineDir = jo
 }
 
 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. */ }
+  const graphs: InstalledGraph[] = [];
+  const seen = new Set<string>();
+  const scan = (dir: string, core: boolean): void => {
+    let entries: Dirent[];
+    try { entries = readdirSync(dir, { withFileTypes: true }); }
+    catch { return; }
+    if (!core || dir === coreDir || entries.some(entry => entry.isFile() && entry.name === 'recipes.yaml')) {
+      for (const entry of entries) {
+        if (!entry.isFile() || !/\.ya?ml$/.test(entry.name) || entry.name === 'recipes.yaml') continue;
+        const path = join(dir, entry.name);
+        try {
+          const doc = parseYaml(readFileSync(path, 'utf8')) as {
+            graph_id?: unknown;
+            loop?: { title?: string; description?: string; exec_request?: unknown; inputs?: unknown };
+          } | null;
+          const id = doc?.graph_id;
+          if (typeof id !== 'string' || !/^[a-z0-9-]+$/.test(id) || seen.has(id)) continue;
+          if (core && doc?.loop?.exec_request !== true) continue;
+          const inputs = doc?.loop?.inputs;
+          const inputKeys = core && Array.isArray(inputs)
+            ? inputs.filter((key): key is string => typeof key === 'string')
+            : core && inputs && typeof inputs === 'object' ? Object.keys(inputs) : undefined;
+          graphs.push({ id, title: doc?.loop?.title ?? id, description: doc?.loop?.description ?? '', path,
+            ...(inputKeys ? { inputKeys } : {}) });
+          seen.add(id);
+        } catch { /* A malformed file is not an executable graph. */ }
+      }
     }
-    return [];
-  });
+    if (core) for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith('.')) scan(join(dir, entry.name), true);
+    }
+  };
+  scan(coreDir, true);
+  scan(mineDir, false);
+  return graphs;
 }
 
 export function seatTitles(path = fileURLToPath(new URL('../../scripts/coord-tracks.json', import.meta.url))): string[] {
@@ -108,8 +129,32 @@ export function seatTitles(path = fileURLToPath(new URL('../../scripts/coord-tra
   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":{},"after":[]}]. 앞 항목의 결과가 있어야 할 수 있는 일(예: 점검·조사 «결과로» 쓰는 한 장 · 보고)은 after 에 그 앞 항목 번호(0부터)를 적는다 — 그 항목은 앞 항목이 끝난 뒤 그 결과를 받아 시작한다. 서로 기다릴 필요가 없으면 after 는 빈 배열. 자리 이름은 주어진 목록에서만, 그래프 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)}`;
+export function latestFieldFolder(configRoot = getElanousConfigDir()): string | null {
+  const root = join(configRoot, 'field');
+  let latest: { path: string; time: number } | null = null;
+  try {
+    for (const event of readdirSync(root, { withFileTypes: true })) {
+      if (!event.isDirectory() || event.name.startsWith('.')) continue;
+      const path = join(root, event.name);
+      try {
+        const photos = readdirSync(path, { withFileTypes: true }).filter(file => file.isFile() && /\.(?:png|jpe?g|webp|heic)$/i.test(file.name));
+        for (const photo of photos) {
+          const time = statSync(join(path, photo.name)).mtimeMs;
+          if (!latest || time > latest.time || (time === latest.time && path.localeCompare(latest.path) > 0)) latest = { path, time };
+        }
+      } catch { /* Unreadable event does not supply photos. */ }
+    }
+  } catch { /* No field directory. */ }
+  return latest?.path ?? null;
+}
+
+export function execPlanPrompt(text: string, graphs: readonly InstalledGraph[], seats: readonly string[], attachments: readonly ExecAttachment[] = [], fieldFolder: string | null = latestFieldFolder()): string {
+  const supplied = attachments.map(({ name, path }) => `첨부: ${name} (${/\.(?:png|jpe?g|webp|gif|heic)$/i.test(name) ? '이미지' : '파일'}) — ${path}`).join('\n');
+  return `COO 역할. 요청을 실행 가능한 자리별 그래프로 나눠 맡겨라. JSON 배열만 출력: [{"seat":"자리","title":"할 일","graphId":"설치된 그래프 ID 또는 빈 문자열","inputs":{},"after":[]}]. 각 행에는 선택 칸 "output":"report|slides|research|post|video|answer"를 쓸 수 있다: ${Object.entries(OUTPUT_KINDS).map(([kind, entry]) => `${entry.guidance} = ${kind}${entry.fileName ? ` (${entry.fileName})` : ''}`).join(', ')}; 그 외 일은 report로 둔다. 앞 항목의 결과가 있어야 할 수 있는 일(예: 점검·조사 «결과로» 쓰는 한 장 · 보고)은 after 에 그 앞 항목 번호(0부터)를 적는다 — 그 항목은 앞 항목이 끝난 뒤 그 결과를 받아 시작한다. 서로 기다릴 필요가 없으면 after 는 빈 배열. 자리 이름은 주어진 목록에서만, 그래프 ID는 설치된 목록에서만 고른다. 맞는 그래프가 없으면 graphId=""로 표시한다. 그래프에 inputKeys 가 있으면 inputs 를 그 키로만 채우되 한 줄과 아래 알려진 값에서 얻을 수 있는 값만 넣는다(모르는 값은 넣지 않는다). image/photo/file 입력에는 알맞은 첨부 경로를 쓸 수 있다. folder 입력에는 첨부가 없거나 첨부 사진이 그 현장 폴더 안에 있을 때만 오늘 현장 폴더를 쓸 수 있다. 다른 현장 사진이나 출처를 모르는 업로드 사진이 있으면 폴더를 추측하지 마라. 그 그래프가 꼭 받아야 할 값(예: 브랜드 이름 · 사진 파일)을 알 수 없으면 graphId=""로 두고 title 끝에 « — <무엇> 필요»를 적는다. 단순히 묻는 말에는 없는 그래프를 지어내지 말고 graphId=""로 표시한다. 없는 그래프나 산출을 지어내지 마라. 바깥 게시·발행·광고·결제는 승인 노드를 거치기 전 실행하면 안 된다.\n자리: ${JSON.stringify(seats)}\n실행 가능한 그래프: ${JSON.stringify(graphs.map(({ id, title, description, inputKeys }) => ({ id, title, description, ...(inputKeys ? { inputKeys } : {}) })))}\n${fieldFolder ? `알려진 값: 오늘 현장 폴더 = ${fieldFolder}\n` : ''}${supplied ? `${supplied}\n` : ''}한 줄: ${JSON.stringify(text)}`;
+}
+
+export async function judgeExecPlan(text: string, graphs: readonly InstalledGraph[], seats: readonly string[], attachments: readonly ExecAttachment[] = [], fieldFolder: string | null = latestFieldFolder()): Promise<unknown> {
+  const prompt = execPlanPrompt(text, graphs, seats, attachments, fieldFolder);
   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') });
@@ -120,13 +165,17 @@ export async function planExecRequest(text: string, deps: {
   graphs?: () => Promise<InstalledGraph[]>;
   seats?: () => string[];
   judge?: typeof judgeExecPlan;
+  attachments?: readonly ExecAttachment[];
+  fieldFolder?: () => string | null;
 } = {}): Promise<ExecPlanItem[]> {
   const graphs = await (deps.graphs ?? installedGraphs)();
   const seats = (deps.seats ?? seatTitles)();
-  const raw = await (deps.judge ?? judgeExecPlan)(text, graphs, seats);
+  const attachments = deps.attachments ?? [];
+  const fieldFolder = (deps.fieldFolder ?? latestFieldFolder)();
+  const raw = await (deps.judge ?? judgeExecPlan)(text, graphs, seats, attachments, fieldFolder);
   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, index: number) => {
+  const plans: ExecPlanItem[] = raw.map((item: unknown, index: number) => {
     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()
@@ -136,11 +185,40 @@ export async function planExecRequest(text: string, deps: {
     const after = Array.isArray(row.after)
       ? [...new Set(row.after.filter((n): n is number => Number.isInteger(n) && (n as number) >= 0 && (n as number) < index))]
       : [];
+    const graph = known.get(row.graphId);
+    const modelOutput = typeof row.output === 'string' && Object.hasOwn(OUTPUT_KINDS, row.output)
+      ? row.output as OutputKind : undefined;
+    const picked = modelOutput ?? pickDefaultOutput(row.title).kind;
+    const output = picked === 'video' && !graph ? 'report' : picked;
+    debug.log('exec.plan', 'default-output', { kind: output, source: modelOutput === output ? 'model' : 'rule' });
+    const inputs = { ...row.inputs as Record<string, unknown> };
+    let folderReason: string | undefined;
+    if (graph) {
+      for (const key of graph.inputKeys ?? []) {
+        if (key === 'folder') {
+          // A folder input must contain every attached photo — never guess it from «the latest event» (review r1).
+          const photos = attachments.filter(a => /\.(?:png|jpe?g|webp|gif|heic)$/i.test(a.name)).map(a => resolve(a.path));
+          const holds = (folder: string) => photos.every(photo => photo.startsWith(`${resolve(folder)}${sep}`));
+          const given = typeof inputs.folder === 'string' ? inputs.folder : undefined;
+          if (given !== undefined) {
+            if (!holds(given)) { delete inputs.folder; folderReason = `${row.seat}: folder 필요 — 첨부 사진이 그 현장 폴더 안에 없습니다`; }
+          } else if (fieldFolder && holds(fieldFolder)) inputs.folder = fieldFolder;
+          else if (photos.length) folderReason = `${row.seat}: folder 필요 — 첨부 사진의 현장 폴더를 알 수 없습니다`;
+          continue;
+        }
+        if (inputs[key] !== undefined) continue;
+        if (['image', 'photo', 'file'].includes(key)) {
+          const attachment = attachments.find(a => key === 'file' || /\.(?:png|jpe?g|webp|gif|heic)$/i.test(a.name));
+          if (attachment) inputs[key] = attachment.path;
+        }
+      }
+    }
     return {
-      seat: row.seat, title: row.title.trim(), graphId: row.graphId,
-      inputs: row.inputs as Record<string, unknown>,
+      seat: row.seat, title: row.title.trim(), graphId: row.graphId, inputs, output,
       ...(after.length ? { after } : {}),
-      ...(!known.has(row.graphId) ? { reason: `${row.seat}: 요청에 맞는 설치된 실행 그래프가 없습니다` } : {}),
+      ...(!graph ? { reason: `${row.seat}: 요청에 맞는 설치된 실행 그래프가 없습니다` } : folderReason ? { reason: folderReason } : {}),
     };
   });
+  for (const plan of plans) debug.log('exec.planner', 'select', { seat: plan.seat, chosen: plan.graphId, candidates: graphs.slice(0, 10).map(graph => graph.id) });
+  return plans;
 }

package/src/exec-requests/runner.ts

@@ -1,16 +1,26 @@
-import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, realpathSync, statSync, writeFileSync } 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 { notifyExecRequestTransition } from '../web-push/notify-exec-request.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';
+import { ExecRequestStore, type ExecAttachment, type ExecRequest, type ExecResult, type ExecSeat } from './store.js';
+import { answerAsSeat } from '../intake-plane/seat-answer.js';
+import { redactSecrets } from '../task-cards/card-store.js';
+import { recordOutput } from '../outputs/ledger.js';
+import type { OutputKind } from './default-outputs.js';
+
+function recordResult(result: ExecResult, id: string, root: string, kind: OutputKind | 'file'): void {
+  recordOutput({ source: 'exec', sourceId: id, seat: result.seat, title: result.title, url: result.url, kind }, root);
+}
 
 export interface ExecRunnerDeps {
   store?: ExecRequestStore;
   graphs?: () => Promise<InstalledGraph[]>;
-  plan?: (text: string) => Promise<ExecPlanItem[]>;
+  plan?: (text: string, attachments?: readonly ExecAttachment[]) => Promise<ExecPlanItem[]>;
+  answer?: typeof answerAsSeat;
   run?: typeof runGraph;
   root?: string;
 }
@@ -38,7 +48,11 @@ function safeFile(path: string, root: string, graphId: string, runId: string): s
       ? realpathSync(artifactsDir) : null;
     const inRunDirectory = realArtifactsDir === join(base, `${runId}.json.artifacts`)
       && real.startsWith(`${realArtifactsDir}${sep}`);
-    if ((!local && !inRunDirectory) || !statSync(real).isFile()) return null;
+    // EXEC2 — plugin graphs (doc-draft · geo-check) write into `<graphId>/<runId>/`; that directory is this run's own too.
+    const runDir = join(allowed, runId);
+    const realRunDir = existsSync(runDir) && statSync(runDir).isDirectory() ? realpathSync(runDir) : null;
+    const inOwnRunDir = realRunDir === join(base, runId) && real.startsWith(`${realRunDir}${sep}`);
+    if ((!local && !inRunDirectory && !inOwnRunDir) || !statSync(real).isFile()) return null;
     return real;
   } catch { return null; }
 }
@@ -56,8 +70,32 @@ function fileName(path: string, runId: string): string {
   return `${runId}--${digest}--${basename(path)}`;
 }
 
+/** EXEC2 — `report` is how geo-check names its file; treat it like `file`/`path`. */
+function fileCandidate(output: Record<string, unknown>): string | null {
+  if (typeof output.file === 'string') return output.file;
+  if (typeof output.path === 'string') return output.path;
+  if (typeof output.report === 'string' && /\.(md|txt|pdf)$/i.test(output.report)) return output.report;
+  return null;
+}
+
+const TEXT_RESULT_LIMIT = 200_000;
+const TEXT_RESULT_NAME = 'result.md';
+
+/** EXEC2 — a done seat whose graph only answered in text gets that text as a run artifact (redacted), so the result is viewable. */
+function textResultFile(seat: ExecSeat, state: GraphRunState, root: string): string | null {
+  const outputs = [...(state.nodes ?? [])].reverse().map(node => lastJsonObject(node.output)).filter((o): o is Record<string, unknown> => !!o);
+  const text = outputs.map(o => o.markdown ?? o.text).find((v): v is string => typeof v === 'string' && v.trim().length > 0);
+  if (!text || !SEGMENT.test(seat.graphId) || !SEGMENT.test(seat.runId)) return null;
+  const dir = join(root, 'graph-runs', seat.graphId, `${seat.runId}.json.artifacts`);
+  const path = join(dir, TEXT_RESULT_NAME);
+  try {
+    if (!existsSync(path)) { mkdirSync(dir, { recursive: true }); writeFileSync(path, redactSecrets(text.slice(0, TEXT_RESULT_LIMIT)), { mode: 0o600 }); }
+    return path;
+  } catch { return null; }
+}
+
 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;
+  const candidate = fileCandidate(output);
   let url: string;
   let kind: ExecResult['kind'];
   let name: string;
@@ -95,6 +133,7 @@ function syncRun(item: ExecRequest, seat: ExecSeat, state: GraphRunState, root:
   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 });
+      notifyTransition(item, item.status, item.approvals.length);
     }
   } else item.approvals = item.approvals.filter(a => a.graphId !== seat.graphId || a.runId !== seat.runId);
   for (const node of state.nodes ?? []) {
@@ -104,12 +143,36 @@ function syncRun(item: ExecRequest, seat: ExecSeat, state: GraphRunState, root:
     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);
+      if (result && !item.results.some(existing => existing.seat === result.seat && existing.url === result.url)) {
+        item.results.push(result);
+        recordResult(result, item.id, root, seat.output ?? 'file');
+      }
+    }
+  }
+  if (seat.status === 'done' && !item.results.some(existing => existing.seat === seat.seat)) {
+    const file = textResultFile(seat, state, root);
+    const result = file ? resultOf({ file, title: seat.title }, seat, item.id, root) : null;
+    if (result) {
+      item.results.push(result);
+      recordResult(result, item.id, root, seat.output ?? 'file');
+    } else {
+      const keys = [...new Set((state.nodes ?? []).flatMap(node => Object.keys(lastJsonObject(node.output) ?? {})))];
+      debug.log('exec.result', 'none', { seat: seat.seat, graphId: seat.graphId, keys });
     }
   }
   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}`;
+  if (seat.status === 'failed') seat.reason = failureReason(state);
+}
+
+/** EXEC2 — the failing node's own error (e.g. doc-draft `check` {outcome:'fail', error}) beats the terminal gate's empty one. */
+function failureReason(state: GraphRunState): string {
+  for (const node of [...(state.nodes ?? [])].reverse()) {
+    if (typeof node.error === 'string' && node.error) return node.error;
+    const output = lastJsonObject(node.output);
+    if (output && typeof output.error === 'string' && output.error) return redactSecrets(output.error);
+  }
+  return `그래프 런 ${state.status}`;
 }
 
 const PRIOR_TEXT_LIMIT = 4_000;
@@ -129,8 +192,14 @@ export function withPriorResults(inputs: Record<string, unknown> | undefined, pr
   return { ...base, context: `${previous}앞 자리 결과:\n${parts.join('\n\n')}` };
 }
 
+function notifyTransition(item: ExecRequest, from: ExecRequest['status'], pendingApprovals: number): void {
+  void notifyExecRequestTransition({ id: item.id, text: item.text, from, to: item.status,
+    summary: item.summary, pendingApprovals }).catch(() => { /* Push never interrupts execution. */ });
+}
+
 function aggregate(item: ExecRequest): void {
   if (item.status === 'planning' || item.seats.length === 0) return;
+  const previous = item.status;
   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';
   // 실패면 요약은 «실패 사유»가 이긴다 — 먼저 끝난 자리의 산출 설명이 남아 있어도 덮는다(혼합 결과에서 성공처럼 보이지 않게).
@@ -138,6 +207,7 @@ function aggregate(item: ExecRequest): void {
     const reasons = item.seats.filter(seat => seat.status === 'failed').map(seat => seat.reason ?? `${seat.seat}: 그래프 실행 실패`);
     if (reasons.length > 0) item.summary = reasons.join('; ');
   }
+  if (previous !== item.status && (item.status === 'done' || item.status === 'failed')) notifyTransition(item, previous, item.approvals.length);
 }
 
 export class ExecRequestRunner {
@@ -156,10 +226,12 @@ export class ExecRequestRunner {
       if (item.status === 'planning') {
         item.status = 'failed';
         item.summary = '데몬 재시작으로 COO 계획이 중단됐습니다';
+        notifyTransition(item, 'planning', item.approvals.length);
       } else {
         if (item.seats.length === 0) {
           item.status = 'failed';
           item.summary = '데몬 재시작으로 자리 배정이 중단됐습니다';
+          notifyTransition(item, 'running', item.approvals.length);
         }
         for (const seat of item.seats) {
           if (seat.status === 'done' || seat.status === 'failed') continue;
@@ -192,14 +264,16 @@ export class ExecRequestRunner {
     }
   }
 
-  submit(text: string): ExecRequest {
-    const item = this.store.create(text);
+  submit(text: string, attachments?: ExecAttachment[]): ExecRequest {
+    const item = this.store.create(text, attachments);
     void this.execute(item.id).catch(error => {
       const current = this.store.get(item.id);
       if (!current) return;
+      const previous = current.status;
       current.status = 'failed';
       current.summary = error instanceof Error ? error.message : String(error);
       this.store.save(current);
+      if (previous !== current.status) notifyTransition(current, previous, current.approvals.length);
       debug.log('exec-requests', 'failed', { id: item.id, reason: current.summary });
     });
     return item;
@@ -209,10 +283,45 @@ export class ExecRequestRunner {
     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 plans = await (this.deps.plan ?? ((text: string, attachments?: readonly ExecAttachment[]) => planExecRequest(text, { graphs: async () => graphs, attachments })))(item.text, item.attachments);
     const byId = new Map(graphs.map(graph => [graph.id, graph]));
+    // Every clause must be a question — «상황 알려줘? 카드 만들어줘» carries a work item (review r1).
+    const clauses = [...item.text.trim().matchAll(/([^?？.!。\n]+)([?？]?)/g)].map(m => ({ body: m[1]!.trim(), asked: m[2] !== '' })).filter(c => c.body);
+    const isQuestion = clauses.length > 0 && clauses.every(c => c.asked
+      || /(?:알려\s*줘|알려\s*주세요|보여\s*줘|보여\s*주세요|어떻게|무엇|뭐|어떤|언제|누구|질문|인가요|나요|습니까)$/.test(c.body));
+    if (isQuestion && plans.length > 0 && plans.every(plan => !plan.graphId
+      && !/\s—\s.+\s필요\s*$/.test(plan.title) && !/\s—\s.+\s필요\s*$/.test(plan.reason ?? '')
+      && !/(?:초안|작성|제작|생성|게시|분석|전략|메일|보고서)/.test(plan.title)) && !(item.attachments?.length)) {
+      for (const plan of plans) {
+        const answered = await (this.deps.answer ?? answerAsSeat)(plan.seat, item.text);
+        if (!answered) {
+          item.seats.push({ seat: plan.seat, title: plan.title, status: 'failed', graphId: '', runId: '',
+            reason: plan.reason ?? `${plan.seat}: 요청에 맞는 설치된 실행 그래프가 없습니다` });
+          continue;
+        }
+        const seat: ExecSeat = { seat: plan.seat, title: plan.title, status: 'done', graphId: 'seat-answer', runId: randomUUID(), ...(plan.output ? { output: plan.output } : {}) };
+        const dir = join(this.root, 'graph-runs', seat.graphId);
+        const statePath = join(dir, `${seat.runId}.json`);
+        const artifactDir = join(dir, `${seat.runId}.json.artifacts`);
+        mkdirSync(artifactDir, { recursive: true });
+        const file = join(artifactDir, TEXT_RESULT_NAME);
+        writeFileSync(file, redactSecrets(answered.text.slice(0, TEXT_RESULT_LIMIT)), { mode: 0o600 });
+        const state: GraphRunState = { graphId: seat.graphId, runId: seat.runId, status: 'done', path: [], executed: 0, dryRun: false, statePath, nodes: [] };
+        writeFileSync(statePath, JSON.stringify(state), { mode: 0o600 });
+        item.seats.push(seat);
+        const result = resultOf({ file, title: answered.title }, seat, id, this.root);
+        if (result) {
+          item.results.push(result);
+          recordResult(result, item.id, this.root, seat.output ?? 'file');
+        }
+      }
+      item.status = 'running';
+      aggregate(item);
+      this.store.save(item);
+      return;
+    }
     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.after?.length ? { after: plan.after } : {}),
+      runId: plan.reason || !byId.has(plan.graphId) ? '' : randomUUID(), inputs: plan.inputs, ...(plan.output ? { output: plan.output } : {}), ...(plan.after?.length ? { after: plan.after } : {}),
       ...(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 })) });
@@ -366,12 +475,14 @@ export class ExecRequestRunner {
         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;
+          const candidate = fileCandidate(artifact);
           if (typeof candidate !== 'string') continue;
           const path = safeFile(candidate, this.root, seat.graphId, seat.runId);
           if (path && fileName(path, seat.runId) === name) return path;
         }
       }
+      const text = safeFile(join(this.root, 'graph-runs', seat.graphId, `${seat.runId}.json.artifacts`, TEXT_RESULT_NAME), this.root, seat.graphId, seat.runId);
+      if (text && fileName(text, seat.runId) === name) return text;
     } catch { return null; }
     return null;
   }

package/src/exec-requests/store.ts

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { getElanousConfigDir } from '../elanous-config-dir.js';
+import type { OutputKind } from './default-outputs.js';
 
 export type SeatStatus = 'waiting' | 'running' | 'done' | 'failed';
 export interface ExecSeat {
@@ -10,6 +11,8 @@ export interface ExecSeat {
   status: SeatStatus;
   graphId: string;
   runId: string;
+  /** Requested output category, distinct from the result file MIME kind. */
+  output?: OutputKind;
   inputs?: Record<string, unknown>;
   reason?: string;
   /** A5b — indexes of earlier seats this seat waits for. */
@@ -22,9 +25,15 @@ export interface ExecResult {
   url: string;
   sources?: Array<{ title: string; url: string }>;
 }
+export interface ExecAttachment {
+  name: string;
+  path: string;
+}
+
 export interface ExecRequest {
   id: string;
   text: string;
+  attachments?: ExecAttachment[];
   createdAt: string;
   status: 'planning' | 'running' | 'done' | 'failed';
   summary: string;
@@ -39,8 +48,8 @@ export class ExecRequestStore {
   readonly dir: string;
   constructor(configDir = getElanousConfigDir()) { this.dir = join(configDir, 'exec-requests'); }
 
-  create(text: string): ExecRequest {
-    const item: ExecRequest = { id: randomUUID(), text, createdAt: new Date().toISOString(), status: 'planning', summary: '', seats: [], results: [], approvals: [] };
+  create(text: string, attachments?: ExecAttachment[]): ExecRequest {
+    const item: ExecRequest = { id: randomUUID(), text, ...(attachments !== undefined ? { attachments } : {}), createdAt: new Date().toISOString(), status: 'planning', summary: '', seats: [], results: [], approvals: [] };
     this.save(item);
     return item;
   }