elanous 0.2.15 → 0.2.16

package/src/loops/orchestrator/tick.ts

@@ -8,9 +8,11 @@ import { effectiveInstanceRoot } from '../../instance/resolve.js';
 import { getUserConfig } from '../../user-config.js';
 import { debug } from '../../debug/log.js';
 import { listSelfDevRuns, runSummaryLine, selfDevRunsDir } from '../../self-dev/run-store.js';
+import { planAction, runSeatLoopOnce, type SeatItem } from '../../seat-loop/seat-loop.js';
+import { harnessQueueOutcome } from '../../harness/harness-queue.js';
 
 export type Window = '08' | '12' | '18';
-export type Node = 'intake' | 'split' | 'place' | 'delegate' | 'reconcile' | 'report';
+export type Node = 'intake' | 'split' | 'place' | 'delegate' | 'launch' | 'reconcile' | 'report';
 export type Mode = 'off' | 'shadow' | 'live';
 const SEAT_LOOP_IDS: Readonly<Record<string, string>> = { OP: 'op-seat', MK: 'cmo-seat', TC: 'tc-seat', UX: 'ux-seat' };
 export interface Cell { id: string; title: string; seat?: string; host?: string; version?: string; cardId: string; origin: 'candidate' | 'flow1a'; priority?: 'P0' | 'P1' | 'P2'; predecessors?: string[] }
@@ -19,6 +21,9 @@ export interface TickState {
   cards: TaskCard[]; skippedCards: Array<{ id: string; reason: string }>; cells: Cell[]; placed: number; unplaced?: number; delegated: number; wouldDelegate: number; rebalanced?: number; rebalanceBlocked?: Array<{ id: string; reason: string }>;
   reconciled: { reached: number; progressing: number; blocked: number; unknown: number };
   runSummaries?: string[];
+  launched?: Array<{ seat: string; status: string; key?: string; queueId?: string; runId?: string }>;
+  queueOutcomes?: Array<{ queueId: string; key?: string; outcome: string }>;
+  steps: Array<{ node: Node; reason: string; count: number; targetLoopId?: string }>;
   nodes: Partial<Record<Node, 'ok' | 'skipped'>>;
   missing: string[];
 }
