elanous 0.2.10 → 0.2.11

package/src/domains/outbound-alert.ts

@@ -210,7 +210,7 @@ export function flushDeferred(path = DEFERRED_PATH): number {
   ].join('\n');
   observeFlush(items.length, lagMin, [...new Set(items.map(i => i.kind))]);
   let delivered = 0;
-  // origin 없는 finance 는 기존 report 묶음. 운영 보류분은 별도로 묶어 운영 봇 경계를 유지한다.
+  // origin 없는 매매 알림만 report 묶음. 그 외는 kind 별로 운영 봇 경계를 유지한다.
   const noOrigin = items.filter(i => !i.origin);
   const tradingBatch = noOrigin.filter(i => !isOperationalKind(i.kind));
   if (tradingBatch.length && deliver(fmt(tradingBatch), 'report')) delivered += tradingBatch.length;
@@ -420,6 +420,11 @@ export function sendTelegramDirect(
       const target = kindRouteTarget(cfg, kind);
       if (target) return sendRaw(target.botToken, String(target.chatId), text);
     } catch { /* unavailable channel routing: fall through */ }
+    // A declared table is authoritative: missing roles cannot escape to an env bot.
+    if (cfg.telegram.channels?.length) {
+      logKindRouteFallback(kind, 'none', false);
+      return false;
+    }
   }
   if (isOperationalKind(kind)) {
     let home: ReturnType<typeof mainHomeTarget> = null;

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

@@ -1,22 +1,27 @@
 // 발송 목적(kind) → 텔레그램 채널 역할 · 대상. 가벼운 모듈(telegram.ts 를 import 하지 않는다 — outbound-alert 순환 방지).
-// 표에 없는 kind 는 undefined → 부르는 쪽이 폴백을 판정한다(투자 알림은 옛 reportChannel 유지).
+// 명시적으로 매매 kind 인 경우만 trading; 나머지는 system. 역할 채널이 없으면 다른 역할로 폴백하지 않는다.
 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';
+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',
+  regression: 'system', 'agent-mission': 'system', brief: 'system', 'op-report': 'system',
 };
 
-/** No channel mapping for an operational kind may cross into a different bot. */
+/** Only named finance delivery kinds can use the trading/report bot. */
+export function isTradingKind(kind?: string): boolean {
+  return kind === 'report' || kind === 'alert' || kind === 'digest';
+}
+
 export function isOperationalKind(kind?: string): boolean {
-  return kind?.startsWith('ops-') ?? false;
+  return !isTradingKind(kind);
 }
 
 export function mainHomeTarget(cfg: UserConfig): { botToken: string; chatId: number } | null {
-  const botToken = resolveChannelBotToken('telegram', cfg).token;
+  const botToken = operationsBotToken(cfg);
   const chatId = cfg.telegram.homeChannel ?? cfg.telegram.allowedUsers[0];
   return botToken && chatId != null && Number.isFinite(chatId) ? { botToken, chatId } : null;
 }
@@ -25,15 +30,48 @@ export function logKindRouteFallback(kind: string | undefined, to: 'report-chann
   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];
+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;
 }
 
