elanous 0.2.24 → 0.2.25

package/src/dashboard/slash-runtime/dashboard-handlers.ts

@@ -387,12 +387,13 @@ import {
 import { resolveLocalEndpoints, runLocalLLMCompat } from '../../local-llm-test.js';
 import { getShellRegistry } from '../../shell-runner/registry.js';
 import { renderHandleStatusChip, type HandleStatus } from '../../status/chip.js';
-import { decideAttach } from '../../shell-runner/attach-routing.js';
 import type { DashboardTermSlashRuntime } from '../term-slash-runtime.js';
 import { resolveTerminalMoveDestination } from '../../terminal-matrix/mobility.js';
 import { loadPersistedSessions } from '../../terminal/session-persistence.js';
 import { dispatchTerminalModalObserve } from '../../skills/tools/terminal-modal.js';
 import { SlashCommandRegistry } from './registry.js';
+import { registerShellSlash } from './shell-slash.js';
+export { registerShellSlash } from './shell-slash.js';
 import { cronSecondDueAt, filterLoopRows, formatLoopsTable, localLoopRows, type LoopsTableRow } from './loops-table.js';
 import { loopCronVerdict } from '../../loops/verdict.js';
 import { checklistBoardSlash } from '../../release-loop/checklist-board.js';
@@ -3715,143 +3716,8 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
     ctx.setChatScrollOffset(-1);
   });
 
