elanous 0.2.6 → 0.2.7

package/src/domains/core-tools.ts

@@ -15,6 +15,8 @@ import { existsSync } from 'node:fs';
 import { Database } from 'bun:sqlite';
 import type { LLMToolSpec } from '../llm.js';
 import { debug } from '../debug/log.js';
+import { runRecall, type RecallSearch } from '../tool-runtime/self-cognition-runtimes.js';
+import type { ToolRuntimeContext } from '../tool-runtime/types.js';
 import { SCHEDULE_MANAGE_SPEC, dispatchScheduleManage } from './schedule-manage-tool.js';
 import { SESSION_MANAGE_SPEC, dispatchSessionQuery } from './session-query-tool.js';
 import { AUTOPILOT_MISSION_SPEC, dispatchAutopilotMissions } from '../autopilot/mission-tool.js';
@@ -43,6 +45,7 @@ const MEMORY_RECALL_SPEC: LLMToolSpec = {
       sinceHours: { type: 'number', description: '조회 기간 시간(기본 168=7일).' },
       limit: { type: 'number', description: '반환 건수(기본 8).' },
       restoreId: { type: 'string', description: '느린 복원(선택) — archived 후보의 id 를 지정하면 그 cold 기억을 S3 에서 복원(recall_count++·warm 재활성화)해 본문 반환. 회상 결과 archived 에 관련 후보가 있고 본문이 필요할 때만.' },
+      timeBudgetMs: { type: 'number', description: '기억 조회 시간 예산(밀리초·기본 60000). 초과 시 찾은 것까지 부분 반환.' },
     },
     required: [],
   },