-/** The channel for a purpose kind — only with explicit `telegram.channels` and a mapped role. */
+/** 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

@@ -7,6 +7,7 @@ import { defaultGraphsDir } from '../self-implement/graph-templates.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;
@@ -21,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[];
@@ -147,7 +150,7 @@ export function latestFieldFolder(configRoot = getElanousConfigDir()): string |
 
 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)}`;
+  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> {
@@ -183,6 +186,11 @@ export async function planExecRequest(text: string, deps: {
       ? [...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) {
@@ -206,7 +214,7 @@ export async function planExecRequest(text: string, deps: {
       }
     }
     return {
-      seat: row.seat, title: row.title.trim(), graphId: row.graphId, inputs,
+      seat: row.seat, title: row.title.trim(), graphId: row.graphId, inputs, output,
       ...(after.length ? { after } : {}),
       ...(!graph ? { reason: `${row.seat}: 요청에 맞는 설치된 실행 그래프가 없습니다` } : folderReason ? { reason: folderReason } : {}),
     };

package/src/exec-requests/runner.ts

@@ -9,6 +9,12 @@ import { installedGraphs, planExecRequest, type ExecPlanItem, type InstalledGrap
 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;
@@ -137,14 +143,19 @@ 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);
-    else {
+    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 });
     }
@@ -288,7 +299,7 @@ export class ExecRequestRunner {
             reason: plan.reason ?? `${plan.seat}: 요청에 맞는 설치된 실행 그래프가 없습니다` });
           continue;
         }
-        const seat: ExecSeat = { seat: plan.seat, title: plan.title, status: 'done', graphId: 'seat-answer', runId: randomUUID() };
+        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`);
@@ -299,7 +310,10 @@ export class ExecRequestRunner {
         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);
+        if (result) {
+          item.results.push(result);
+          recordResult(result, item.id, this.root, seat.output ?? 'file');
+        }
       }
       item.status = 'running';
       aggregate(item);
@@ -307,7 +321,7 @@ export class ExecRequestRunner {
       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 })) });

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. */

package/src/execution-loop/launch-gate.ts

@@ -0,0 +1,100 @@
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { debug } from '../debug/log.js';
+import { extractVerbatimOriginalAsk } from '../self-implement/goal-author.js';
+import { loadRunLedger } from '../self-implement/run-ledger.js';
+import { queryRunningRuns, type QueriedRunningRunsResult } from '../self-implement/running-runs.js';
+import type { BudgetDecision } from '../self-implement/budget-gate.js';
+
+export type ActiveRunsForGoal = readonly string[] | 'unknown';
+
+/** Match an un-authored CLI request to the verbatim ask recorded in an authored run. */
+export function launchRequestId(text: string): string {
+  return `request-${createHash('sha256').update(text).digest('hex').slice(0, 32)}`;
+}
+
+export interface ActiveRunsForGoalDeps {
+  queryRuns?: () => QueriedRunningRunsResult;
+  loadLedger?: typeof loadRunLedger;
+  readGoalDocument?: (path: string) => string;
+}
+
+/** Only a live process with an exact goal ID or verbatim authored ask is a duplicate. Incomplete observation is not absence. */
+export function activeRunsForGoal(goalId: string, deps: ActiveRunsForGoalDeps = {}): ActiveRunsForGoal {
+  try {
+    const observation = (deps.queryRuns ?? (() => queryRunningRuns({ includeTest: true, caller: 'execution-loop.launch-gate', noCache: true })))();
+    const loadLedger = deps.loadLedger ?? loadRunLedger;
+    const readGoalDocument = deps.readGoalDocument ?? ((path: string) => readFileSync(path, 'utf8'));
+    let unknown = observation.completeness !== 'complete' || observation.pty.unreadable.length > 0;
+    const active = new Set<string>();
+    for (const run of observation.entries) {
+      if (run.status === 'ended-unclosed') continue;
+      if (run.ledgerDirectories.length === 0) { unknown = true; continue; }
+      let identified = false;
+      for (const directory of run.ledgerDirectories) {
+        try {
+          const ledger = loadLedger(run.runId, directory);
+          if (ledger === null) { unknown = true; continue; }
+          const ids = new Set(ledger.flatMap((entry) => entry.goalId ? [entry.goalId] : []));
+          if (ids.size !== 1) { unknown = true; continue; }
+          identified = true;
+          let matches = ids.has(goalId);
+          if (!matches && goalId.startsWith('request-') && run.status === 'running' && run.ptyRefs.length > 0) {
+            const document = ledger.find((entry) => entry.event === 'start')?.data.goalFile;
+            if (typeof document === 'string') {
+              try {
+                const ask = extractVerbatimOriginalAsk(readGoalDocument(document));
+                matches = ask?.range !== undefined && launchRequestId(ask.ask) === goalId;
+              } catch { unknown = true; }
+            }
+          }
+          if (matches) {
+            if (run.status === 'running' && run.ptyRefs.length > 0) active.add(run.runId);
+            else unknown = true;
+          }
+        } catch { unknown = true; }
+      }
+      if (!identified) unknown = true;
+    }
+    // Positive evidence wins even if a different process or store is unreadable.
+    return active.size > 0 ? [...active].sort() : unknown ? 'unknown' : [];
+  } catch {
+    return 'unknown';
+  }
+}
+
+export interface PreLaunchGateInput {
+  goalId: string;
+  budget?: BudgetDecision | 'unknown';
+  forceLaunch?: boolean;
+}
+
+export interface PreLaunchGateDeps extends ActiveRunsForGoalDeps {
+  activeRuns?: (goalId: string) => ActiveRunsForGoal;
+}
+
+export interface PreLaunchGateDecision {
+  action: 'proceed' | 'blocked-duplicate' | 'blocked-budget' | 'wait-reset';
+  sameGoalActiveRuns: ActiveRunsForGoal;
+  budget: BudgetDecision | 'unknown';
+  reason: string;
+}
+
+/** Force bypasses only a duplicate observation, never an exhausted budget. */
+export function preLaunchGate(input: PreLaunchGateInput, deps: PreLaunchGateDeps = {}): PreLaunchGateDecision {
+  const decision = decidePreLaunch(input, deps);
+  debug.log('execution-loop.launch-gate', 'decision', { goalId: input.goalId, action: decision.action, sameGoalActiveRuns: decision.sameGoalActiveRuns, budget: decision.budget === 'unknown' ? 'unknown' : decision.budget.action, forceLaunch: input.forceLaunch === true, reason: decision.reason });
+  return decision;
+}
+
+function decidePreLaunch(input: PreLaunchGateInput, deps: PreLaunchGateDeps): PreLaunchGateDecision {
+  const sameGoalActiveRuns = (deps.activeRuns ?? ((goalId) => activeRunsForGoal(goalId, deps)))(input.goalId);
+  const budget = input.budget ?? 'unknown';
+  if (budget !== 'unknown' && (budget.action === 'stop' || budget.action === 'wait-reset')) {
+    return { action: budget.action === 'stop' ? 'blocked-budget' : 'wait-reset', sameGoalActiveRuns, budget, reason: budget.reasons.join(' · ') || `budget: ${budget.action}` };
+  }
+  if (sameGoalActiveRuns !== 'unknown' && sameGoalActiveRuns.length > 0 && !input.forceLaunch) {
+    return { action: 'blocked-duplicate', sameGoalActiveRuns, budget, reason: `same-goal active runs: ${sameGoalActiveRuns.join(', ')}` };
+  }
+  return { action: 'proceed', sameGoalActiveRuns, budget, reason: sameGoalActiveRuns === 'unknown' ? 'active runs unknown' : input.forceLaunch && sameGoalActiveRuns.length > 0 ? 'duplicate overridden by force-launch' : 'no confirmed duplicate' };
+}