-  registry.register(['shell', 'sh'], async (args, ctx) => {
-    // SP-C — /shell list|kill|attach family. Talks to the
-    // ShellRegistry singleton (set up in the boot block in
-    // dashboard/index.ts). Kill uses prefix matching on id so users
-    // don't have to type the full slug; attach routes a vw-mode handle
-    // into the foreground via VW switch.
-    //
-    // getShellRegistry + renderHandleStatusChip + decideAttach hoisted
-    // from dynamic to static imports here. Host-local helpers
-    // (shellSlashRuntime + openShellRollupPopup + virtualWindows ops)
-    // come via ctx.shellSlash.
-    const sub = (args[0] ?? '').toLowerCase();
-    const reg = getShellRegistry();
-    if (!sub || sub === 'help') {
-      for (const line of ctx.shellSlash.slashRuntime.helpLines()) ctx.chatLines.push(line);
-      ctx.setChatScrollOffset(-1);
-      return;
-    }
-    const resolveHandle = (needle: string) => {
-      const want = needle.toLowerCase();
-      if (!want) return null;
-      const exact = reg.get(needle);
-      if (exact) return exact;
-      const all = reg.list();
-      const matches = all.filter(h => h.id.toLowerCase().startsWith(want));
-      if (matches.length === 1) return matches[0]!;
-      return matches.length > 1 ? { ambiguous: matches } as const : null;
-    };
-    if (sub === 'rollup') {
-      // N2 — same popup as the 🐚 pill click, openable from
-      // keyboard-only sessions (SSH / nested tmux).
-      await ctx.shellSlash.openRollupPopup();
-      return;
-    }
-    if (sub === 'list') {
-      // N3 — `/shell list all` bypasses the 30s settled TTL so users
-      // can audit everything. Default stays live-only.
-      const showSettled = (args[1] ?? '').toLowerCase() === 'all';
-      const all = reg.list(showSettled ? { includeSettled: true } : undefined);
-      ctx.chatLines.push('');
-      if (all.length === 0) {
-        ctx.chatLines.push(ctx.shellSlash.slashRuntime.emptyListLine(showSettled));
-        ctx.setChatScrollOffset(-1);
-        return;
-      }
-      ctx.chatLines.push(ctx.shellSlash.slashRuntime.listHeaderLine(all.length, showSettled));
-      for (const h of all) {
-        const chip = renderHandleStatusChip(h.status);
-        const label = reg.getVwLabel(h.id);
-        const idTail = h.id.length > 10 ? `…${h.id.slice(-8)}` : h.id;
-        ctx.chatLines.push(ctx.shellSlash.slashRuntime.listEntryLine({
-          idTail,
-          chip,
-          mode: h.mode,
-          label,
-        }));
-      }
-      ctx.setChatScrollOffset(-1);
-      return;
-    }
-    if (sub === 'kill') {
-      const needle = args[1] ?? '';
-      if (!needle) {
-        ctx.chatLines.push(ctx.shellSlash.slashRuntime.killUsageLine());
-        ctx.setChatScrollOffset(-1);
-        return;
-      }
-      const res = resolveHandle(needle);
-      if (!res) {
-        ctx.chatLines.push(ctx.shellSlash.slashRuntime.noHandleMatchesLine(needle));
-      } else if ('ambiguous' in res) {
-        ctx.chatLines.push(ctx.shellSlash.slashRuntime.ambiguousHeaderLine(needle));
-        for (const h of res.ambiguous) {
-          ctx.chatLines.push(ctx.shellSlash.slashRuntime.ambiguousEntryLine({ id: h.id }));
-        }
-      } else {
-        try {
-          res.kill();
-          ctx.chatLines.push(ctx.shellSlash.slashRuntime.killedLine(res.id));
-        } catch (err) {
-          ctx.chatLines.push(ctx.shellSlash.slashRuntime.killFailedLine(
-            err instanceof Error ? err.message : String(err),
-          ));
-        }
-      }
-      ctx.setChatScrollOffset(-1);
-      return;
-    }
-    if (sub === 'attach') {
-      const needle = args[1] ?? '';
-      if (!needle) {
-        ctx.chatLines.push(ctx.shellSlash.slashRuntime.attachUsageLine());
-        ctx.setChatScrollOffset(-1);
-        return;
-      }
-      const res = resolveHandle(needle);
-      if (!res) {
-        ctx.chatLines.push(ctx.shellSlash.slashRuntime.noHandleMatchesLine(needle));
-        ctx.setChatScrollOffset(-1);
-        return;
-      }
-      if ('ambiguous' in res) {
-        ctx.chatLines.push(ctx.shellSlash.slashRuntime.ambiguousHeaderLine(needle));
-        for (const h of res.ambiguous) {
-          ctx.chatLines.push(ctx.shellSlash.slashRuntime.ambiguousEntryLine({ id: h.id }));
-        }
-        ctx.setChatScrollOffset(-1);
-        return;
-      }
-      // SRF-2 — attach routing by mode, delegated to the pure
-      // decision fn in shell-runner/attach-routing.ts.
-      const outcome = decideAttach(res, {
-        getVwLabel: (id) => reg.getVwLabel(id),
-        resolveVwIdByLabel: (label) => ctx.shellSlash.resolveVwIdByLabel(label),
-      });
-      if (outcome.kind === 'switch-vw') {
-        ctx.shellSlash.virtualWindowsSwitchTo(outcome.windowId);
-        ctx.chatLines.push(ctx.shellSlash.slashRuntime.attachedLine(
-          outcome.windowId,
-          outcome.label,
-          outcome.mode,
-        ));
-      } else if (outcome.kind === 'bg') {
-        ctx.chatLines.push(ctx.shellSlash.slashRuntime.bgAttachWarningLine(outcome.status));
-        ctx.chatLines.push(ctx.shellSlash.slashRuntime.bgAttachHintLine());
-      } else if (outcome.kind === 'no-window') {
-        ctx.chatLines.push(ctx.shellSlash.slashRuntime.noWindowAttachWarningLine(outcome.reason));
-        ctx.chatLines.push(ctx.shellSlash.slashRuntime.noWindowAttachHintLine());
-      } else {
-        ctx.chatLines.push(ctx.shellSlash.slashRuntime.genericAttachWarningLine(outcome.reason));
-      }
-      ctx.setChatScrollOffset(-1);
-      return;
-    }
-    ctx.chatLines.push(ctx.shellSlash.slashRuntime.unknownSubcommandLine(sub));
-    ctx.setChatScrollOffset(-1);
-  });
+
+  registerShellSlash(registry);
 
   // ── B-3.b ─────────────────────────────────────────────────────────
 

