elanous 0.2.9 → 0.2.10

package/src/domains/outbound-alert.ts

@@ -13,9 +13,9 @@ import { conatusEnv } from './conatus-env.js';
 import { spillLongContent } from '../storage/content-spill.js';
 import { openSurfaceEventsDb, recordEvent } from './surface-events.js';
 import { latestUserIntentTs } from '../user-intent/index.js';
-import { getUserConfig } from '../user-config.js';
+import { getUserConfig, type UserConfig } from '../user-config.js';
 import { resolveChannelBotToken } from '../channel-bot-token.js';
-import { kindRouteTarget } from './telegram-kind-route.js';
+import { isOperationalKind, kindRouteTarget, logKindRouteFallback, mainHomeTarget } from './telegram-kind-route.js';
 import { debug } from '../debug/log.js';
 import { resolveDaemonEndpoint } from '../nexus/daemon-endpoint.js';
 import { effectiveInstanceRoot, prodInstanceRoot } from '../instance/resolve.js';
@@ -210,9 +210,14 @@ export function flushDeferred(path = DEFERRED_PATH): number {
   ].join('\n');
   observeFlush(items.length, lagMin, [...new Set(items.map(i => i.kind))]);
   let delivered = 0;
-  // origin 없는 것 = report 묶음(기존 동작·finance/크론 알림).
+  // origin 없는 finance 는 기존 report 묶음. 운영 보류분은 별도로 묶어 운영 봇 경계를 유지한다.
   const noOrigin = items.filter(i => !i.origin);