package/src/field/field-reel.ts

@@ -7,6 +7,7 @@ import { debug } from '../debug/log.js';
 import { mergeCapturedPath } from '../shell-env-bootstrap.js';
 import { listFieldMedia } from './field-media.js';
 import { startFieldFeed, type FieldFeedStart } from './field-feed-auto.js';
+import { recordOutput } from '../outputs/ledger.js';
 
 export interface FieldReelResult { ok: boolean; file?: string; seconds: number; error?: string; feed?: FieldFeedStart }
 export type FieldReelRunner = (dir: string, opts: { title: string; sub: string; mode?: 'standard' | 'instant' }) => Promise<FieldReelResult>;
@@ -137,6 +138,7 @@ async function render(dir: string, job: Job): Promise<void> {
   // 현재 렌더의 수신자 스냅샷. 렌더 중 업로드의 수신자는 다음 렌더로 넘긴다.
   const callbacks = job.callbacks;
   const renderOpts = job.opts;
+  let reelTitle = renderOpts.title || event;
   job.callbacks = new Map();
   writeStatus(dir, { state: 'rendering', items, startedAt });
   mkdirSync(join(dir, 'reel'), { recursive: true }); // 실행기 계약 — 산출 폴더는 있다(reel.sh 는 스스로 다시 만든다)
@@ -148,8 +150,9 @@ async function render(dir: string, job: Job): Promise<void> {
     let titleLines: string[] = [];
     try { titleLines = readFileSync(join(dir, 'title.txt'), 'utf8').split(/\r?\n/); }
     catch (err) { if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err; }
+    reelTitle = titleLines[0]?.trim() || renderOpts.title || event;
     result = await (renderOpts.runner ?? defaultFieldReelRunner)(dir, {
-      title: titleLines[0]?.trim() || renderOpts.title || event,
+      title: reelTitle,
       sub: titleLines[1]?.trim() || renderOpts.sub || sub,
       ...(renderOpts.mode ? { mode: renderOpts.mode } : {}),
     });
@@ -163,6 +166,7 @@ async function render(dir: string, job: Job): Promise<void> {
   writeStatus(dir, { state: result.ok ? 'done' : 'failed', items, startedAt, finishedAt,
     seconds: result.seconds, ...(result.ok ? { file: result.file } : { error: result.error ?? 'render failed' }) });
   debug.log('field.reel', result.ok ? 'done' : 'failed', { event, items, seconds: result.seconds });
+  if (result.ok && result.file) recordOutput({ source: 'field-reel', sourceId: event, kind: 'video', title: reelTitle, path: result.file });
   if (result.ok) {
     // EV10b: 엔진이 timeline.json 에 남긴 비전 호출 수·성공·«현장 N» 강등·걸린 ms — codex 잔량과 겹치므로 관측한다(OP 10-01).
     let cardsCache: 'hit' | 'miss' | 'n/a' = 'n/a';

package/src/field-note/index.ts

@@ -0,0 +1,201 @@
+export interface FieldPhoto {
+  file: string;
+  /** EXIF `YYYY:MM:DD HH:mm:ss`, ISO local time, or ISO time with an offset. */
+  exifTakenAt?: string | null;
+}
+
+export interface TranscriptEntry {
+  speaker: string;
+  timestamp: string;
+  text: string;
+}
+
+export interface FieldNoteOptions {
+  /** Minutes east of UTC for offset-free EXIF and transcript timestamps; KST by default. */
+  timeZoneOffsetMinutes?: number;
+  /** Minutes added to every dated photo after interpreting its EXIF timestamp. */
+  photoCorrectionMinutes?: number;
+  /** Maximum gap between consecutive photos in the same scene; 15 minutes by default. */
+  sceneGapMinutes?: number;
+}
+
+export interface TimedPhoto extends FieldPhoto {
+  takenAt: string;
+}
+
+export interface FieldScene {
+  start: string;
+  end: string;
+  photos: TimedPhoto[];
+  transcript: TranscriptEntry[];
+}
+
+export interface FieldTimeline {
+  scenes: FieldScene[];
+  undatedPhotos: FieldPhoto[];
+  /** Chronological entries when there are no dated photos to anchor a scene. */
+  transcriptWithoutPhotos: TranscriptEntry[];
+  timeZoneOffsetMinutes: number;
+}
+
+export interface FieldNoteLlm {
+  /** Only used for a raw transcript string; JSON entries bypass transcription. */
+  transcribe?: (source: string) => Promise<TranscriptEntry[]>;
+  summarize?: (entries: readonly TranscriptEntry[]) => Promise<string>;
+}
+
+const MINUTE = 60_000;
+
+function validOffset(minutes: number): boolean {
+  return Number.isInteger(minutes) && minutes >= -14 * 60 && minutes <= 14 * 60;
+}
+
+function parseTime(value: string, offsetMinutes: number): number | null {
+  const input = value.trim();
+  const local = /^(\d{4})[:-](\d{2})[:-](\d{2})[ T](\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,3}))?$/.exec(input);
+  const zoned = local ? null : /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,3}))?(?:Z|[+-]\d{2}:\d{2})$/.exec(input);
+  const match = local ?? zoned;
+  if (!match) return null;
+  const [, year, month, day, hour, minute, second, fraction] = match;
+  if (+year! < 100) return null;
+  const milliseconds = fraction ? Number(fraction.padEnd(3, '0')) : 0;
+  const utc = Date.UTC(+year!, +month! - 1, +day!, +hour!, +minute!, +second!, milliseconds);
+  const date = new Date(utc);
+  if (date.getUTCFullYear() !== +year! || date.getUTCMonth() + 1 !== +month! ||
+      date.getUTCDate() !== +day! || date.getUTCHours() !== +hour! ||
+      date.getUTCMinutes() !== +minute! || date.getUTCSeconds() !== +second!) return null;
+  if (local) return utc - offsetMinutes * MINUTE;
+  // Offset-bearing ISO timestamps are absolute instants, not local wall-clock readings.
+  const parsed = Date.parse(input);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function iso(ms: number): string {
+  return new Date(ms).toISOString();
+}
+
+/** Pure alignment: neither mutates its inputs nor consults the machine clock/timezone. */
+export function alignFieldNote(
+  photos: readonly FieldPhoto[],
+  transcript: readonly TranscriptEntry[],
+  options: FieldNoteOptions = {},
+): FieldTimeline {
+  const offset = options.timeZoneOffsetMinutes ?? 540;
+  const correction = options.photoCorrectionMinutes ?? 0;
+  const gap = options.sceneGapMinutes ?? 15;
+  if (!validOffset(offset) || !Number.isFinite(correction) || !Number.isFinite(gap) || gap < 0) {
+    throw new RangeError('Invalid field-note timezone, photo correction, or scene gap');
+  }
+  const dated: Array<{ photo: TimedPhoto; time: number; order: number }> = [];
+  const undatedPhotos: FieldPhoto[] = [];
+  photos.forEach((photo, order) => {
+    const parsed = photo.exifTakenAt ? parseTime(photo.exifTakenAt, offset) : null;
+    if (parsed === null) undatedPhotos.push({ ...photo });
+    else dated.push({ photo: { ...photo, takenAt: iso(parsed + correction * MINUTE) }, time: parsed + correction * MINUTE, order });
+  });
+  dated.sort((a, b) => a.time - b.time || a.order - b.order);
+
+  const groups: typeof dated[] = [];
+  for (const item of dated) {
+    const last = groups.at(-1);
+    if (!last || item.time - last[last.length - 1]!.time > gap * MINUTE) groups.push([item]);
+    else last.push(item);
+  }
+
+  const entries = transcript.map((entry, order) => {
+    const time = parseTime(entry.timestamp, offset);
+    if (time === null) throw new RangeError(`Invalid transcript timestamp at index ${order}: ${entry.timestamp}`);
+    return { entry: { ...entry }, time, order };
+  }).sort((a, b) => a.time - b.time || a.order - b.order);
+
+  // An utterance belongs to the scene whose photo span [first, last] is nearest in time (inside the span = distance 0);
+  // a tie goes to the earlier scene. So a 10:55 line next to an 11:00 photo joins the 11:00 scene, not 09:00.
+  const spans = groups.map((group) => ({ start: group[0]!.time, end: group[group.length - 1]!.time }));
+  const sceneEntries: Array<Array<(typeof entries)[number]>> = groups.map(() => []);
+  for (const item of entries) {
+    if (groups.length === 0) break;
+    let best = 0;
+    let bestDistance = Infinity;
+    spans.forEach((span, index) => {
+      const distance = item.time < span.start ? span.start - item.time : item.time > span.end ? item.time - span.end : 0;
+      if (distance < bestDistance) { best = index; bestDistance = distance; }
+    });
+    sceneEntries[best]!.push(item);
+  }
+  const scenes = groups.map((group, index) => {
+    const assigned = sceneEntries[index]!;
+    const times = [group[0]!.time, group[group.length - 1]!.time, ...assigned.map((item) => item.time)];
+    return {
+      start: iso(Math.min(...times)), end: iso(Math.max(...times)),
+      photos: group.map((item) => item.photo), transcript: assigned.map((item) => item.entry),
+    };
+  });
+  return {
+    scenes, undatedPhotos,
+    transcriptWithoutPhotos: groups.length === 0 ? entries.map((item) => item.entry) : [],
+    timeZoneOffsetMinutes: offset,
+  };
+}
+
+function localTime(instant: string, offset: number): string {
+  const shifted = new Date(Date.parse(instant) + offset * MINUTE).toISOString().slice(0, 16).replace('T', ' ');
+  const sign = offset >= 0 ? '+' : '-';
+  const hours = String(Math.floor(Math.abs(offset) / 60)).padStart(2, '0');
+  const minutes = String(Math.abs(offset) % 60).padStart(2, '0');
+  return `${shifted} UTC${sign}${hours}:${minutes}`;
+}
+
+function photoLine(photo: FieldPhoto, label: string): string {
+  const file = encodeURIComponent(photo.file).replace(/%2F/gi, '/').replace(/[()]/g, (char) => char === '(' ? '%28' : '%29');
+  const alt = photo.file.split(/[\\/]/).at(-1)?.replace(/\]/g, '\\]') ?? photo.file;
+  return `- ${label} ![${alt}](<${file}>)`;
+}
+
+/** Synchronous, side-effect-free Markdown rendering; summaries are optional placeholders. */
+export function renderFieldNote(timeline: FieldTimeline, summaries: readonly string[] = []): string {
+  if (summaries.length > timeline.scenes.length + (timeline.transcriptWithoutPhotos.length ? 1 : 0)) {
+    throw new RangeError('More summaries than transcript sections');
+  }
+  const lines = ['# 현장 노트', ''];
+  timeline.scenes.forEach((scene, i) => {
+    lines.push(`## 장면 ${i + 1} · ${localTime(scene.start, timeline.timeZoneOffsetMinutes)} – ${localTime(scene.end, timeline.timeZoneOffsetMinutes)}`);
+    lines.push('', '### 전사 요약', summaries[i]?.trim() || '_(전사 요약 자리)_', '', '### 사진');
+    for (const photo of scene.photos) lines.push(photoLine(photo, localTime(photo.takenAt, timeline.timeZoneOffsetMinutes)));
+    lines.push('');
+  });
+  if (timeline.transcriptWithoutPhotos.length) {
+    lines.push('## 사진 없는 전사', '', '### 전사 요약',
+      summaries[timeline.scenes.length]?.trim() || '_(전사 요약 자리)_', '', '### 시간순 전사');
+    for (const entry of timeline.transcriptWithoutPhotos) {
+      lines.push(`- ${entry.timestamp} · ${entry.speaker}: ${entry.text}`);
+    }
+    lines.push('');
+  }
+  if (timeline.undatedPhotos.length) {
+    lines.push('## 시각 없음', '');
+    for (const photo of timeline.undatedPhotos) lines.push(photoLine(photo, '시각 없음'));
+    lines.push('');
+  }
+  return lines.join('\n').trimEnd() + '\n';
+}
+
+/** LLM calls are supplied by the caller; JSON transcripts need no transcription call. */
+export async function generateFieldNote(
+  photos: readonly FieldPhoto[],
+  transcript: readonly TranscriptEntry[] | string,
+  llm: FieldNoteLlm = {},
+  options: FieldNoteOptions = {},
+): Promise<string> {
+  let entries: readonly TranscriptEntry[];
+  if (typeof transcript === 'string') {
+    if (!llm.transcribe) throw new Error('A transcribe dependency is required for raw transcript input');
+    entries = await llm.transcribe(transcript);
+  } else entries = transcript;
+  const timeline = alignFieldNote(photos, entries, options);
+  const sections = timeline.scenes.map((scene) => scene.transcript);
+  if (timeline.transcriptWithoutPhotos.length) sections.push(timeline.transcriptWithoutPhotos);
+  const summaries = llm.summarize
+    ? await Promise.all(sections.map((segment) => segment.length ? llm.summarize!(segment) : ''))
+    : [];
+  return renderFieldNote(timeline, summaries);
+}