@@ -26,11 +31,13 @@ export interface TickState {
 export type SplitAdapter = (card: TaskCard, opts?: { shadow?: boolean }) => Promise<Array<{ id: string; title: string; seat?: string; host?: string }>> | Array<{ id: string; title: string; seat?: string; host?: string }>;
 /** RELPLAN1 `placeCell(input: PlacementCell)` — owner·priority·predecessors are required; the result carries no seat. */
 export type PlacementInput = { id: string; title: string; owner: string; priority: 'P0' | 'P1' | 'P2'; predecessors: string[] };
-export type PlaceAdapter = (cell: PlacementInput) => Promise<{ version?: string } | null> | { version?: string } | null;
+export type PlaceAdapter = (cell: PlacementInput, deps?: { dryRun?: boolean; now?: Date }) => Promise<{ version?: string } | null> | { version?: string } | null;
 export type RebalanceAdapter = (version: string) => Promise<{ decisions: unknown[]; blocked: Array<{ id: string; reason: string }> }> | { decisions: unknown[]; blocked: Array<{ id: string; reason: string }> };
 export interface TickDeps {
   root?: string; now?: Date; mode?: Mode; runId?: string; window?: Window;
   cards?: () => TaskCard[]; split?: SplitAdapter; placeCell?: PlaceAdapter;
+  seatTurn?: (seat: string, root: string) => Promise<{ status: string; queueId?: string; runId?: string; item?: { source: string; id: string } }>;
+  queueOutcome?: (queueId: string, root: string) => 'pending' | 'unknown' | 'retryable' | 'succeeded';
   loadAdapter?: (path: string, name: string) => Promise<unknown>;
   checklist?: (version: string) => Pick<ChecklistItem, 'id' | 'status'>[];
   observe?: (event: string, data: { loopId: string; runId: string; window: Window; node: Node; reason: string; count: number; targetLoopId?: string }) => void;
@@ -54,7 +61,10 @@ export function wishCards(cards: readonly TaskCard[]): TaskCard[] {
   return cards.filter(card => card.status === 'open' && card.goalId.startsWith('wish:') &&
     !card.sections.some(section => section.key === 'orch:split' || section.key.startsWith('orch:split:')));
 }
-export function reconciliation(cells: readonly Cell[], requests: readonly { key: string; status: string }[], checklist: (version: string) => Pick<ChecklistItem, 'id' | 'status'>[]): TickState['reconciled'] {
+export function reconciliation(cells: readonly Cell[], requests: readonly { key: string; status: string }[], checklist: (version: string) => Pick<ChecklistItem, 'id' | 'status'>[],
+  queue: readonly { key: string; outcome: string }[] = []): TickState['reconciled'] {
+  // 체크리스트가 정본이고, 칸이 아직 체크리스트에 없을 때만 «그 칸의 의뢰 키»로 발사된 대기열 결과를 본다.
+  const queueByKey = new Map(queue.map(row => [row.key, row.outcome]));
   const result = { reached: 0, progressing: 0, blocked: 0, unknown: 0 };
   const byVersion = new Map<string, Pick<ChecklistItem, 'id' | 'status'>[]>();
   const keys = new Set(requests.filter(row => row.status === 'queued').map(row => row.key));
@@ -65,7 +75,12 @@ export function reconciliation(cells: readonly Cell[], requests: readonly { key:
     if (status === 'green' || status === 'done') result.reached++;
     else if (status === 'yellow') result.progressing++;
     else if (status === 'red') result.blocked++;
-    else result.unknown++;
+    else {
+      const outcome = queueByKey.get(`orch:${cell.cardId}:${cell.id}`);
+      if (outcome === 'pending' || outcome === 'succeeded') result.progressing++;
+      else if (outcome === 'retryable') result.blocked++;
+      else result.unknown++;
+    }
   }
   return result;
 }
@@ -116,7 +131,7 @@ function stateFile(root: string, runId: string): string {
   if (!/^[a-zA-Z0-9._-]+$/.test(runId) || runId === '.' || runId === '..') throw new Error('Invalid orchestrator runId');
   return join(root, 'loop', 'orchestrator', `${runId}.json`);
 }
-function restorePrevious(root: string, day: string, mode: Mode): Pick<TickState, 'cards' | 'cells'> | null {
+function restorePrevious(root: string, day: string, mode: Mode): Pick<TickState, 'cards' | 'cells' | 'launched'> | null {
   const dir = join(root, 'loop', 'orchestrator');
   if (!existsSync(dir)) return null;
   const states = readdirSync(dir).filter(name => /^[a-zA-Z0-9._-]+\.json$/.test(name))
@@ -126,15 +141,17 @@ function restorePrevious(root: string, day: string, mode: Mode): Pick<TickState,
   states.sort((a, b) => a.name.localeCompare(b.name));
   const cards = new Map<string, TaskCard>();
   const cells = new Map<string, Cell>();
+  const launched = new Map<string, NonNullable<TickState['launched']>[number]>();
   for (const { state } of states) {
     for (const card of state.cards) cards.set(card.id, card);
     for (const cell of state.cells) cells.set(`${cell.cardId}:${cell.id}`, cell);
+    for (const turn of state.launched ?? []) if (turn.queueId) launched.set(turn.queueId, turn);
   }
-  return { cards: [...cards.values()], cells: [...cells.values()] };
+  return { cards: [...cards.values()], cells: [...cells.values()], launched: [...launched.values()] };
 }
 function initial(runId: string, window: Window, mode: Mode, day: string): TickState {
   return { runId, window, mode, day, cards: [], skippedCards: [], cells: [], placed: 0, delegated: 0, wouldDelegate: 0,
-    reconciled: { reached: 0, progressing: 0, blocked: 0, unknown: 0 }, nodes: {}, missing: [] };
+    reconciled: { reached: 0, progressing: 0, blocked: 0, unknown: 0 }, steps: [], nodes: {}, missing: [] };
 }
 function graphRunId(): string | undefined {
   const context = process.env.ELANOUS_GRAPH_CONTEXT;
@@ -163,8 +180,9 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
   const configured = deps.mode ?? getUserConfig().loops?.orchestrator?.mode;
   const mode: Mode = configured === 'off' || configured === 'live' ? configured : 'shadow';
   const state: TickState = existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')) as TickState : initial(runId, window, mode, kstDay(now));
+  state.steps ??= [];
   if (state.window !== window || state.mode !== mode) throw new Error('orchestrator run window/mode changed');
-  const predecessor: Partial<Record<Node, Node>> = { split: 'intake', place: 'split', delegate: 'place', reconcile: 'delegate', report: 'reconcile' };
+  const predecessor: Partial<Record<Node, Node>> = { split: 'intake', place: 'split', delegate: 'place', launch: 'delegate', reconcile: 'launch', report: 'reconcile' };
   const preceding = predecessor[node];
   if (preceding && !state.nodes[preceding]) throw new Error(`orchestrator ${node}: missing ${preceding} result`);
   const loadAdapter = deps.loadAdapter ?? optionalAdapter;
@@ -174,6 +192,7 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
   };
   const observe = (event: string, reason = '', count = 0, targetLoopId?: string): void => {
     const data = { loopId: 'orchestrator', runId, window, node, reason, count, ...(targetLoopId ? { targetLoopId } : {}) };
+    if (event !== 'tick') state.steps.push({ node, reason, count, ...(targetLoopId ? { targetLoopId } : {}) });
     try { (deps.observe ?? ((name, payload) => debug.log('loop.orchestrator', name, payload)))(event, data); }
     catch { /* observation must not change the run */ }
   };
@@ -198,6 +217,7 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
           if (!cell.id?.trim() || !cell.title?.trim()) throw new Error('invalid split cell');
           state.cells.push({ cardId: card.id, id: cell.id, title: cell.title, origin: split ? 'flow1a' : 'candidate', ...(cell.seat ? { seat: cell.seat } : {}), ...(cell.host !== undefined ? { host: cell.host } : {}) });
         }
+        observe('exchange', `split:${card.id}`, cells.length);
         if (split && cells.length && mode === 'live') {
           const store = new CardStore(root);
           try {
@@ -209,15 +229,24 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
       const place = deps.placeCell ?? await adapter<PlaceAdapter>('../../release-loop/placement.js', 'placeCell');
       const available = typeof place === 'function';
       if (!available) { state.missing.push('relplan1-absent'); observe('node-missing', 'relplan1-absent', state.cells.length); }
-      else if (mode === 'shadow') observe('exchange', 'relplan1-shadow-not-invoked', state.cells.length);
-      if (mode === 'live' && available) for (const cell of state.cells) {
-        if (cell.origin !== 'flow1a') continue;
-        // TC review must-fix ②: map to the placer's required shape; a cell without an owner is unplaced, not a crash.
-        if (!cell.seat) { state.unplaced = (state.unplaced ?? 0) + 1; observe('exchange', 'unplaced-no-owner', 1); continue; }
-        const placed = await place({ id: cell.id, title: cell.title, owner: cell.seat, priority: cell.priority ?? 'P2', predecessors: cell.predecessors ?? [] });
-        if (validVersion(placed?.version)) {
-          cell.version = placed.version;
-          state.placed++;
+      if (mode === 'shadow' && deps.placeCell) observe('exchange', 'relplan1-shadow-not-invoked', state.cells.length);
+      // 담당 없는 칸은 배치를 부르든 안 부르든 센다 — 배치 호출 여부와 집계를 묶지 않는다.
+      for (const cell of state.cells) {
+        if (cell.origin === 'flow1a' && (!cell.seat || !SEAT_LOOP_IDS[cell.seat])) { state.unplaced = (state.unplaced ?? 0) + 1; observe('exchange', 'unplaced-no-owner', 1); }
+      }
+      if (available && (mode === 'live' || !deps.placeCell)) for (const cell of state.cells) {
+        if (cell.origin !== 'flow1a' || !cell.seat || !SEAT_LOOP_IDS[cell.seat]) continue;
+        // RELPLAN's dryRun calculates the same release without writing a checklist in shadow.
+        try {
+          const placed = await place({ id: cell.id, title: cell.title, owner: cell.seat, priority: cell.priority ?? 'P2', predecessors: cell.predecessors ?? [] }, { dryRun: mode === 'shadow', now });
+          if (validVersion(placed?.version)) {
+            cell.version = placed.version;
+            state.placed++;
+            observe('exchange', mode === 'shadow' ? `would-place:${cell.id}:${cell.version}` : `placed:${cell.id}:${cell.version}`, 1);
+          } else { state.unplaced = (state.unplaced ?? 0) + 1; observe('exchange', 'unplaced-no-release', 1); }
+        } catch (error) {
+          state.unplaced = (state.unplaced ?? 0) + 1;
+          observe('exchange', `unplaced:${cell.id}:${String(error).slice(0, 160)}`, 1);
         }
       }
     } else if (node === 'delegate') {
@@ -229,9 +258,11 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
         if (!targetLoopId) continue;
         const key = `orch:${cell.cardId}:${cell.id}`;
         if (keys.has(key)) continue;
-        // Shadow shows what it would hand over even before a release is chosen (placement is not invoked in shadow).
-        if (mode === 'shadow') { keys.add(key); state.wouldDelegate++; observe('would-delegate', validVersion(cell.version) ? key : `${key} (unplaced)`, 1, targetLoopId); continue; }
-        if (!validVersion(cell.version)) continue;
+        if (!validVersion(cell.version)) {
+          if (mode === 'shadow') { keys.add(key); state.wouldDelegate++; observe('would-delegate', `${key} (unplaced)`, 1, targetLoopId); }
+          continue;
+        }
+        if (mode === 'shadow') { keys.add(key); state.wouldDelegate++; observe('would-delegate', key, 1, targetLoopId); continue; }
         keys.add(key);
         mkdirSync(dirname(path), { recursive: true });
         // TC review must-fix ①: the seat-requests journal contract needs receiptId, and appends are serialized under the
@@ -249,13 +280,53 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
         state.delegated++;
         observe('exchange', 'queued', 1, targetLoopId);
       }
+    } else if (node === 'launch') {
+      const eligible = state.cells.filter(cell => cell.origin === 'flow1a' && cell.seat && SEAT_LOOP_IDS[cell.seat]
+        && validVersion(cell.version) && (mode === 'shadow' || readRequests(root).some(row => row.key === `orch:${cell.cardId}:${cell.id}` && row.status === 'queued')));
+      const seats = [...new Set(eligible.map(cell => cell.seat!))];
+      state.launched = [];
+      for (const seat of seats) {
+        if (mode === 'shadow') {
+          const cell = eligible.find(row => row.seat === seat)!;
+          const item: SeatItem = { source: 'request', id: `orch:${cell.cardId}:${cell.id}`, title: cell.title, text: cell.title };
+          const action = planAction(item, seat);
+          state.launched.push({ seat, key: item.id, status: action.kind === 'harness' ? 'would-launch' : `would-${action.kind}` });
+          observe('exchange', `would-${action.kind}:${seat}`, 1, SEAT_LOOP_IDS[seat]);
+        } else {
+          const turn = await (deps.seatTurn ?? ((assigned: string, stateRoot: string) => runSeatLoopOnce(assigned, {
+            root: stateRoot, config: { ...getUserConfig().loops?.seat, mode: 'live-safe', seats: [assigned] },
+          })))(seat, root);
+          // 자리 턴이 «이 틱이 넣은 의뢰»를 처리했을 때만 칸에 잇는다 — 대기열의 다른 의뢰는 이 카드의 발사가 아니다.
+          const targets = new Set(eligible.filter(row => row.seat === seat).map(row => `orch:${row.cardId}:${row.id}`));
+          const handled = 'item' in turn && turn.item?.source === 'request' ? turn.item.id : undefined;
+          const key = handled && targets.has(handled) ? handled : undefined;
+          if (handled && !key) observe('exchange', `seat-turn-other-request:${seat}`, 1, SEAT_LOOP_IDS[seat]);
+          state.launched.push({ seat, status: turn.status, ...(key ? { key } : {}),
+            ...('queueId' in turn && turn.queueId ? { queueId: turn.queueId } : {}),
+            ...('runId' in turn && turn.runId ? { runId: turn.runId } : {}) });
+          observe('exchange', `seat-turn:${seat}:${turn.status}`, 1, SEAT_LOOP_IDS[seat]);
+        }
+      }
     } else if (node === 'reconcile') {
-      if (window !== '08' && state.cells.length === 0) {
+      if (window !== '08') {
+        // 새 카드가 있어도 앞 틱의 의뢰·발사를 같이 대조한다 — 지금 틱 것이 같은 키를 이긴다.
         const previous = restorePrevious(root, state.day, mode);
-        if (previous) { state.cards = previous.cards; state.cells = previous.cells; }
+        if (previous) {
+          const merge = <T>(older: readonly T[], newer: readonly T[], key: (row: T) => string) =>
+            [...new Map([...older, ...newer].map(row => [key(row), row])).values()];
+          state.cards = merge(previous.cards, state.cards, card => card.id);
+          state.cells = merge(previous.cells, state.cells, cell => `${cell.cardId}:${cell.id}`);
+          state.launched = merge(previous.launched ?? [], state.launched ?? [], turn => turn.queueId ?? `${turn.seat}:${turn.key ?? ''}`);
+        }
       }
+      state.queueOutcomes = (state.launched ?? []).filter(turn => turn.queueId).map(turn => {
+        const outcome = (deps.queueOutcome ?? ((id: string, stateRoot: string) => harnessQueueOutcome(id, { root: stateRoot })))(turn.queueId!, root);
+        observe('exchange', `queue-outcome:${turn.queueId}:${outcome}`, 1, SEAT_LOOP_IDS[turn.seat]);
+        return { queueId: turn.queueId!, ...(turn.key ? { key: turn.key } : {}), outcome };
+      });
       const requests = readRequests(root);
-      state.reconciled = reconciliation(state.cells, requests, mode === 'shadow' ? version => readChecklist(root, version) : (deps.checklist ?? (version => readChecklist(root, version))));
+      state.reconciled = reconciliation(state.cells, requests, mode === 'shadow' ? version => readChecklist(root, version) : (deps.checklist ?? (version => readChecklist(root, version))),
+        state.queueOutcomes.flatMap(row => row.key ? [{ key: row.key, outcome: row.outcome }] : []));
       const from = new Date(`${state.day}T00:00:00+09:00`).getTime();
       state.runSummaries = listSelfDevRuns(selfDevRunsDir(root))
         .filter(run => run.updatedAt >= from && run.updatedAt < from + 86_400_000)
@@ -295,9 +366,9 @@ if (import.meta.main) {
   const node = process.argv[2];
   const index = process.argv.indexOf('--window');
   const window = index < 0 ? undefined : process.argv[index + 1];
-  if (!['intake', 'split', 'place', 'delegate', 'reconcile', 'report'].includes(node ?? '') ||
+  if (!['intake', 'split', 'place', 'delegate', 'launch', 'reconcile', 'report'].includes(node ?? '') ||
       (window !== undefined && !['08', '12', '18'].includes(window))) {
-    console.error('orchestrator: expected <intake|split|place|delegate|reconcile|report> [--window 08|12|18]');
+    console.error('orchestrator: expected <intake|split|place|delegate|launch|reconcile|report> [--window 08|12|18]');
     process.exitCode = 2;
   } else {
     void (async () => {

package/src/maturity/bot-slash-catalog.ts

@@ -1,6 +1,7 @@
 import type { SlashCommand } from '../chat/index.js';
 import type { Maturity } from './feature-maturity.js';
 import type { BotSurface } from './bot-command-maturity.js';
+import { botUnavailableSlashReply, deriveTuiSlashAvailability, formatBotUnavailableSlashReply } from './tui-slash-availability.js';
 
 export interface BotSlashCatalogEntry {
   name: string;
@@ -56,11 +57,19 @@ export function buildBotSlashCatalog(options: {
     commands.push({ name, description: `${description.slice(0, 100 - suffix.length)}${suffix}`, supported: false });
     seen.add(name);
   }
-  const unsupported = new Set(commands.filter((command) => !command.supported).map((command) => command.name));
+  const handled = new Set(handledCommands.map(({ name }) => name));
+  const unsupported = new Set(commands.filter(({ supported }) => !supported).map(({ name }) => name));
+  const availability = new Map(deriveTuiSlashAvailability(
+    coreCommands.filter(({ name }) => Object.hasOwn(maturity.tuiSlash, name)), maturity,
+  ).map((entry) => [entry.name, entry]));
   return {
     commands,
     unsupportedReply(name) {
-      return unsupported.has(name) ? `/${name}은(는) ${surface === 'telegram' ? '텔레그램' : '디스코드'}에서 아직 지원되지 않습니다. TUI에서 /${name}을(를) 사용하세요.` : null;
+      if (handled.has(name)) return null;
+      const entry = availability.get(name);
+      if (entry?.maturity === 'system') return null;
+      if (unsupported.has(name)) return formatBotUnavailableSlashReply(name, surface);
+      return botUnavailableSlashReply(entry, surface);
     },
   };
 }

package/src/maturity/feature-maturity.ts

@@ -59,7 +59,7 @@ export const FEATURE_MATURITY = {
     pty: 'beta', pr: 'beta', repo: 'beta', role: 'beta', machine: 'beta', 'agent-env': 'beta',
     where: 'stable', shadow: 'beta', llm: 'beta', storage: 'beta', leader: 'beta',
     pod: 'beta', browser: 'beta', questions: 'beta', usage: 'stable', live: 'beta',
-    research: 'beta', release: 'beta', freeze: 'beta', flow: 'beta', seat: 'beta', hq: 'beta', steward: 'beta', coord: 'beta', context: 'beta', 'model-watch': 'beta', doctor: 'stable',
+    research: 'beta', release: 'beta', know: 'beta', freeze: 'beta', flow: 'beta', seat: 'beta', hq: 'beta', steward: 'beta', coord: 'beta', context: 'beta', 'model-watch': 'beta', doctor: 'stable',
     control: 'beta', resources: 'beta', hooks: 'beta', setup: 'stable', start: 'stable',
     grounding: 'beta', graph: 'beta', loop: 'stable', card: 'stable', 'launch-head': 'beta',
     a2a: 'beta', plugin: 'stable', make: 'beta', skills: 'beta', connect: 'beta', import: 'beta',
@@ -75,7 +75,7 @@ export const FEATURE_MATURITY = {
     schedule: 'beta', intake: 'beta', logs: 'stable', ad: 'beta', docs: 'beta',
     decisions: 'beta', directives: 'beta', claims: 'beta', lesson: 'beta', fleet: 'beta', ops: 'stable', outputs: 'beta', publish: 'beta',
     env: 'beta', 'agent-mission': 'beta', dev: 'beta', keys: 'beta', finance: 'beta',
-    config: 'stable', tasks: 'stable', labels: 'beta', msg: 'beta', ask: 'stable',
+    config: 'stable', tasks: 'stable', brief: 'beta', labels: 'beta', msg: 'beta', ask: 'stable',
     onboarding: 'beta', login: 'stable', session: 'beta', chat: 'stable', repl: 'stable',
     agent: 'stable', registry: 'beta', tier: 'stable', local: 'beta', scheduler: 'beta',
     attach: 'beta', wf: 'beta', nexus: 'stable', phone: 'beta', token: 'beta',

package/src/maturity/tui-slash-availability.ts

@@ -8,6 +8,15 @@ export interface TuiSlashAvailability {
   discord: boolean;
 }
 
+export function formatBotUnavailableSlashReply(name: string, surface: 'telegram' | 'discord'): string {
+  return `/${name}은(는) ${surface === 'telegram' ? '텔레그램' : '디스코드'}에서 아직 지원되지 않습니다. TUI에서 /${name}을(를) 사용하세요.`;
+}
+
+export function botUnavailableSlashReply(entry: TuiSlashAvailability | undefined, surface: 'telegram' | 'discord'): string | null {
+  if (!entry || entry[surface] || entry.maturity === 'system') return null;
+  return formatBotUnavailableSlashReply(entry.name, surface);
+}
+
 /** Project canonical TUI commands onto the maturity map and bot-surface grade maps.
  * An absent bot grade means unavailable; a missing TUI grade is a registry error.
  */

package/src/oauth/overload-failover-launch.ts

@@ -0,0 +1,75 @@
+// Launch-time application of the overload gate. Kept out of dev-cli.ts so a
+// unit test can import it without the dev-cli module graph (yaml, typescript).
+
+import type { ChildLlmSelection } from '../agent/run-context.js';
+import { debug } from '../debug/log.js';
+import { resolveGrokCredential } from '../grok/credential.js';
+import {
+  applyOverloadFailoverToChild,
+  readLlmCallOutcomes,
+  type OverloadFailoverLaunchDecision,
+} from './overload-failover.js';
+
+const CODEX_NAMES = new Set(['codex', 'openai-codex']);
+
+export function codexProviderNamed(provider: string | undefined): boolean {
+  if (!provider?.trim()) return false;
+  return CODEX_NAMES.has(provider.trim().toLowerCase());
+}
+
+let launchOverloadOutcomesForTesting: (() => ReturnType<typeof readLlmCallOutcomes>) | undefined;
+
+/** Test seam. `undefined` restores the real log store. */
+export function setLaunchOverloadOutcomesForTesting(
+  reader: (() => ReturnType<typeof readLlmCallOutcomes>) | undefined,
+): void {
+  launchOverloadOutcomesForTesting = reader;
+}
+
+export interface LaunchOverloadFlags {
+  provider?: string;
+  model?: string;
+  /** Pinned childLlm config naming codex. A flag is handled via `provider`. */
+  codexPinned?: boolean;
+  /** Test seam. Default: a grok credential resolves on this host. */
+  grokAvailable?: boolean;
+}
+
+/** Explicit codex stays. Otherwise k `llm.call`/`outcome` overload rows move
+ *  the unpinned child to grok before spawn. */
+export function applyLaunchOverloadFailover(
+  selection: ChildLlmSelection | undefined,
+  flags: LaunchOverloadFlags = {},
+  readOutcomes?: () => ReturnType<typeof readLlmCallOutcomes>,
+  env: NodeJS.ProcessEnv = process.env,
+): ChildLlmSelection | undefined {
+  // Test processes never read this machine's operational logs.db — results must not depend on the host's history.
+  const inTest = env.NODE_ENV === 'test' || Boolean(env.ELANOUS_TEST_HOME);
+  const reader = launchOverloadOutcomesForTesting ?? readOutcomes ?? (inTest ? () => [] : () => readLlmCallOutcomes());
+  let outcomes: ReturnType<typeof readLlmCallOutcomes> = [];
+  try { outcomes = reader(); } catch { outcomes = []; }
+  const explicit = codexProviderNamed(flags.provider) || flags.codexPinned === true;
+  let grokAvailable = flags.grokAvailable;
+  if (grokAvailable === undefined && outcomes.length > 0 && !inTest) {
+    // Only resolve when a switch is possible — a host without grok credentials must stay on codex. Tests inject it.
+    try { grokAvailable = resolveGrokCredential() !== null; } catch { grokAvailable = false; }
+  }
+  const { selection: next, decision } = applyOverloadFailoverToChild(selection, {
+    codexExplicit: explicit,
+    outcomes,
+    ...(grokAvailable !== undefined ? { grokAvailable } : {}),
+    defaultProvider: selection?.provider ?? 'openai-codex',
+  });
+  if (decision.switched && next?.provider === 'grok' && next.model) {
+    debug.log('self-dev', 'overload-failover', {
+      from: selection?.provider ?? 'openai-codex',
+      to: next.provider,
+      model: next.model,
+      why: decision.why,
+    }, { level: 'warn' });
+    return { provider: next.provider, model: next.model, source: 'config' };
+  }
+  return selection;
+}
+
+export type { OverloadFailoverLaunchDecision };

package/src/oauth/overload-failover.ts

@@ -0,0 +1,137 @@
+// Launch-time codex → grok switch driven only by `llm.call` / `outcome`.
+//
+// #24256 read `llm.response` / `llm.stream`. Those rows do not carry
+// provider + status + kind, so a launch that consulted them never saw
+// overload. This module refuses every other category.
+//
+// Boundaries:
+//   • an explicit codex child (flag or pinned config) never switches (#24183)
+//   • k consecutive codex overload/5xx/rate-limit outcomes switch the next
+//     child to grok before that child is spawned
+//   • k later successful outcomes restore codex
+//   • a 400 (kind `other`) never counts
+
+import { logsDbPath, LogStore, type LogStoreRow } from '../mss/logging/log-store.js';
+import {
+  codexOverloadStreakReached,
+  overloadRecovered,
+  OVERLOAD_FAILOVER_STREAK,
+  type LlmCallOutcome,
+  type LlmCallOutcomeKind,
+} from '../session-runtime/retry-policy.js';
+import { lookupLlmTierSpec } from '../model-tier/llm-tier-map.js';
+
+export const LLM_CALL_CATEGORY = 'llm.call';
+export const LLM_CALL_EVENT = 'outcome';
+
+const KINDS = new Set<LlmCallOutcomeKind>(['ok', 'overloaded', '5xx', 'rate-limit', 'other']);
+
+export interface OverloadFailoverLaunchInput {
+  /** True when the launch named codex (flag or pinned childLlm). */
+  readonly codexExplicit: boolean;
+  /** Provider the launch would have used before this gate. */
+  readonly provider: string;
+  readonly model?: string;
+  readonly outcomes: readonly LlmCallOutcome[];
+  readonly streak?: number;
+  /** grok may be selected. Unknown is not a reason to stay on a hot codex. */
+  readonly grokAvailable?: boolean;
+}
+
+export interface OverloadFailoverLaunchDecision {
+  readonly provider: string;
+  readonly model?: string;
+  readonly switched: boolean;
+  readonly why: 'explicit-codex' | 'not-codex' | 'streak' | 'recovered' | 'below-streak' | 'grok-unavailable';
+}
+
+export function parseLlmCallOutcome(row: Pick<LogStoreRow, 'category' | 'event' | 'data'>): LlmCallOutcome | undefined {
+  if (row.category !== LLM_CALL_CATEGORY || row.event !== LLM_CALL_EVENT || !row.data) return undefined;
+  let parsed: unknown;
+  try { parsed = JSON.parse(row.data); } catch { return undefined; }
+  if (!parsed || typeof parsed !== 'object') return undefined;
+  const rec = parsed as { provider?: unknown; status?: unknown; kind?: unknown };
+  if (typeof rec.provider !== 'string' || rec.provider.length === 0) return undefined;
+  if (typeof rec.status !== 'number' || !Number.isFinite(rec.status)) return undefined;
+  if (typeof rec.kind !== 'string' || !KINDS.has(rec.kind as LlmCallOutcomeKind)) return undefined;
+  return { provider: rec.provider, status: rec.status, kind: rec.kind as LlmCallOutcomeKind };
+}
+
+/** Newest-last. Rows that are not `llm.call`/`outcome` are dropped, never guessed. */
+export function outcomesFromCallRows(rows: readonly (Pick<LogStoreRow, 'category' | 'event' | 'data' | 'ts_ms'> & { id?: number })[]): LlmCallOutcome[] {
+  // The store returns newest first; calls in the same millisecond keep that order unless ties break on row id.
+  return [...rows]
+    .filter((row) => row.category === LLM_CALL_CATEGORY && row.event === LLM_CALL_EVENT)
+    .sort((a, b) => a.ts_ms - b.ts_ms || (a.id ?? 0) - (b.id ?? 0))
+    .flatMap((row) => {
+      const parsed = parseLlmCallOutcome(row);
+      return parsed ? [parsed] : [];
+    });
+}
+
+export function readLlmCallOutcomes(opts: {
+  dbPath?: string;
+  sinceMs?: number;
+  limit?: number;
+  open?: (path: string) => Pick<LogStore, 'query' | 'close'>;
+} = {}): LlmCallOutcome[] {
+  const path = opts.dbPath ?? logsDbPath();
+  const open = opts.open ?? ((dbPath: string) => LogStore.openReadOnly(dbPath));
+  let store: Pick<LogStore, 'query' | 'close'> | undefined;
+  try {
+    store = open(path);
+    const rows = store.query({
+      exactCategories: [LLM_CALL_CATEGORY],
+      events: [LLM_CALL_EVENT],
+      ...(opts.sinceMs !== undefined ? { sinceMs: opts.sinceMs } : {}),
+      limit: opts.limit ?? 50,
+    });
+    return outcomesFromCallRows(rows);
+  } catch {
+    return [];
+  } finally {
+    try { store?.close(); } catch { /* a missing store is "no sample", not a launch failure */ }
+  }
+}
+
+export function decideOverloadFailoverLaunch(input: OverloadFailoverLaunchInput): OverloadFailoverLaunchDecision {
+  const streak = input.streak ?? OVERLOAD_FAILOVER_STREAK;
+  const base = { provider: input.provider, ...(input.model !== undefined ? { model: input.model } : {}) };
+  if (input.codexExplicit) return { ...base, switched: false, why: 'explicit-codex' };
+  const onCodex = input.provider === 'openai-codex' || input.provider === 'codex';
+  if (!onCodex) return { ...base, switched: false, why: 'not-codex' };
+  if (overloadRecovered(input.outcomes, streak)) return { ...base, switched: false, why: 'recovered' };
+  if (!codexOverloadStreakReached(input.outcomes, streak)) return { ...base, switched: false, why: 'below-streak' };
+  if (input.grokAvailable === false) return { ...base, switched: false, why: 'grok-unavailable' };
+  return {
+    provider: 'grok',
+    model: lookupLlmTierSpec('grok', 'better').model,
+    switched: true,
+    why: 'streak',
+  };
+}
+
+/** Apply the gate to a not-yet-pinned child selection. Explicit codex is left untouched. */
+export function applyOverloadFailoverToChild<T extends { provider: string; model: string; source: 'flag' | 'config' }>(
+  selection: T | undefined,
+  opts: {
+    codexExplicit: boolean;
+    outcomes: readonly LlmCallOutcome[];
+    grokAvailable?: boolean;
+    defaultProvider?: string;
+  },
+): { selection: T | { provider: string; model: string; source: 'config' } | undefined; decision: OverloadFailoverLaunchDecision } {
+  const provider = selection?.provider ?? opts.defaultProvider ?? 'openai-codex';
+  const decision = decideOverloadFailoverLaunch({
+    codexExplicit: opts.codexExplicit,
+    provider,
+    ...(selection?.model !== undefined ? { model: selection.model } : {}),
+    outcomes: opts.outcomes,
+    grokAvailable: opts.grokAvailable,
+  });
+  if (!decision.switched || !decision.model) return { selection, decision };
+  return {
+    selection: { provider: decision.provider, model: decision.model, source: 'config' },
+    decision,
+  };
+}

package/src/release-loop/checklist.ts

@@ -18,6 +18,8 @@ export interface ChecklistItem {
   deadlineVersion?: string;
   ceoMinutes?: number;
   ceoDate?: string;
+  /** 다른 칸의 처리량을 올리는 칸(자율성·효율성·동시성). 없으면 가속 등급이 아니다. */
+  accelerator?: true;
   evidence?: string;
   disposition?: ChecklistDisposition;
   kind?: ChecklistKind;
@@ -103,7 +105,7 @@ export function validateCeoLoad(input: { ceoMinutes?: number; ceoDate?: string }
   if (input.ceoDate !== undefined && (!/^\d{4}-\d{2}-\d{2}$/.test(input.ceoDate) || !Number.isFinite(Date.parse(`${input.ceoDate}T00:00:00Z`)) || new Date(`${input.ceoDate}T00:00:00Z`).toISOString().slice(0, 10) !== input.ceoDate)) throw new CliUserError('대표 손 날짜는 YYYY-MM-DD 이어야 한다');
 }
 
-export function addItem(v: string, input: { id: string; title: string; owner?: string; kind?: ChecklistKind; priority?: ChecklistItem['priority']; predecessors?: string[]; deadlineVersion?: string; ceoMinutes?: number; ceoDate?: string }, options: { allowDuplicateId?: boolean } = {}): Checklist {
+export function addItem(v: string, input: { id: string; title: string; owner?: string; kind?: ChecklistKind; priority?: ChecklistItem['priority']; predecessors?: string[]; deadlineVersion?: string; ceoMinutes?: number; ceoDate?: string; accelerator?: boolean }, options: { allowDuplicateId?: boolean } = {}): Checklist {
   if (!input.id.trim()) throw new CliUserError('칸 id 가 비었다');
   if (!input.title.trim()) throw new CliUserError('칸 제목이 비었다');
   if (input.kind !== undefined && input.kind !== 'screen') throw new CliUserError(`잘못된 종류: ${input.kind}`, 'screen');
@@ -111,6 +113,7 @@ export function addItem(v: string, input: { id: string; title: string; owner?: s
   if (input.priority !== undefined && !['P0', 'P1', 'P2'].includes(input.priority)) throw new CliUserError(`잘못된 우선순위: ${input.priority}`);
   if (input.predecessors !== undefined && (!Array.isArray(input.predecessors) || input.predecessors.some((p) => typeof p !== 'string' || !p.trim() || p === input.id))) throw new CliUserError('잘못된 선행 칸');
   if (input.deadlineVersion !== undefined) store.validateVersion(input.deadlineVersion);
+  if (input.accelerator !== undefined && input.accelerator !== true) throw new CliUserError('가속 등급은 true 이거나 생략한다');
   validateCeoLoad(input);
   return mutate(v, (data, otherItems) => {
     if (data.items.some((item) => item.id === input.id)) throw new CliUserError(`이미 있는 칸: ${input.id}`, 'set <id> 로 고친다');
@@ -122,14 +125,14 @@ export function addItem(v: string, input: { id: string; title: string; owner?: s
     }
     const by = process.env.ELANOUS_TRACK || 'cli';
     const at = new Date().toISOString();
-    const item: ChecklistItem = { id: input.id, title: input.title, status: 'yellow', ...(input.owner !== undefined ? { owner: input.owner } : {}), ...(input.kind !== undefined ? { kind: input.kind } : {}), ...(input.priority !== undefined ? { priority: input.priority } : {}), ...(input.predecessors !== undefined ? { predecessors: input.predecessors } : {}), ...(input.deadlineVersion !== undefined ? { deadlineVersion: input.deadlineVersion } : {}), ...(input.ceoMinutes !== undefined ? { ceoMinutes: input.ceoMinutes } : {}), ...(input.ceoDate !== undefined ? { ceoDate: input.ceoDate } : {}), updatedAt: at, updatedBy: by };
+    const item: ChecklistItem = { id: input.id, title: input.title, status: 'yellow', ...(input.owner !== undefined ? { owner: input.owner } : {}), ...(input.kind !== undefined ? { kind: input.kind } : {}), ...(input.priority !== undefined ? { priority: input.priority } : {}), ...(input.predecessors !== undefined ? { predecessors: input.predecessors } : {}), ...(input.deadlineVersion !== undefined ? { deadlineVersion: input.deadlineVersion } : {}), ...(input.ceoMinutes !== undefined ? { ceoMinutes: input.ceoMinutes } : {}), ...(input.ceoDate !== undefined ? { ceoDate: input.ceoDate } : {}), ...(input.accelerator === true ? { accelerator: true as const } : {}), updatedAt: at, updatedBy: by };
     data.items.push(item);
     change(data, item.id, 'add', null, item, by, at);
     return true;
   });
 }
 
-export function setItem(v: string, id: string, patch: { status?: ChecklistStatus; evidence?: string; owner?: string; disposition?: ChecklistDisposition; kind?: ChecklistKind; priority?: ChecklistItem['priority']; predecessors?: string[]; deadlineVersion?: string; ceoMinutes?: number; ceoDate?: string }, by: string): Checklist {
+export function setItem(v: string, id: string, patch: { status?: ChecklistStatus; evidence?: string; owner?: string; disposition?: ChecklistDisposition; kind?: ChecklistKind; priority?: ChecklistItem['priority']; predecessors?: string[]; deadlineVersion?: string; ceoMinutes?: number; ceoDate?: string; accelerator?: boolean | null }, by: string): Checklist {
   return mutate(v, (data) => {
     const item = data.items.find((i) => i.id === id);
     if (!item) throw new CliUserError(`없는 칸: ${id}`, 'list 로 칸 목록을 본다');
@@ -139,6 +142,7 @@ export function setItem(v: string, id: string, patch: { status?: ChecklistStatus
     if (patch.priority !== undefined && !['P0', 'P1', 'P2'].includes(patch.priority)) throw new CliUserError(`잘못된 우선순위: ${patch.priority}`);
     if (patch.predecessors !== undefined && (!Array.isArray(patch.predecessors) || patch.predecessors.some((p) => typeof p !== 'string' || !p.trim() || p === id))) throw new CliUserError('잘못된 선행 칸');
     if (patch.deadlineVersion !== undefined) store.validateVersion(patch.deadlineVersion);
+    if (patch.accelerator !== undefined && patch.accelerator !== true && patch.accelerator !== null) throw new CliUserError('가속 등급은 true(부여) 또는 null(해제)이다');
     validateCeoLoad(patch);
     if (patch.owner !== undefined) {
       parseOwner(patch.owner);
@@ -146,13 +150,14 @@ export function setItem(v: string, id: string, patch: { status?: ChecklistStatus
         throw new CliUserError(`지금 주인: ${item.owner} — --force 로만 바꾼다`, 'release checklist claim <id> --by <자리> --force');
       }
     }
-    const fields = (['evidence', 'owner', 'status', 'disposition', 'kind', 'priority', 'predecessors', 'deadlineVersion', 'ceoMinutes', 'ceoDate'] as const).filter((field) => patch[field] !== undefined && JSON.stringify(patch[field]) !== JSON.stringify(item[field]));
+    const fields = (['evidence', 'owner', 'status', 'disposition', 'kind', 'priority', 'predecessors', 'deadlineVersion', 'ceoMinutes', 'ceoDate', 'accelerator'] as const).filter((field) => patch[field] !== undefined && JSON.stringify(patch[field]) !== JSON.stringify(item[field] ?? null));
     if (fields.length === 0) return false;
     const at = new Date().toISOString();
     for (const field of fields) {
       const from = item[field];
       const to = patch[field]!;
-      (item as unknown as Record<string, unknown>)[field] = to;
+      if (field === 'accelerator' && to === null) delete item.accelerator;
+      else (item as unknown as Record<string, unknown>)[field] = to;
       item.updatedAt = at;
       item.updatedBy = by;
       change(data, id, field, from, to, by, at);