-  if (noOrigin.length && deliver(fmt(noOrigin), 'report')) delivered += noOrigin.length;
+  const tradingBatch = noOrigin.filter(i => !isOperationalKind(i.kind));
+  if (tradingBatch.length && deliver(fmt(tradingBatch), 'report')) delivered += tradingBatch.length;
+  for (const kind of new Set(noOrigin.filter(i => isOperationalKind(i.kind)).map(i => i.kind))) {
+    const batch = noOrigin.filter(i => i.kind === kind);
+    if (deliver(fmt(batch), kind)) delivered += batch.length;
+  }
   // origin 있는 것 = 발신 채널·스레드별로 묶어 서로 다른 수신자에게 섞이지 않게 발송.
   const groups = new Map<string, { origin: MissionOrigin; list: Item[] }>();
   for (const it of items) {
@@ -402,20 +407,43 @@ function sendTelegramRaw(token: string, chatId: string | number, text: string, t
   return ok;
 }
 
-/** 텔레그램 직접 발송(TELEGRAM_BOT_TOKEN/CHAT_ID — env 우선, 없으면 CONATUS/.env). report 폴백. */
-function sendTelegramDirect(text: string, kind?: string): boolean {
-  // A purpose kind with a channel role (intake · ops-*) goes to that channel even when the daemon is down.
-  try {
-    const target = kindRouteTarget(getUserConfig(), kind);
-    if (target) return sendTelegramRaw(target.botToken, String(target.chatId), text);
-  } catch { /* fall through to the legacy direct path */ }
+/** 텔레그램 직접 발송. 운영 kind 는 메인 봇/홈 밖의 env 로 내려가지 않는다. */
+export function sendTelegramDirect(
+  text: string, kind?: string,
+  deps: { config?: UserConfig; sendRaw?: typeof sendTelegramRaw; legacyEnv?: typeof conatusEnv } = {},
+): boolean {
+  const sendRaw = deps.sendRaw ?? sendTelegramRaw;
+  let cfg: UserConfig | undefined;
+  try { cfg = deps.config ?? getUserConfig(); } catch { /* unavailable config: operational delivery still fails closed */ }
+  if (cfg) {
+    try {
+      const target = kindRouteTarget(cfg, kind);
+      if (target) return sendRaw(target.botToken, String(target.chatId), text);
+    } catch { /* unavailable channel routing: fall through */ }
+  }
+  if (isOperationalKind(kind)) {
+    let home: ReturnType<typeof mainHomeTarget> = null;
+    let mainToken = '';
+    try {
+      if (cfg) {
+        mainToken = resolveChannelBotToken('telegram', cfg).token;
+        home = mainHomeTarget(cfg);
+      }
+    } catch { /* unavailable main bot */ }
+    const rcToken = cfg?.telegram.reportChannel?.botToken;
+    logKindRouteFallback(kind, home ? 'main-home' : 'none', !!mainToken && !!cfg?.telegram.reportChannel && (!rcToken || rcToken === mainToken));
+    if (home) return sendRaw(home.botToken, String(home.chatId), text);
+    console.error('[outbound] 운영 kind 메인 봇/홈 미설정 — 콘솔 출력\n' + text);
+    return false;
+  }
   let tok = process.env.TELEGRAM_BOT_TOKEN || '';
   let chat = process.env.TELEGRAM_CHAT_ID || '';
   if (!tok || !chat) {
-    const env = conatusEnv();
+    const env = (deps.legacyEnv ?? conatusEnv)();
     tok = tok || env.TELEGRAM_BOT_TOKEN || '';
     chat = chat || env.TELEGRAM_CHAT_ID || '';
   }
+  logKindRouteFallback(kind, tok && chat ? 'conatus-env' : 'none', false);
   if (!tok || !chat) { console.error('[outbound] 토큰/chat 미설정 — 콘솔 출력\n' + text); return false; }
-  return sendTelegramRaw(tok, chat, text);
+  return sendRaw(tok, chat, text);
 }

package/src/domains/release-tool.ts

@@ -0,0 +1,168 @@
+import type { LLMToolSpec } from '../llm.js';
+import type { ToolRuntimeContext } from '../tool-runtime/types.js';
+import { debug } from '../debug/log.js';
+import { requestConfirmation, type ConfirmOpts, type ConfirmResult } from '../hitl/confirm.js';
+import { devVersion, listChecklist, summarizeChecklist, type Checklist } from '../release-loop/checklist.js';
+import { add, move, validateVersion } from '../release-loop/feature-store.js';
+import { formatKst, getSchedule, setSchedule, type ReleaseSchedule } from '../release-loop/release-schedule.js';
+import { latestGraphRun, type GraphRunState } from '../graph-runner/runner.js';
+import { formatElanousCard, type ElanousCard } from './elanous-card.js';
+
+export const RELEASE_STATUS_SPEC: LLMToolSpec = {
+  name: 'release_status',
+  description: '판 어디까지 · 컷 언제 · 릴리스 상황 · 판올림 · 체크리스트 · 남은 칸을 읽는다. 판 일정, 빨강 칸, 담당별 노랑, 최근 발행 런을 조회하는 읽기 전용 도구. 행정 업무는 coo_admin.',
+  parameters: { type: 'object', properties: { version: { type: 'string', description: '조회할 판. 생략하면 개발 판과 다음 판.' } }, required: [] },
+};
+
+export const RELEASE_CHANGE_SPEC: LLMToolSpec = {
+  name: 'release_change',
+  description: '오너의 판올림 변경 요청 — 체크리스트 칸 추가, 칸을 다른 판으로 이동, 판 컷·착지 마감 수정. 실행 전에 사람에게 한 번 확인받는다. 읽기 요청에는 release_status 사용.',
+  parameters: { type: 'object', properties: {
+    action: { type: 'string', enum: ['add-item', 'move-item', 'set-schedule'] },
+    version: { type: 'string', description: 'add-item 또는 set-schedule 대상 판' },
+    id: { type: 'string', description: '칸 id (add-item 또는 move-item)' },
+    title: { type: 'string', description: '추가할 칸 제목' },
+    owner: { type: 'string', description: '추가할 칸 담당(선택)' },
+    from: { type: 'string', description: '이동 전 판' },
+    to: { type: 'string', description: '이동 후 판' },
+    cutAt: { type: 'string', description: 'ISO 오프셋 포함 컷 시각(선택)' },
+    landBy: { type: 'string', description: 'ISO 오프셋 포함 착지 마감(선택)' },
+  }, required: ['action'] },
+};
+
+export interface ReleaseToolDeps {
+  now?: Date;
+  devVersion?: () => string;
+  checklist?: (version: string) => Checklist;
+  schedule?: (version: string) => ReleaseSchedule | null;
+  latestRun?: (graphId: string) => GraphRunState | null;
+  confirm?: (options: ConfirmOpts) => Promise<ConfirmResult>;
+  add?: typeof add;
+  move?: typeof move;
+  setSchedule?: typeof setSchedule;
+}
+
+function nextVersion(version: string): string {
+  const [major, minor, patch] = version.split('.').map(Number);
+  return `${major}.${minor}.${patch! + 1}`;
+}
+
+function kstDate(iso: string): string {
+  return new Date(Date.parse(iso) + 9 * 60 * 60_000).toISOString().slice(0, 10);
+}
+
+function daysLeft(iso: string, now: Date): number {
+  const due = Date.parse(`${kstDate(iso)}T00:00:00Z`);
+  const today = Date.parse(`${kstDate(now.toISOString())}T00:00:00Z`);
+  return (due - today) / 86_400_000;
+}
+
+function dDay(days: number): string {
+  return days < 0 ? `D+${-days}` : days === 0 ? 'D-day' : `D-${days}`;
+}
+
+export function dispatchReleaseStatus(args: Record<string, unknown>, deps: ReleaseToolDeps = {}): { text: string; structured: Record<string, unknown> } {
+  const requested = args.version;
+  if (requested !== undefined && (typeof requested !== 'string' || !requested.trim())) throw new Error('판 이름이 필요합니다');
+  const version = requested ? null : (deps.devVersion?.() ?? devVersion());
+  const versions = requested ? [requested as string] : [version!, nextVersion(version!)];
+  const now = deps.now ?? new Date();
+  const run = (deps.latestRun ?? latestGraphRun)('release-loop');
+  const latest = run ? { status: run.status, lastNode: run.path.at(-1) ?? null, startedAt: run.startedAt ?? null } : null;
+  const entries = versions.map(v => {
+    validateVersion(v);
+    const schedule = (deps.schedule ?? getSchedule)(v);
+    const data = (deps.checklist ?? listChecklist)(v);
+    const summary = summarizeChecklist(data);
+    const red = data.items.filter(item => item.status === 'red').map(({ id, title, owner }) => ({ id, title, owner: owner ?? '미배정' }));
+    const yellowByOwner: Record<string, number> = {};
+    for (const item of data.items.filter(item => item.status === 'yellow')) {
+      const owner = item.owner ?? '미배정';
+      yellowByOwner[owner] = (yellowByOwner[owner] ?? 0) + 1;
+    }
+    const cutDaysLeft = schedule ? daysLeft(schedule.cutAt, now) : null;
+    const landDaysLeft = schedule?.landBy ? daysLeft(schedule.landBy, now) : null;
+    const cutHoursLeft = schedule ? Math.ceil((Date.parse(schedule.cutAt) - now.getTime()) / 3_600_000) : null;
+    const landHoursLeft = schedule?.landBy ? Math.ceil((Date.parse(schedule.landBy) - now.getTime()) / 3_600_000) : null;
+    return { version: v, schedule: schedule ? { cutAt: schedule.cutAt, landBy: schedule.landBy, cutDaysLeft, landDaysLeft, cutHoursLeft, landHoursLeft } : null,
+      counts: { green: summary.green, yellow: summary.yellow, red: summary.red, done: summary.done }, red, yellowByOwner };
+  });
+  const lines = entries.map(entry => {
+    const schedule = entry.schedule;
+    return `${entry.version} · 컷 ${schedule ? formatKst(schedule.cutAt) : '미정'}${schedule?.landBy ? ` · 착지 마감 ${formatKst(schedule.landBy)}` : ' · 착지 마감 미정'}${schedule ? ` · 컷 ${dDay(schedule.cutDaysLeft!)} (${schedule.cutHoursLeft}시간)${schedule.landDaysLeft !== null ? ` · 착지 ${dDay(schedule.landDaysLeft)} (${schedule.landHoursLeft}시간)` : ''}` : ''}\n` +
+      `초록 ${entry.counts.green} · 노랑 ${entry.counts.yellow} · 빨강 ${entry.counts.red} · 끝 ${entry.counts.done}\n` +
+      `빨강 칸: ${entry.red.length ? entry.red.map(item => `${item.id} ${item.title} (${item.owner})`).join(', ') : '없음'}\n` +
+      `담당별 노랑: ${Object.keys(entry.yellowByOwner).length ? Object.entries(entry.yellowByOwner).map(([owner, count]) => `${owner} ${count}`).join(', ') : '없음'}`;
+  });
+  lines.push(latest ? `최근 발행 런: ${latest.status} · 끝 노드 ${latest.lastNode ?? '없음'} · 시작 ${latest.startedAt ?? '미상'}` : '최근 발행 런: 없음');
+  const cards: ElanousCard[] = [
+    { kind: 'release-schedule', items: entries.map(entry => ({ title: `${entry.version} 컷`, due: entry.schedule ? kstDate(entry.schedule.cutAt) : null, daysLeft: entry.schedule?.cutDaysLeft ?? null, state: entry.schedule ? 'scheduled' : 'undecided', owner: 'release' })), meta: { versions: entries.map(entry => entry.version) } },
+    { kind: 'release-checklist', items: entries.flatMap(entry => entry.red.map(item => ({ title: `${item.id} ${item.title}`, due: null, daysLeft: null, state: 'red', owner: item.owner }))), meta: { counts: entries.map(entry => ({ version: entry.version, ...entry.counts })) } },
+  ];
+  const structured = { releases: entries, latestRun: latest };
+  debug.log('release.tool', 'status', { action: 'status', version: versions.join(',') });
+  return { text: `${lines.join('\n\n')}\n${cards.map(formatElanousCard).join('\n')}`, structured };
+}
+
+function requiredString(args: Record<string, unknown>, key: string): string {
+  const value = args[key];
+  if (typeof value !== 'string' || !value.trim()) throw new Error(`${key} 값이 필요합니다`);
+  return value.trim();
+}
+
+/** Never accepts a user-supplied owner claim: only a human, server-assigned owner context can authorize a mutation. */
+export async function dispatchReleaseChange(args: Record<string, unknown>, context?: ToolRuntimeContext, deps: ReleaseToolDeps = {}): Promise<string> {
+  const action = typeof args.action === 'string' ? args.action : '';
+  const version = typeof args.version === 'string' ? args.version : typeof args.from === 'string' ? args.from : '';
+  const ownerId = context?.verifiedOwner?.id;
+  if (context?.requestOrigin === 'external-agent' || !context?.sessionId || !ownerId?.trim()) {
+    debug.log('release.tool', 'change-refused', { action, version });
+    return '서버에서 검증한 오너의 사람 채팅 문맥에서만 판올림을 바꿀 수 있습니다.';
+  }
+  const channels = context.confirmChannels;
+  if (!channels?.length) {
+    debug.log('release.tool', 'change-refused', { action, version });
+    return '원래 채팅의 확인 채널이 없어 판올림을 바꾸지 않았습니다.';
+  }
+  let prompt: string;
+  let apply: () => void;
+  if (action === 'add-item') {
+    const v = requiredString(args, 'version');
+    const id = requiredString(args, 'id');
+    const title = requiredString(args, 'title');
+    validateVersion(v);
+    const owner = args.owner === undefined ? undefined : requiredString(args, 'owner');
+    prompt = `${v} 에 칸 ${id} «${title}» 추가 — 진행할까요?`;
+    apply = () => { (deps.add ?? add)(v, { id, title, status: 'yellow', ...(owner ? { owner } : {}), updatedAt: new Date().toISOString(), updatedBy: ownerId }); };
+  } else if (action === 'move-item') {
+    const id = requiredString(args, 'id');
+    const from = requiredString(args, 'from');
+    const to = requiredString(args, 'to');
+    validateVersion(from); validateVersion(to);
+    if (from === to) throw new Error('같은 판으로 옮길 수 없습니다');
+    prompt = `${id} 칸을 ${from} 에서 ${to} 로 이동 — 진행할까요?`;
+    apply = () => { (deps.move ?? move)(id, from, to, ownerId); };
+  } else if (action === 'set-schedule') {
+    const v = requiredString(args, 'version');
+    validateVersion(v);
+    const cutAt = args.cutAt === undefined ? undefined : requiredString(args, 'cutAt');
+    const landBy = args.landBy === undefined ? undefined : requiredString(args, 'landBy');
+    if (!cutAt && !landBy) throw new Error('cutAt 또는 landBy 가 필요합니다');
+    // Validate offsets before asking for approval, not after.
+    for (const iso of [cutAt, landBy].filter((value): value is string => !!value)) {
+      if (!/^\d{4}-\d\d-\d\dT\d\d:\d\d(?::\d\d(?:\.\d{1,3})?)?(?:Z|[+-]\d\d:\d\d)$/.test(iso) || !Number.isFinite(Date.parse(iso))) throw new Error(`잘못된 ISO 시각: ${iso}`);
+    }
+    prompt = `${v} 판 일정 ${cutAt ? `컷 ${formatKst(cutAt)}` : ''}${landBy ? ` 착지 마감 ${formatKst(landBy)}` : ''} 변경 — 진행할까요?`;
+    apply = () => { (deps.setSchedule ?? setSchedule)(v, { ...(cutAt ? { cutAt } : {}), ...(landBy ? { landBy } : {}) }, ownerId); };
+  } else throw new Error('action 은 add-item, move-item, set-schedule 중 하나여야 합니다');
+  debug.log('release.tool', 'change-requested', { action, version });
+  const result = await (deps.confirm ?? requestConfirmation)({ prompt, onTimeout: () => false, failOpen: false,
+    channels });
+  if (!result.answer || !channels.some(channel => channel.name === result.channel)) {
+    debug.log('release.tool', 'change-refused', { action, version });
+    return `${prompt} — 승인되지 않아 변경하지 않았습니다.`;
+  }
+  apply();
+  debug.log('release.tool', 'change-confirmed', { action, version });
+  return `${prompt} — 변경했습니다.`;
+}

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

@@ -1,12 +1,30 @@
 // 발송 목적(kind) → 텔레그램 채널 역할 · 대상. 가벼운 모듈(telegram.ts 를 import 하지 않는다 — outbound-alert 순환 방지).
-// 표에 없는 kind 는 undefined → 부르는 쪽이 옛 reportChannel 로 간다(투자 알림 등 기존 동작 그대로).
+// 표에 없는 kind 는 undefined → 부르는 쪽이 폴백을 판정한다(투자 알림은 옛 reportChannel 유지).
 import type { UserConfig } from '../user-config.js';
+import { resolveChannelBotToken } from '../channel-bot-token.js';
+import { debug } from '../debug/log.js';
 import { channelForRole, resolveTelegramChannels } from './telegram-channels.js';
 
 export const DEFAULT_KIND_ROLES: Readonly<Record<string, string>> = {
   intake: 'system', 'ops-report': 'system', 'ops-alert': 'system', 'ops-health': 'system',
+  regression: 'system', 'agent-mission': 'system',
 };
 
+/** No channel mapping for an operational kind may cross into a different bot. */
+export function isOperationalKind(kind?: string): boolean {
+  return kind?.startsWith('ops-') ?? false;
+}
+
+export function mainHomeTarget(cfg: UserConfig): { botToken: string; chatId: number } | null {
+  const botToken = resolveChannelBotToken('telegram', cfg).token;
+  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 */ }
+}
+
 export function roleForKind(cfg: UserConfig, kind?: string): string | undefined {
   if (!kind) return undefined;
   return cfg.telegram.kindRoles?.[kind] ?? DEFAULT_KIND_ROLES[kind];

package/src/exec-requests/planner.ts

@@ -1,10 +1,11 @@
-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';
 
 export interface InstalledGraph {
@@ -12,7 +13,7 @@ export interface InstalledGraph {
   title: string;
   description: string;
   path: string;
-  /** 플러그인 그래프가 받는 입력 키(`examples/*.json` 표본에서) — COO 가 inputs 를 채울 수 있게. */
+  /** 코어 loop.inputs 또는 플러그인 examples/*.json 표본의 입력 키. */
   inputKeys?: string[];
 }
 export interface ExecPlanItem {
@@ -83,24 +84,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 +126,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":[]}]. 앞 항목의 결과가 있어야 할 수 있는 일(예: 점검·조사 «결과로» 쓰는 한 장 · 보고)은 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 +162,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 +182,35 @@ 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 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,
       ...(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;
 }