elanous 0.2.23 → 0.2.25

package/src/debug/log-diet.ts

@@ -2,6 +2,13 @@ import type { DebugEvent } from './log.js';
 
 export const LOG_DIET_WINDOW_MS = 60_000;
 
+/** LOG-DIET-2 — minimum spacing between two `log.diet/suppressed` summary releases.
+ *  One diet window: a folded stream costs at most one summary row per window instead of one per flush. */
+export const LOG_DIET_SUMMARY_MIN_INTERVAL_MS = LOG_DIET_WINDOW_MS;
+
+/** LOG-DIET-2 — pending-stream pressure that releases summaries before the interval elapses. */
+export const LOG_DIET_SUMMARY_MAX_PENDING = 256;
+
 export const LOG_DIET_KEYS: Readonly<Record<string, 'repeat' | 'consecutive'>> = {
   'watchdog/activity': 'consecutive',
   'user-config.llm/provider-resolved': 'repeat',
@@ -9,6 +16,18 @@ export const LOG_DIET_KEYS: Readonly<Record<string, 'repeat' | 'consecutive'>> =
   'input.cursor.claim/chat-main': 'repeat',
   'tox.loop/waiting-capacity': 'repeat',
   'tox.loop/tick': 'repeat',
+  'llm.credential/provider-key-missing': 'repeat',
+  'llm.credential/provider-key-resolved': 'repeat',
+  'pty.manifest/output-bytes-flushed': 'repeat',
+  // `pod-lease/admit-by-usage` is NOT folded: dispatch backpressure and the TA parent-host admission
+  // read it back from logs and count rows (`admissionCounts`) — it is a judgment-path event.
+};
+
+/** LOG-DIET-2 — per-key fold windows (ms). "State echo" keys whose value rarely changes fold on a
+ *  longer window than the default 60s, so a slow-rotation emitter (one row per question per tick)
+ *  stays folded instead of re-admitting every window. Keys not listed here keep the guard default. */
+export const LOG_DIET_KEY_WINDOW_MS: Readonly<Record<string, number>> = {
+  'hitl.card-bridge/skipped': 30 * 60_000,
 };
 
 export interface LogDietSummary {
@@ -32,6 +51,8 @@ interface Stream {
   sessionId?: string;
   value: string;
   lastEmittedAt: number;
+  /** Fold window pinned at stream creation: `keyWindowMs[key] ?? windowMs`. */
+  windowMs: number;
   count: number;
   firstSuppressedAt?: string;
   lastSuppressedAt?: string;
@@ -54,17 +75,25 @@ function stableValue(value: unknown): string {
 
 export class LogDietGuard {
   private readonly windowMs: number;
+  private readonly keyWindowMs: Readonly<Record<string, number>>;
   private readonly now: () => number;
   private readonly keys: Readonly<Record<string, Policy>>;
   private readonly maxStreams: number;
+  private readonly summaryMinIntervalMs: number;
+  private readonly summaryMaxPending: number;
   private readonly disabled: boolean;
   private readonly streams = new Map<string, Stream>();
+  private lastSummaryReleaseAt = Number.NEGATIVE_INFINITY;
+  private pendingStreams = 0;
 
-  constructor(opts: { windowMs?: number; now?: () => number; keys?: Readonly<Record<string, Policy>>; maxStreams?: number } = {}) {
+  constructor(opts: { windowMs?: number; keyWindowMs?: Readonly<Record<string, number>>; now?: () => number; keys?: Readonly<Record<string, Policy>>; maxStreams?: number; summaryMinIntervalMs?: number; summaryMaxPending?: number } = {}) {
     this.windowMs = opts.windowMs ?? LOG_DIET_WINDOW_MS;
+    this.keyWindowMs = opts.keyWindowMs ?? LOG_DIET_KEY_WINDOW_MS;
     this.now = opts.now ?? Date.now;
     this.keys = opts.keys ?? LOG_DIET_KEYS;
     this.maxStreams = Math.max(1, opts.maxStreams ?? 2000);
+    this.summaryMinIntervalMs = Math.max(0, opts.summaryMinIntervalMs ?? LOG_DIET_SUMMARY_MIN_INTERVAL_MS);
+    this.summaryMaxPending = Math.max(1, opts.summaryMaxPending ?? LOG_DIET_SUMMARY_MAX_PENDING);
     this.disabled = process.env.ELANOUS_LOG_DIET === 'off';
   }
 
@@ -74,7 +103,7 @@ export class LogDietGuard {
       category: stream.category,
       event: stream.event,
       count: stream.count,
-      windowMs: this.windowMs,
+      windowMs: stream.windowMs,
       firstSuppressedAt: stream.firstSuppressedAt!,
       lastSuppressedAt: stream.lastSuppressedAt!,
       ...(stream.runId !== undefined ? { runId: stream.runId } : {}),
@@ -84,8 +113,9 @@ export class LogDietGuard {
 
   admit(rec: DietRecord): { pass: boolean; summaries: LogDietSummary[] } {
     const policy = this.keys[`${rec.category}/${rec.event}`];
+    // LOG-DIET-2 — a registered key folds at warn too; unregistered warn/error/critical alarms never fold.
     if (this.disabled || !policy || rec.category === 'log.diet'
-      || rec.level === 'warn' || rec.level === 'error' || rec.level === 'critical') {
+      || rec.level === 'error' || rec.level === 'critical') {
       return { pass: true, summaries: [] };
     }
 
@@ -102,12 +132,14 @@ export class LogDietGuard {
       ? [rec.category, rec.event, value]
       : [rec.category, rec.event, sessionId, runId]);
     const time = this.now();
+    const windowMs = this.keyWindowMs[`${rec.category}/${rec.event}`] ?? this.windowMs;
     const summaries: LogDietSummary[] = [];
     const stream = this.streams.get(key);
     if (stream) {
       this.streams.delete(key); // Evict the least recently observed flow.
       this.streams.set(key, stream);
-      if ((policy === 'repeat' || stream.value === value) && time - stream.lastEmittedAt < this.windowMs) {
+      if ((policy === 'repeat' || stream.value === value) && time - stream.lastEmittedAt < stream.windowMs) {
+        if (stream.count === 0) this.pendingStreams++;
         stream.count++;
         const at = new Date(time).toISOString();
         stream.firstSuppressedAt ??= at;
@@ -115,7 +147,7 @@ export class LogDietGuard {
         return { pass: false, summaries };
       }
       const pending = this.summary(stream);
-      if (pending) summaries.push(pending);
+      if (pending) { summaries.push(pending); this.pendingStreams--; }
       stream.count = 0;
       stream.firstSuppressedAt = undefined;
       stream.lastSuppressedAt = undefined;
@@ -128,18 +160,22 @@ export class LogDietGuard {
       const oldestKey = this.streams.keys().next().value!;
       const oldest = this.streams.get(oldestKey)!;
       const pending = this.summary(oldest);
-      if (pending) summaries.push(pending);
+      if (pending) { summaries.push(pending); this.pendingStreams--; }
       this.streams.delete(oldestKey);
     }
     this.streams.set(key, { category: rec.category, event: rec.event,
       ...(typeof runId === 'string' ? { runId } : {}),
       ...(sessionId !== undefined ? { sessionId } : {}),
-      value, lastEmittedAt: time, count: 0 });
+      value, lastEmittedAt: time, windowMs, count: 0 });
     return { pass: true, summaries };
   }
 
-  /** Emit pending counts without reopening the current sample windows. */
-  flushPending(): LogDietSummary[] {
+  /** Emit pending counts without reopening the current sample windows.
+   *  LOG-DIET-2 — releases are spaced by `summaryMinIntervalMs` unless forced (drain)
+   *  or the pending-stream pressure cap is hit. Deferred counts stay accumulated on
+   *  their streams, so a held-back release never drops a suppressed event. */
+  flushPending(force = false): LogDietSummary[] {
+    if (!force && !this.summaryReleaseDue()) return [];
     const summaries: LogDietSummary[] = [];
     for (const stream of this.streams.values()) {
       const pending = this.summary(stream);
@@ -148,11 +184,18 @@ export class LogDietGuard {
       stream.firstSuppressedAt = undefined;
       stream.lastSuppressedAt = undefined;
     }
+    this.pendingStreams = 0;
+    this.lastSummaryReleaseAt = this.now();
     return summaries;
   }
 
+  private summaryReleaseDue(): boolean {
+    if (this.pendingStreams >= this.summaryMaxPending) return true;
+    return this.now() - this.lastSummaryReleaseAt >= this.summaryMinIntervalMs;
+  }
+
   drain(): LogDietSummary[] {
-    const summaries = this.flushPending();
+    const summaries = this.flushPending(true);
     this.streams.clear();
     return summaries;
   }

package/src/debug/log.ts

@@ -561,6 +561,24 @@ class DebugLog {
     for (const summary of summaries) this.log('log.diet', 'suppressed', summary);
   }
 
+  /** LOG-DIET-2 — summaries are now spaced by the diet window, so a short-lived process could exit
+   *  holding folded counts. On the first suppression we arm one exit drain that force-releases them
+   *  (and flushes the sinks synchronously) so a held-back release never drops a count at shutdown. */
+  private _logDietExitArmed = false;
+  private armLogDietExitDrain(): void {
+    if (this._logDietExitArmed) return;
+    this._logDietExitArmed = true;
+    const drain = (): void => { try { this.drainLogDietPending(); } catch { /* exit path must not throw */ } };
+    process.once('beforeExit', drain);
+    process.once('exit', drain);
+  }
+
+  /** Force-release every pending diet summary (ignores the summary interval) and flush sinks. */
+  drainLogDietPending(): void {
+    if (this._logDietGuard) this.emitLogDietSummaries(this._logDietGuard.flushPending(true));
+    this.flush();
+  }
+
   /** Force any buffered events to disk immediately. */
   flush(): void {
     if (this._logDietGuard) this.emitLogDietSummaries(this._logDietGuard.flushPending());
@@ -615,7 +633,7 @@ class DebugLog {
     if (this._logDietGuard) {
       const decision = this._logDietGuard.admit(rec);
       this.emitLogDietSummaries(decision.summaries);
-      if (!decision.pass) return;
+      if (!decision.pass) { this.armLogDietExitDrain(); return; }
     }
 
     // Ring buffer — always populated when at least one sink is live so

package/src/domains/morning-essential.ts

@@ -7,6 +7,7 @@
 
 import { getUserConfig } from '../user-config.js';
 import { getProviderForConfig, anyProviderAvailable, textOnly, type LLMMessage } from '../llm.js';
+import { debug } from '../debug/log.js';
 import { marketClock } from './finance.js';
 import { renderSemisEssential } from './kg-semis.js';
 import { feedBySource } from './morning-synthesis.js';
@@ -116,11 +117,25 @@ const ESSENTIAL_SYSTEM = `너는 Conatus 투자 아침 브리핑의 편집자다
 - 매매 지시(사라/팔라/비중 조절) 금지. 관찰과 유의점만. 최종 판단은 verify+HITL.
 - 담백하고 신중한 톤. 이모지 최소.`;
 
+/** synthesizeEssentialBrief 모델 자리(A/B 첫 조각) — 미지정이면 지금과 같은 기본 경로. */
+export interface EssentialSynthOpts {
+  /** 지정하면 getProviderForConfig(cfg, model) 로 부른다. */
+  model?: string;
+  /** provider 주입(시험용). 미지정이면 getProviderForConfig. */
+  providerFor?: (cfg: ReturnType<typeof getUserConfig>, model?: string) => ReturnType<typeof getProviderForConfig>;
+  /** 가용성 주입(시험용). 미지정이면 anyProviderAvailable. */
+  available?: () => boolean;
+}
+
 /** 상세 markdown 을 입력으로 LLM 시장서사 종합. provider 없거나 실패 시 ''(에센셜은 결정론만). */
-export async function synthesizeEssentialBrief(detailMarkdown: string): Promise<string> {
-  if (!anyProviderAvailable()) return '';
+export async function synthesizeEssentialBrief(detailMarkdown: string, opts: EssentialSynthOpts = {}): Promise<string> {
+  const { model, providerFor, available } = opts;
+  if (!(available ?? anyProviderAvailable)()) return '';
   try {
-    const provider = getProviderForConfig(getUserConfig());
+    const cfg = getUserConfig();
+    if (model) debug.log('domains.llm', 'cron-model', { domain: 'morning-essential', model: model ?? null });
+    const resolve = providerFor ?? getProviderForConfig;
+    const provider = model ? resolve(cfg, model) : resolve(cfg);
     if (!provider.streamChat) return '';
     // 토큰 절약: 상세를 앞부분 위주로 트림(핵심 섹션이 상단).
     const digest = detailMarkdown.slice(0, 6000);

package/src/domains/release-tool.ts

@@ -9,6 +9,7 @@ import { requestConfirmation, type ConfirmOpts, type ConfirmResult } from '../hi
 import { devVersion, checklistDevVersion, listChecklist, summarizeChecklist, type Checklist, type ChecklistItem } from '../release-loop/checklist.js';
 import { add, move, validateVersion } from '../release-loop/feature-store.js';
 import { formatKst, formatSchedule, getSchedule, listSchedules, setSchedule, type ReleaseSchedule } from '../release-loop/release-schedule.js';
+import { mergedPrsLast24h as countMergedPrsLast24h } from '../release-loop/placement.js';
 import { latestGraphRun, type GraphRunState } from '../graph-runner/runner.js';
 import { formatElanousCard, type ElanousCard } from './elanous-card.js';
 
@@ -20,10 +21,12 @@ export const RELEASE_STATUS_SPEC: LLMToolSpec = {
     + 'topic=cell: id 칸 하나의 상태·근거와 살핀 판.\n'
     + 'topic=schedule: 발행 이후 판의 컷·착지·발행·동결 일정.\n'
     + 'topic=ops: 도는 런·발행·늦은 스케줄·자리·열린 결정의 출처 있는 개관.\n'
+    + 'topic 과 action 을 동시에 쓰지 않는다 — 둘 중 하나만: topic 은 읽을 대상, action 은 짧은 요약.\n'
     + '발행·버전·피처·체크리스트·칸·컷·일정·운영 상태 질문은 Grep·ListDir·파일 검색보다 이 도구를 먼저 부른다 — 그 답은 파일이 아니라 원장에 있다.',
   parameters: { type: 'object', properties: {
     version: { type: 'string', description: '조회할 판. 생략하면 개발 판과 다음 판.' },
     topic: { type: 'string', enum: ['status', 'features', 'cell', 'schedule', 'ops'], description: '읽을 대상(기본 status).' },
+    action: { type: 'string', enum: ['schedule', 'blocked', 'landed'], description: '짧은 읽기 요약: 다음 컷 일정·막힌 칸·최근 24시간 병합 PR.' },
     id: { type: 'string', description: 'topic=cell 때 찾을 칸 id(필수).' },
   }, required: [] },
 };
@@ -57,6 +60,7 @@ export interface ReleaseToolDeps {
   add?: typeof add;
   move?: typeof move;
   setSchedule?: typeof setSchedule;
+  mergedPrsLast24h?: (now?: Date) => number;
 }
 
 function nextVersion(version: string): string {
@@ -118,6 +122,9 @@ function cellView(item: ChecklistItem) {
 export function dispatchReleaseStatus(args: Record<string, unknown>, deps: ReleaseToolDeps = {}): { text: string; structured: Record<string, unknown> } {
   const topic = args.topic === undefined ? 'status' : args.topic;
   if (typeof topic !== 'string' || !['status', 'features', 'cell', 'schedule', 'ops'].includes(topic)) throw new Error('topic 은 status, features, cell, schedule, ops 중 하나');
+  if (args.topic !== undefined && args.action !== undefined) {
+    throw new Error(`topic 과 action 을 동시에 보낼 수 없습니다 — 둘 중 하나만: topic=${topic} 는 읽을 대상, action 은 짧은 요약(schedule·blocked·landed)`);
+  }
   const requested = args.version;
   if (requested !== undefined && (typeof requested !== 'string' || !requested.trim())) throw new Error('판 이름이 필요합니다');
   const checklist = deps.checklist ?? listChecklist;
@@ -129,6 +136,42 @@ export function dispatchReleaseStatus(args: Record<string, unknown>, deps: Relea
     return { text: facts.length ? facts.map(fact => JSON.stringify(fact)).join('\n') : '운영 개관: 관측된 사실 없음', structured: { facts } };
   }
   const dev = checklistDevVersion(deps.devVersion?.() ?? devVersion());
+  if (args.action !== undefined) {
+    const action = args.action;
+    if (typeof action !== 'string' || !['schedule', 'blocked', 'landed'].includes(action)) {
+      throw new Error('action 은 schedule, blocked, landed 중 하나여야 합니다');
+    }
+    if (action === 'schedule') {
+      const released = checklist(dev).released;
+      const schedules = (deps.schedules ?? listSchedules)()
+        .filter(row => requested ? row.version === requested : !released || versionOrder(row.version, released) > 0)
+        .sort((a, b) => versionOrder(a.version, b.version));
+      const text = schedules.length ? `다음 컷 시각:\n${schedules.map(formatSchedule).join('\n')}` : '다음 컷 시각: 일정 없음';
+      debug.log('release.tool', 'status', { action, version: requested ?? dev });
+      return { text, structured: { schedules: schedules.map(row => ({ version: row.version, cutAt: row.cutAt, landBy: row.landBy,
+        publishAt: row.publishAt ?? null, freezeFrom: row.freezeFrom ?? null, freezeUntil: row.freezeUntil ?? null })) } };
+    }
+    if (action === 'blocked') {
+      const versions = requested ? [requested as string] : [dev, nextVersion(dev)];
+      const blocked = versions.flatMap(version => {
+        validateVersion(version);
+        return checklist(version).items
+          .filter(item => item.status === 'red' || (item.status === 'yellow' && item.disposition === 'block'))
+          .map(item => ({ version, id: item.id, title: firstLine(item.title), status: item.status, disposition: item.disposition ?? null, owner: item.owner ?? null }));
+      });
+      const text = blocked.length ? `막힌 칸 ${blocked.length}개:\n${blocked.map(item => `${item.version} · ${item.id} ${item.title} · ${item.status === 'red' ? '빨강' : '보류'}${item.owner ? ` · 담당 ${item.owner}` : ''}`).join('\n')}` : '막힌 칸 없음';
+      debug.log('release.tool', 'status', { action, version: requested ?? versions.join(',') });
+      return { text, structured: { blocked } };
+    }
+    const now = deps.now ?? new Date();
+    const merged = (deps.mergedPrsLast24h ?? countMergedPrsLast24h)(now);
+    debug.log('release.tool', 'status', { action, since: new Date(now.getTime() - 86_400_000).toISOString(), until: now.toISOString(), merged });
+    return { text: `어제 착지: 최근 24시간 병합 PR ${merged}건`, structured: {
+      mergedPrsLast24h: merged,
+      since: new Date(now.getTime() - 86_400_000).toISOString(),
+      until: now.toISOString(),
+    } };
+  }
   if (topic === 'features' || topic === 'cell' || topic === 'schedule') {
     let result: { text: string; structured: Record<string, unknown> };
     if (topic === 'features') {

package/src/error-report/report.ts

@@ -31,7 +31,7 @@ export interface ErrorReport {
   at: string; consent: true;
 }
 
-export interface ErrorReportSettings { enabled: boolean; identity: boolean; email?: string; telegramUser?: string }
+export interface ErrorReportSettings { enabled: boolean; identity: boolean; consented?: boolean; email?: string; telegramUser?: string }
 
 export interface ErrorReportDeps {
   configDir?: () => string;
@@ -100,10 +100,18 @@ export function buildErrorReport(input: ErrorReportInput, ctx: { installId: stri
   return report;
 }
 
+/** First-run notice: says what is actually sent — identity fields go along only when errorReports.identity is on. */
+export function errorReportNoticeLine(config: { identity?: boolean; email?: string; telegramUser?: string } | undefined): string {
+  const fields = [config?.email ? '이메일' : '', config?.telegramUser ? '텔레그램 사용자' : ''].filter(Boolean).join('·');
+  // Mirrors buildErrorReport: a field goes along only when identity is on AND the field is set.
+  const who = config?.identity === true && fields ? `진단과 함께 설정된 신원(${fields})을` : '익명 진단을';
+  return `오류 보고 안내: 오류 발생 시 ${who} 운영팀에 전송합니다. 끄려면 \`elanous config set errorReports.enabled false\`.`;
+}
+
 function defaultSettings(): ErrorReportSettings {
   try {
     const er = getUserConfig().errorReports;
-    return { enabled: er?.enabled !== false, identity: er?.identity === true, ...(er?.email ? { email: er.email } : {}), ...(er?.telegramUser ? { telegramUser: er.telegramUser } : {}) };
+    return { enabled: er?.enabled !== false, consented: er?.noticeShown === true, identity: er?.identity === true, ...(er?.email ? { email: er.email } : {}), ...(er?.telegramUser ? { telegramUser: er.telegramUser } : {}) };
   } catch { return { enabled: false, identity: false }; }
 }
 
@@ -137,10 +145,17 @@ export async function reportError(input: ErrorReportInput, deps: ErrorReportDeps
     if (!settings.enabled) return { sent: false, reason: 'disabled' };
     const now = (deps.now ?? Date.now)();
     const key = `${input.code}\u0000${input.message.slice(0, 200)}`;
+    const configDir = (deps.configDir ?? getElanousConfigDir)();
+    if (settings.consented !== true) {
+      const report = buildErrorReport(input, {
+        installId: installId(configDir), settings, nexus: { alive: false }, at: new Date(now).toISOString(),
+      });
+      keepPending(report, configDir, deps);
+      return { sent: false, reason: 'awaiting-notice' };
+    }
     const previous = lastSent.get(key);
     if (previous !== undefined && now - previous < SAME_ERROR_GAP_MS) return { sent: false, reason: 'recently-sent' };
     lastSent.set(key, now);
-    const configDir = (deps.configDir ?? getElanousConfigDir)();
     const report = buildErrorReport(input, {
       installId: installId(configDir), settings, nexus: await (deps.nexusMeta ?? defaultNexusMeta)(), at: new Date(now).toISOString(),
     });
@@ -186,7 +201,9 @@ function keepPending(report: ErrorReport, configDir: string, deps: ErrorReportDe
 export async function retryPendingErrorReport(deps: ErrorReportDeps = {}): Promise<ReportOutcome> {
   try {
     if (!(deps.enabledByEnvironment ?? defaultEnabledByEnvironment)()) return { sent: false, reason: 'environment' };
-    if (!(deps.settings ?? defaultSettings)().enabled) return { sent: false, reason: 'disabled' };
+    const settings = (deps.settings ?? defaultSettings)();
+    if (!settings.enabled) return { sent: false, reason: 'disabled' };
+    if (settings.consented !== true) return { sent: false, reason: 'awaiting-notice' };
     const configDir = (deps.configDir ?? getElanousConfigDir)();
     const file = pendingFile(configDir);
     if (!existsSync(file)) return { sent: false, reason: 'none' };

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

@@ -4,7 +4,8 @@ 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';
+import { CODEX_PROVIDER, GROK_PROVIDER, decideLaunchBudget, type BudgetAction, type BudgetDecision, type BudgetInputs } from '../self-implement/budget-gate.js';
+import { DEFAULT_FALLBACK_CHAIN } from '../oauth/fallback-chain.js';
 
 export type ActiveRunsForGoal = readonly string[] | 'unknown';
 
@@ -87,9 +88,164 @@ export function activeRunsForGoal(goalId: string, deps: ActiveRunsForGoalDeps =
   }
 }
 
+const LAUNCH_BUDGET_PROVIDER: Readonly<Record<string, string>> = { 'codex-rotate': CODEX_PROVIDER, grok: GROK_PROVIDER };
+
+/**
+ * L6 발사 관문의 예산 입력 보정 — 발사 우주의 config 에 체인이 없으면(작업 트리 = 시험 우주) 막지 않고
+ * 코드 기본 체인으로 판단한다. `--child-llm-provider` 를 명시했으면 그것이 체인이다(예산 판정 밖 provider 는 통과).
+ */
+export function harnessLaunchBudgetDecision(
+  inputs: BudgetInputs,
+  opts: { readonly childLlmProvider?: string; readonly childLlmModel?: string } = {},
+): { readonly decision: BudgetDecision; readonly warning?: string; readonly unmeasuredProvider?: string } {
+  const explicit = opts.childLlmProvider?.trim();
+  const judged = (selected: BudgetInputs) => {
+    const { decision, unmeasuredProvider } = decideLaunchBudget(selected);
+    return { decision, ...(unmeasuredProvider ? { unmeasuredProvider, warning: `budget: ${unmeasuredProvider} usage unmeasured — launching` } : {}) };
+  };
+  if (explicit) {
+    if (explicit !== CODEX_PROVIDER && explicit !== GROK_PROVIDER) {
+      return {
+        decision: { action: 'proceed', provider: explicit, ...(opts.childLlmModel ? { model: opts.childLlmModel } : {}), reasons: [`${explicit}: 명시 provider — 예산 판정 밖`] },
+        warning: `budget: ${explicit} is outside the budget gate — launched as requested`,
+      };
+    }
+    const chain = [{ provider: explicit, ...(opts.childLlmModel ? { model: opts.childLlmModel } : {}) }];
+    return judged({ ...inputs, preference: { ...inputs.preference, chain } });
+  }
+  if (inputs.preference.chain.length > 0) return judged(inputs);
+  const chain = DEFAULT_FALLBACK_CHAIN.map((step) => ({ provider: LAUNCH_BUDGET_PROVIDER[step] ?? step }));
+  const result = judged({ ...inputs, preference: { ...inputs.preference, chain } });
+  return {
+    ...result,
+    warning: `budget: no chain in this universe's config — judged with the code default ${DEFAULT_FALLBACK_CHAIN.join(',')}${result.warning ? ` · ${result.warning}` : ''}`,
+  };
+}
+
+/** Parent → Pod budget snapshot env. Numbers and names only — never a credential, never free-text reasons. */
+export const BUDGET_SNAPSHOT_ENV = 'ELANOUS_BUDGET_SNAPSHOT';
+export const BUDGET_SNAPSHOT_MAX_AGE_SEC = 15 * 60;
+// Host and Pod clocks may differ slightly even when the Job carries a freshly measured verdict.
+const BUDGET_SNAPSHOT_CLOCK_SKEW_SEC = 30;
+
+/** The verdict the host's launch gate reached (chain ⊕ the user's caps) — the Pod follows it instead of judging again. */
+export interface HostBudgetVerdict {
+  action: BudgetAction;
+  provider?: string;
+  model?: string;
+}
+
+export interface BudgetSnapshot {
+  /** The provider the host verdict picked, or the one asked for when nothing was picked. */
+  provider: string;
+  /** Percent of that provider's window still unspent (0–100) — observation only; absent when the host could not measure it. */
+  remaining?: number;
+  window: string;
+  /** Epoch milliseconds on the measuring host. */
+  measuredAt: number;
+  host: string;
+  /** The explicit child provider the host judged for (`--child-llm-provider`). Absent = the host's configured chain. */
+  requested?: string;
+  /** The host launch-gate verdict. Absent = the host reached none, and the Pod treats the budget as unmeasured. */
+  decision?: HostBudgetVerdict;
+}
+
+export type BudgetSource = 'snapshot' | 'local' | 'unmeasured';
+
+export interface ResolvedLaunchBudget {
+  budget: BudgetDecision | 'unknown';
+  budgetSource: BudgetSource;
+  snapshotAgeSec?: number;
+}
+
+const BUDGET_ACTIONS: readonly BudgetAction[] = ['proceed', 'next-provider', 'wait-reset', 'stop'];
+
+function canonicalBudgetProvider(name: string): string {
+  const id = name.trim();
+  return id === 'codex' || id === 'codex-rotate' ? 'openai-codex' : id;
+}
+
+function pickVerdict(value: unknown): HostBudgetVerdict | undefined {
+  if (!value || typeof value !== 'object') return undefined;
+  const { action, provider, model } = value as Record<string, unknown>;
+  if (typeof action !== 'string' || !(BUDGET_ACTIONS as readonly string[]).includes(action)) return undefined;
+  if (provider !== undefined && (typeof provider !== 'string' || !provider.trim())) return undefined;
+  if (model !== undefined && typeof model !== 'string') return undefined;
+  return { action: action as BudgetAction, ...(provider ? { provider: canonicalBudgetProvider(provider) } : {}), ...(model ? { model } : {}) };
+}
+
+export function encodeBudgetSnapshot(snapshot: BudgetSnapshot): string {
+  const { provider, remaining, window, measuredAt, host, requested, decision } = snapshot;
+  const verdict = pickVerdict(decision);
+  return JSON.stringify({
+    provider: canonicalBudgetProvider(provider),
+    ...(typeof remaining === 'number' && Number.isFinite(remaining) ? { remaining } : {}),
+    window, measuredAt, host,
+    ...(requested?.trim() ? { requested: canonicalBudgetProvider(requested) } : {}),
+    ...(verdict ? { decision: verdict } : {}),
+  });
+}
+
+function parseBudgetSnapshot(raw: string | undefined): BudgetSnapshot | undefined {
+  if (!raw?.trim()) return undefined;
+  try {
+    const value = JSON.parse(raw) as Record<string, unknown> | null;
+    if (!value || typeof value !== 'object') return undefined;
+    const { provider, remaining, window, measuredAt, host, requested, decision } = value;
+    if (typeof provider !== 'string' || !provider.trim() || typeof window !== 'string' || typeof host !== 'string') return undefined;
+    if (remaining !== undefined && (typeof remaining !== 'number' || !Number.isFinite(remaining) || remaining < 0 || remaining > 100)) return undefined;
+    if (typeof measuredAt !== 'number' || !Number.isFinite(measuredAt)) return undefined;
+    if (requested !== undefined && (typeof requested !== 'string' || !requested.trim())) return undefined;
+    const verdict = decision === undefined ? undefined : pickVerdict(decision);
+    if (decision !== undefined && !verdict) return undefined;
+    return {
+      provider: canonicalBudgetProvider(provider), ...(remaining !== undefined ? { remaining } : {}), window, measuredAt, host,
+      ...(requested ? { requested: canonicalBudgetProvider(requested) } : {}), ...(verdict ? { decision: verdict } : {}),
+    };
+  } catch { return undefined; }
+}
+
+/** The host's verdict as the Pod's decision — never re-judged with one provider or code-constant caps. */
+function decisionFromSnapshot(snapshot: BudgetSnapshot, verdict: HostBudgetVerdict, ageSec: number): BudgetDecision {
+  const target = verdict.provider ? ` → ${verdict.provider}` : '';
+  const used = snapshot.remaining === undefined ? '' : ` · ${snapshot.provider} ${Math.round((100 - snapshot.remaining) * 100) / 100}% used (${snapshot.window})`;
+  return {
+    action: verdict.action,
+    ...(verdict.provider ? { provider: verdict.provider } : {}),
+    ...(verdict.model ? { model: verdict.model } : {}),
+    reasons: [`host ${snapshot.host} verdict ${verdict.action}${target}${used} · ${ageSec}s ago`],
+  };
+}
+
+export interface ResolveLaunchBudgetDeps {
+  env?: Readonly<Record<string, string | undefined>> | undefined;
+  now?: () => number;
+  /** The provider this launch will use, when named explicitly. */
+  provider?: string | undefined;
+  /** Host-side measurement. Never called inside a Pod. */
+  measureLocal: () => Promise<BudgetDecision | 'unknown'>;
+}
+
+/** A Pod has no subscription credential or usage cache, so it follows the parent's verdict ⊕ its age and never measures. */
+export async function resolveLaunchBudget(deps: ResolveLaunchBudgetDeps): Promise<ResolvedLaunchBudget> {
+  const env = deps.env ?? process.env;
+  if (env.ELANOUS_SUBSTRATE !== 'pod') return { budget: await deps.measureLocal(), budgetSource: 'local' };
+  const snapshot = parseBudgetSnapshot(env[BUDGET_SNAPSHOT_ENV]);
+  if (!snapshot) return { budget: 'unknown', budgetSource: 'unmeasured' };
+  const ageSec = Math.round(((deps.now ?? Date.now)() - snapshot.measuredAt) / 1000);
+  const requested = deps.provider?.trim() ? canonicalBudgetProvider(deps.provider) : undefined;
+  // The verdict holds only for the question the host answered: the same explicit provider, or both on the configured chain.
+  if (!snapshot.decision || ageSec < -BUDGET_SNAPSHOT_CLOCK_SKEW_SEC || ageSec > BUDGET_SNAPSHOT_MAX_AGE_SEC || requested !== snapshot.requested) {
+    return { budget: 'unknown', budgetSource: 'unmeasured', snapshotAgeSec: ageSec };
+  }
+  return { budget: decisionFromSnapshot(snapshot, snapshot.decision, Math.max(0, ageSec)), budgetSource: 'snapshot', snapshotAgeSec: ageSec };
+}
+
 export interface PreLaunchGateInput {
   goalId: string;
   budget?: BudgetDecision | 'unknown';
+  budgetSource?: BudgetSource;
+  snapshotAgeSec?: number;
   forceLaunch?: boolean;
 }
 
@@ -107,7 +263,7 @@ export interface PreLaunchGateDecision {
 /** 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 });
+  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, ...(input.budgetSource ? { budgetSource: input.budgetSource } : {}), ...(input.snapshotAgeSec !== undefined ? { snapshotAgeSec: input.snapshotAgeSec } : {}) });
   return decision;
 }