package/src/dashboard/slash-runtime/shell-slash.ts

@@ -0,0 +1,145 @@
+import type { DashboardSlashContext, DashboardSlashReturn } from './dashboard-handlers.js';
+import { getShellRegistry } from '../../shell-runner/registry.js';
+import { renderHandleStatusChip } from '../../status/chip.js';
+import { decideAttach } from '../../shell-runner/attach-routing.js';
+import type { SlashCommandRegistry } from './registry.js';
+
+export function registerShellSlash(registry: SlashCommandRegistry<DashboardSlashContext, DashboardSlashReturn>): void {
+  registry.register(['shell', 'sh'], async (args, ctx) => {
+    // SP-C — /shell list|kill|attach family. Talks to the
+    // ShellRegistry singleton (set up in the boot block in
+    // dashboard/index.ts). Kill uses prefix matching on id so users
+    // don't have to type the full slug; attach routes a vw-mode handle
+    // into the foreground via VW switch.
+    //
+    // getShellRegistry + renderHandleStatusChip + decideAttach hoisted
+    // from dynamic to static imports here. Host-local helpers
+    // (shellSlashRuntime + openShellRollupPopup + virtualWindows ops)
+    // come via ctx.shellSlash.
+    const sub = (args[0] ?? '').toLowerCase();
+    const reg = getShellRegistry();
+    if (!sub || sub === 'help') {
+      for (const line of ctx.shellSlash.slashRuntime.helpLines()) ctx.chatLines.push(line);
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    const resolveHandle = (needle: string) => {
+      const want = needle.toLowerCase();
+      if (!want) return null;
+      const exact = reg.get(needle);
+      if (exact) return exact;
+      const all = reg.list();
+      const matches = all.filter(h => h.id.toLowerCase().startsWith(want));
+      if (matches.length === 1) return matches[0]!;
+      return matches.length > 1 ? { ambiguous: matches } as const : null;
+    };
+    if (sub === 'rollup') {
+      // N2 — same popup as the 🐚 pill click, openable from
+      // keyboard-only sessions (SSH / nested tmux).
+      await ctx.shellSlash.openRollupPopup();
+      return;
+    }
+    if (sub === 'list') {
+      // N3 — `/shell list all` bypasses the 30s settled TTL so users
+      // can audit everything. Default stays live-only.
+      const showSettled = (args[1] ?? '').toLowerCase() === 'all';
+      const all = reg.list(showSettled ? { includeSettled: true } : undefined);
+      ctx.chatLines.push('');
+      if (all.length === 0) {
+        ctx.chatLines.push(ctx.shellSlash.slashRuntime.emptyListLine(showSettled));
+        ctx.setChatScrollOffset(-1);
+        return;
+      }
+      ctx.chatLines.push(ctx.shellSlash.slashRuntime.listHeaderLine(all.length, showSettled));
+      for (const h of all) {
+        const chip = renderHandleStatusChip(h.status);
+        const label = reg.getVwLabel(h.id);
+        const idTail = h.id.length > 10 ? `…${h.id.slice(-8)}` : h.id;
+        ctx.chatLines.push(ctx.shellSlash.slashRuntime.listEntryLine({
+          idTail,
+          chip,
+          mode: h.mode,
+          label,
+        }));
+      }
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    if (sub === 'kill') {
+      const needle = args[1] ?? '';
+      if (!needle) {
+        ctx.chatLines.push(ctx.shellSlash.slashRuntime.killUsageLine());
+        ctx.setChatScrollOffset(-1);
+        return;
+      }
+      const res = resolveHandle(needle);
+      if (!res) {
+        ctx.chatLines.push(ctx.shellSlash.slashRuntime.noHandleMatchesLine(needle));
+      } else if ('ambiguous' in res) {
+        ctx.chatLines.push(ctx.shellSlash.slashRuntime.ambiguousHeaderLine(needle));
+        for (const h of res.ambiguous) {
+          ctx.chatLines.push(ctx.shellSlash.slashRuntime.ambiguousEntryLine({ id: h.id }));
+        }
+      } else {
+        try {
+          res.kill();
+          ctx.chatLines.push(ctx.shellSlash.slashRuntime.killedLine(res.id));
+        } catch (err) {
+          ctx.chatLines.push(ctx.shellSlash.slashRuntime.killFailedLine(
+            err instanceof Error ? err.message : String(err),
+          ));
+        }
+      }
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    if (sub === 'attach') {
+      const needle = args[1] ?? '';
+      if (!needle) {
+        ctx.chatLines.push(ctx.shellSlash.slashRuntime.attachUsageLine());
+        ctx.setChatScrollOffset(-1);
+        return;
+      }
+      const res = resolveHandle(needle);
+      if (!res) {
+        ctx.chatLines.push(ctx.shellSlash.slashRuntime.noHandleMatchesLine(needle));
+        ctx.setChatScrollOffset(-1);
+        return;
+      }
+      if ('ambiguous' in res) {
+        ctx.chatLines.push(ctx.shellSlash.slashRuntime.ambiguousHeaderLine(needle));
+        for (const h of res.ambiguous) {
+          ctx.chatLines.push(ctx.shellSlash.slashRuntime.ambiguousEntryLine({ id: h.id }));
+        }
+        ctx.setChatScrollOffset(-1);
+        return;
+      }
+      // SRF-2 — attach routing by mode, delegated to the pure
+      // decision fn in shell-runner/attach-routing.ts.
+      const outcome = decideAttach(res, {
+        getVwLabel: (id) => reg.getVwLabel(id),
+        resolveVwIdByLabel: (label) => ctx.shellSlash.resolveVwIdByLabel(label),
+      });
+      if (outcome.kind === 'switch-vw') {
+        ctx.shellSlash.virtualWindowsSwitchTo(outcome.windowId);
+        ctx.chatLines.push(ctx.shellSlash.slashRuntime.attachedLine(
+          outcome.windowId,
+          outcome.label,
+          outcome.mode,
+        ));
+      } else if (outcome.kind === 'bg') {
+        ctx.chatLines.push(ctx.shellSlash.slashRuntime.bgAttachWarningLine(outcome.status));
+        ctx.chatLines.push(ctx.shellSlash.slashRuntime.bgAttachHintLine());
+      } else if (outcome.kind === 'no-window') {
+        ctx.chatLines.push(ctx.shellSlash.slashRuntime.noWindowAttachWarningLine(outcome.reason));
+        ctx.chatLines.push(ctx.shellSlash.slashRuntime.noWindowAttachHintLine());
+      } else {
+        ctx.chatLines.push(ctx.shellSlash.slashRuntime.genericAttachWarningLine(outcome.reason));
+      }
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    ctx.chatLines.push(ctx.shellSlash.slashRuntime.unknownSubcommandLine(sub));
+    ctx.setChatScrollOffset(-1);
+  });
+}

package/src/debug/log-diet.ts

@@ -23,6 +23,13 @@ export const LOG_DIET_KEYS: Readonly<Record<string, 'repeat' | 'consecutive'>> =
   // 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 {
   category: string;
   event: string;
@@ -44,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;
@@ -66,6 +75,7 @@ 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;
@@ -76,8 +86,9 @@ export class LogDietGuard {
   private lastSummaryReleaseAt = Number.NEGATIVE_INFINITY;
   private pendingStreams = 0;
 
-  constructor(opts: { windowMs?: number; now?: () => number; keys?: Readonly<Record<string, Policy>>; maxStreams?: number; summaryMinIntervalMs?: number; summaryMaxPending?: 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);
@@ -92,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 } : {}),
@@ -121,12 +132,13 @@ 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();
@@ -154,7 +166,7 @@ export class LogDietGuard {
     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 };
   }
 

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

@@ -21,6 +21,7 @@ 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: '조회할 판. 생략하면 개발 판과 다음 판.' },
@@ -121,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;

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;
 }