@@ -50,7 +53,7 @@ const MEMORY_RECALL_SPEC: LLMToolSpec = {
 
 /** memory_recall 코어(db 주입·테스트 가능). restoreId 지정 시 느린 복원(축B P2), 아니면 회상 + archive 발견.
  *  recency+importance+relevance 스코어. restoreDeps 는 테스트 S3 mock(생략 시 기본 S3). */
-export function recallOrRestore(mdb: Database, args: Record<string, unknown>, restoreDeps?: ArchiveS3Deps): unknown {
+export function recallOrRestore(mdb: Database, args: Record<string, unknown>, restoreDeps?: ArchiveS3Deps, onPartial?: (result: Record<string, unknown>) => void): unknown {
   // ★ 축B P2 느린 복원 — restoreId 지정 시 cold 기억을 S3 에서 명시적 복원(recall_count++·warm 재활성화).
   //   자동 아님(명시적) = 복원 폭주 방지. 죽어있던 restoreFromArchive 호출부 배선.
   if (typeof args.restoreId === 'string' && args.restoreId) {
@@ -75,15 +78,17 @@ export function recallOrRestore(mdb: Database, args: Record<string, unknown>, re
     ...(typeof args.sinceHours === 'number' ? { sinceHours: args.sinceHours } : {}),
     ...(typeof args.limit === 'number' ? { limit: args.limit } : {}),
   });
+  const mappedHits = hits.map(h => ({
+    when: h.ts, surface: h.surface, kind: h.kind,
+    text: h.text.slice(0, 400), importance: h.importance,
+    score: Math.round(h.score * 1000) / 1000,
+  }));
+  onPartial?.({ hits: mappedHits, count: hits.length });
   // M2 — cold(S3 보관) 기억 메타 발견(본문 fetch 없음·빠름). 존재+id 알리고 복원은 restoreId 로 명시적.
   const q = typeof args.query === 'string' ? String(args.query) : '';
   const archived = q ? searchArchive(mdb, q, { ...(typeof args.domain === 'string' && args.domain ? { domain: String(args.domain) } : {}), limit: 3 }) : [];
   return {
-    hits: hits.map(h => ({
-      when: h.ts, surface: h.surface, kind: h.kind,
-      text: h.text.slice(0, 400), importance: h.importance,
-      score: Math.round(h.score * 1000) / 1000,
-    })),
+    hits: mappedHits,
     count: hits.length,
     ...(archived.length ? { archived: archived.map(a => ({ id: a.id, when: a.ts, summary: a.summary, note: 'cold·S3 보관(restoreId 로 느린 복원)' })) } : {}),
     note: '내가 발송/통지한 것의 원장 회상(크로스서피스 기억·hot/warm). archived=흐려져 S3 로 이관된 cold 기억(존재+id·본문은 restoreId 로 느린 복원). 비었으면 해당 기간 발송 없음.',
@@ -91,18 +96,18 @@ export function recallOrRestore(mdb: Database, args: Record<string, unknown>, re
 }
 
 /** memory_recall 공유 구현(finance-tools 에서 이관). db 열기 + recallOrRestore 위임. */
-async function dispatchMemoryRecall(args: Record<string, unknown>): Promise<unknown> {
+async function dispatchMemoryRecall(args: Record<string, unknown>, onPartial?: (result: Record<string, unknown>) => void): Promise<unknown> {
   if (!existsSync(surfaceEventsDbPath())) {
     return { hits: [], note: '발송 원장 미생성 — 아직 기록된 발송이 없음(데몬 재시작 후 sendOutbound부터 적재).' };
   }
   const mdb = openSurfaceEventsDb();
-  try { return recallOrRestore(mdb, args); }
+  try { return recallOrRestore(mdb, args, undefined, onPartial); }
   catch (e) { return { error: `기억 회상 실패: ${e instanceof Error ? e.message.slice(0, 100) : String(e)}` }; }
   finally { mdb.close(); }
 }
 
 /** L2 코어 앱 도구 dispatch 핸들러 — 이름 → 구현. 새 코어 도구는 여기 추가. */
-const CORE_TOOL_HANDLERS: Record<string, (args: Record<string, unknown>) => Promise<unknown>> = {
+const CORE_TOOL_HANDLERS: Record<string, (args: Record<string, unknown>, onPartial?: (result: Record<string, unknown>) => void) => Promise<unknown>> = {
   schedule_manage: dispatchScheduleManage,
   session_manage: (args) => dispatchSessionQuery(args), // 대화 세션 검색·열람·목록·삭제(내용/ID/텔레그램)
   memory_recall: dispatchMemoryRecall,
@@ -115,26 +120,44 @@ const CORE_TOOL_HANDLERS: Record<string, (args: Record<string, unknown>) => Prom
   mission_decide: dispatchMissionDecide, // 미션 결정 기록(re-ground·defer·boundary…)·3박자 주입·코어
 };
 
+/** Worker-side search entry: dispatch must not re-enter its own budget wrapper. */
+export function dispatchRecallUnbudgeted(name: 'memory_recall' | 'self_recall', args: Record<string, unknown>, onPartial: (result: Record<string, unknown>) => void): Promise<unknown> {
+  return CORE_TOOL_HANDLERS[name]!(args, onPartial);
+}
+
 /** L2 코어 앱 도구 spec 목록(전 서피스 공용). */
-export const CORE_TOOL_SPECS: LLMToolSpec[] = [SCHEDULE_MANAGE_SPEC, SESSION_MANAGE_SPEC, MEMORY_RECALL_SPEC, FACT_CHECK_SPEC, SELF_RECALL_SPEC, AUTOPILOT_MISSION_SPEC, OPS_STATUS_SPEC, SE_BUILD_SPEC, LOGS_QUERY_SPEC, MISSION_DECIDE_SPEC];
+const SELF_RECALL_BUDGET_SPEC: LLMToolSpec = {
+  ...SELF_RECALL_SPEC,
+  parameters: {
+    ...SELF_RECALL_SPEC.parameters,
+    properties: {
+      ...(SELF_RECALL_SPEC.parameters.properties as Record<string, unknown>),
+      timeBudgetMs: { type: 'number', description: '기억 조회 시간 예산(밀리초·기본 60000). 초과 시 찾은 것까지 부분 반환.' },
+    },
+  },
+};
+export const CORE_TOOL_SPECS: LLMToolSpec[] = [SCHEDULE_MANAGE_SPEC, SESSION_MANAGE_SPEC, MEMORY_RECALL_SPEC, FACT_CHECK_SPEC, SELF_RECALL_BUDGET_SPEC, AUTOPILOT_MISSION_SPEC, OPS_STATUS_SPEC, SE_BUILD_SPEC, LOGS_QUERY_SPEC, MISSION_DECIDE_SPEC];
 
 export interface CoreTools {
   specs: LLMToolSpec[];
   names: Set<string>;
-  dispatch: (name: string, args: Record<string, unknown>) => Promise<unknown>;
+  dispatch: (name: string, args: Record<string, unknown>, onPartial?: (result: Record<string, unknown>) => void, context?: ToolRuntimeContext) => Promise<unknown>;
 }
 
 /** 서피스 무관 코어 앱 도구 세트. 모든 서피스가 이걸 조립 → 코어 도구 단일 출처 상속.
  *  L1(native)·L3(finance 팩)와 조합해 쓴다. dispatch 는 이름으로 라우팅(미등록=error). */
-export function buildCoreTools(): CoreTools {
+export function buildCoreTools(recallSearch?: RecallSearch): CoreTools {
   const names = new Set(CORE_TOOL_SPECS.map(s => s.name));
   return {
     specs: CORE_TOOL_SPECS,
     names,
-    dispatch: async (name, args) => {
+    dispatch: async (name, args, onPartial, context) => {
       const h = CORE_TOOL_HANDLERS[name];
       if (!h) return { error: `unknown core tool: ${name}` };
-      return h(args);
+      if (name === 'memory_recall' || name === 'self_recall') {
+        return runRecall(name, args, context ?? { surface: 'skill' }, recallSearch, onPartial);
+      }
+      return h(args, onPartial);
     },
   };
 }

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.error(`[outbound] 야간 무음(00:00~06:30 KST) — 보류 적재 (${kind})`);
-    logSend('deferred', kind, { reason: 'quiet-hours' });  // 밀림 적재 관측
+    return true;
   } catch (e) {
     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,14 +253,26 @@ 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.error('[outbound] 야간 무음 우회 — 최근 사용자 활동(깨어있음) → 즉시 발송 + 보류분 flush');
@@ -245,14 +282,16 @@ export function sendOutbound(text: string, kind = 'alert', origin?: MissionOrigi
   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;
 }
 

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}: 요청에 맞는 설치된 실행 그래프가 없습니다` } : {}),
+    };
+  });
+}