elanous 0.2.15 → 0.2.17

package/src/knowledge/know-find.ts

@@ -0,0 +1,105 @@
+import { createRequire } from 'node:module';
+import { LessonLedger, type LessonRow } from '../lessons/lesson-ledger.js';
+import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
+import { devVersion, listChecklist, type Checklist } from '../release-loop/checklist.js';
+import { debug } from '../debug/log.js';
+
+/** Directive row fields this search reads — kept local because `src/directives/directive-index` is excluded from the public export. */
+export interface DirectiveRow { ts: string; text: string; source_file: string; line_no: number }
+
+/** Loads the private directive index at run time only, so public builds bundle cleanly and report the directive source as unreadable. */
+function openDirectiveIndex(): { search(q: string): DirectiveRow[]; close(): void } {
+  const spec = ['..', 'directives', 'directive-index.js'].join('/');
+  const mod = createRequire(import.meta.url)(spec) as { DirectiveIndex: new () => ReturnType<typeof openDirectiveIndex> };
+  return new mod.DirectiveIndex();
+}
+
+export type KnowSource = 'directive' | 'decision' | 'checklist' | 'lesson';
+export interface KnowHit {
+  source: KnowSource;
+  id: string;
+  title: string;
+  status: string;
+  at: string;
+  current: boolean;
+  ref: string;
+}
+export interface KnowResult {
+  rows: KnowHit[];
+  unavailable: Array<{ source: KnowSource; reason: string }>;
+}
+export interface KnowFindDeps {
+  directives: (query: string) => DirectiveRow[];
+  decisions: () => DecisionEntry[];
+  checklist: (version: string) => Checklist;
+  lessons: (query: string) => LessonRow[];
+  versions: () => string[];
+  now: () => Date;
+}
+
+function versions(): string[] {
+  const current = devVersion().replace(/-dev\.\d+$/, '');
+  const parts = current.split('.').map(Number);
+  return [current, `${parts[0]}.${parts[1]}.${parts[2]! + 1}`];
+}
+
+const defaults: KnowFindDeps = {
+  directives: (query) => {
+    const index = openDirectiveIndex();
+    try { return index.search(query); } finally { index.close(); }
+  },
+  decisions: () => new DecisionLedger().list({ status: 'all' }),
+  checklist: (version) => listChecklist(version),
+  lessons: (query) => new LessonLedger().find(query),
+  versions,
+  now: () => new Date(),
+};
+
+function matches(text: string, words: string[]): boolean {
+  const normalized = text.toLocaleLowerCase();
+  return words.every((word) => normalized.includes(word));
+}
+
+export function knowFind(query: string, deps: Partial<KnowFindDeps> = {}): KnowResult {
+  const read = { ...defaults, ...deps };
+  const words = query.trim().toLocaleLowerCase().split(/\s+/).filter(Boolean);
+  if (!words.length) throw new Error('know: 질문이 필요합니다');
+  const rows: KnowHit[] = [];
+  const unavailable: KnowResult['unavailable'] = [];
+  const attempt = (source: KnowSource, work: () => void): void => {
+    try { work(); }
+    catch (error) { unavailable.push({ source, reason: error instanceof Error ? error.message : String(error) }); }
+  };
+  const cutoff = read.now().getTime() - 30 * 86400000;
+  attempt('directive', () => {
+    for (const row of read.directives(query)) rows.push({ source: 'directive', id: `${row.source_file}:${row.line_no}`,
+      title: row.text.replace(/\s+/g, ' ').slice(0, 160), status: 'recorded', at: row.ts,
+      current: Number.isFinite(Date.parse(row.ts)) && Date.parse(row.ts) >= cutoff, ref: `${row.source_file}:${row.line_no}` });
+  });
+  attempt('decision', () => {
+    for (const row of read.decisions()) {
+      if (!matches([row.title, row.scqa.s, row.scqa.c, row.scqa.q, row.scqa.a].filter(Boolean).join(' '), words)) continue;
+      rows.push({ source: 'decision', id: row.id, title: row.title, status: row.status,
+        at: row.decidedAt ?? row.withdrawnAt ?? row.raisedAt ?? row.importedAt ?? '', current: row.status === 'open',
+        ref: row.refs?.[0] ?? `decisions show ${row.id}` });
+    }
+  });
+  attempt('checklist', () => {
+    for (const version of new Set(read.versions())) {
+      for (const row of read.checklist(version).items) {
+        if (!matches(`${row.id} ${row.title}`, words)) continue;
+        rows.push({ source: 'checklist', id: row.id, title: row.title, status: row.status,
+          at: row.updatedAt, current: row.status === 'yellow', ref: `release checklist status --version ${version}` });
+      }
+    }
+  });
+  attempt('lesson', () => {
+    for (const row of read.lessons(query)) rows.push({ source: 'lesson', id: row.id, title: row.incident,
+      status: row.status, at: row.updated_at, current: row.occurrence_count > 1, ref: `lesson show ${row.id}` });
+  });
+  rows.sort((a, b) => Number(b.current) - Number(a.current) || (Date.parse(b.at) || 0) - (Date.parse(a.at) || 0)
+    || a.source.localeCompare(b.source) || a.id.localeCompare(b.id));
+  debug.log('knowledge.know', 'query', { query, counts: Object.fromEntries((['directive', 'decision', 'checklist', 'lesson'] as const)
+    .map(source => [source, rows.filter(row => row.source === source).length])), unavailable });
+  return { rows, unavailable };
+}

package/src/llm.ts

@@ -36,7 +36,7 @@ import {
   type ProviderFallbackAttempt,
   type ProviderFallbackTerminalVerdict,
 } from './session-runtime/retry-policy.js';
-import { fetchApiWithRetry } from './session-runtime/retry-api.js';
+import { fetchApiWithRetry, OverloadFailoverError, type FetchApiWithRetryOpts } from './session-runtime/retry-api.js';
 import { resolveModelAlias } from './intelligence-map/model-alias.js';
 import { reasoningEffortCeiling as reasoningEffortCeilingOf } from './intelligence-map/model-catalog.js';
 import { inferProviderFromModel as registryInferProviderFromModel } from './registry/normalize.js';
@@ -407,6 +407,10 @@ export interface LLMOpts {
       background?: 'transparent' | 'opaque' | 'auto';
     };
   };
+  /** Unused configured fallbacks. The HTTP retry layer switches provider
+   *  after k consecutive overload responses before spending those retries.
+   *  Callers that already pinned a provider omit this (0). */
+  remainingFallbacks?: number;
 }
 
 export interface LLMProvider {
@@ -1310,6 +1314,20 @@ export async function* parseOpenAISSELines(
  *  the request URL. The OpenAI streamer is shared by openai/grok/local
  *  endpoints — all three pass through here. The string lands in the
  *  `llm.retry` debug snapshot and the `ApiHttpError.provider` field. */
+/** Retries still left for this HTTP call. Callers that already know a
+ *  fallback remains pass it so overload switches before those retries. */
+function retryOptsFor(
+  provider: string,
+  errorPrefix: string,
+  remainingFallbacks?: number,
+): FetchApiWithRetryOpts {
+  return {
+    provider,
+    errorPrefix,
+    ...(remainingFallbacks !== undefined && remainingFallbacks > 0 ? { remainingFallbacks } : {}),
+  };
+}
+
 function inferOpenAIProviderName(url: string): string {
   if (url.includes('x.ai')) return 'grok';
   if (url.includes('openai.com')) return 'openai';
@@ -1326,6 +1344,7 @@ async function* streamOpenAIEvents(
    *  `x-grok-client-version` 이 빠지면 HTTP 426 으로 거절된다(실측).
    *  ⛔ 생략하면 종전과 «바이트 동일** — 기존 호출자 무회귀. */
   extraHeaders?: Record<string, string>,
+  remainingFallbacks?: number,
 ): AsyncGenerator<LLMStreamEvent, void, unknown> {
   const headers: Record<string, string> = { 'Content-Type': 'application/json', ...(extraHeaders ?? {}) };
   if (apiKey) headers['Authorization'] = `Bearer ${apiKey}`;
@@ -1353,10 +1372,7 @@ async function* streamOpenAIEvents(
       body: JSON.stringify({ ...body, stream: true }),
       signal,
     },
-    {
-      provider: inferOpenAIProviderName(url),
-      errorPrefix: 'LLM API',
-    },
+    retryOptsFor(inferOpenAIProviderName(url), 'LLM API', remainingFallbacks),
   );
 
   debug.log('llm.response.status', `${response.status} ${response.statusText || ''}`.trim(), {
@@ -2030,6 +2046,8 @@ export async function* streamCodexResponsesEvents(
      *  call. Best-effort; null/undefined if the backend skips the
      *  event. */
     onResponseCreated?: (id: string) => void;
+    /** Unused configured fallbacks. Overload k times switches before retries. */
+    remainingFallbacks?: number;
   } = {},
 ): AsyncGenerator<LLMStreamEvent, void, unknown> {
   const startedAt = Date.now();
@@ -2118,10 +2136,7 @@ export async function* streamCodexResponsesEvents(
       }),
       signal,
     },
-    {
-      provider: 'codex',
-      errorPrefix: 'Codex API',
-    },
+    retryOptsFor('codex', 'Codex API', extra.remainingFallbacks),
   );
   debug.log('llm.response.status', `codex ${response.status}`, {
     url, status: response.status, elapsedMs: Date.now() - startedAt,
@@ -3103,6 +3118,7 @@ async function* streamAnthropicEvents(
   apiKey: string,
   body: any,
   signal?: AbortSignal,
+  remainingFallbacks?: number,
 ): AsyncGenerator<LLMStreamEvent, void, unknown> {
   // Wave 6 (2026-05-04) — Anthropic beta headers from
   // ref/opencode `provider/provider.ts:181-185` analysis.
@@ -3139,10 +3155,7 @@ async function* streamAnthropicEvents(
       body: JSON.stringify({ ...body, stream: true }),
       signal,
     },
-    {
-      provider: 'anthropic',
-      errorPrefix: 'Anthropic API',
-    },
+    retryOptsFor('anthropic', 'Anthropic API', remainingFallbacks),
   );
 
   try {
@@ -4507,7 +4520,11 @@ export async function streamLLM(
     const consumed = await consumeProviderText(
       activeProvider,
       messages,
-      { ...opts, model: activeModel },
+      {
+        ...opts,
+        model: activeModel,
+        remainingFallbacks: opts.provider ? 0 : remainingFallbackProviderNames(attemptedProviders, opts).length,
+      },
       onChunk,
     );
     const full = consumed.full;
@@ -4528,6 +4545,22 @@ export async function streamLLM(
     }
 
     const err: any = consumed.error;
+    if (err instanceof OverloadFailoverError && !opts.provider) {
+      const switched = providerByName('grok');
+      if (switched && !attemptedProviders.has(switched.name) && switched.available() && full.length === 0) {
+        debug.log('llm.router', 'overload-failover', {
+          blockedProvider: activeProvider.name,
+          fallbackProvider: switched.name,
+          streak: err.streak,
+          status: err.status,
+          kind: err.kind,
+        }, { level: 'warn' });
+        activeProvider = switched;
+        modelOverride = undefined;
+        attemptedProviders.add(activeProvider.name);
+        continue;
+      }
+    }
     const reason = sanitizeProviderFailureReason(err?.message || String(err));
     debug.log('llm.router.error', 'streamLLM', {
       provider: activeProvider.name,
@@ -8350,9 +8383,11 @@ export async function streamLLMWithTools(
     // `tools: activeTools` (not opts.tools) so mid-loop hydration reaches the
     // provider on the next turn. turn-0 keeps opts.toolChoice; later turns
     // revert to auto (see above).
-    const buildTurnOpts = () => turn === 0
-      ? { ...opts, model: activeModel, tools: activeTools }
-      : { ...opts, model: activeModel, tools: activeTools, toolChoice: undefined };
+    const buildTurnOpts = () => {
+      const remainingFallbacks = opts.provider ? 0 : remainingFallbackProviderNames(attemptedProviders, opts).length;
+      const base = { ...opts, model: activeModel, tools: activeTools, remainingFallbacks };
+      return turn === 0 ? base : { ...base, toolChoice: undefined };
+    };
     let turnOpts = buildTurnOpts();
     // reasoning-heavy family(codex/claude/gemini/grok/local)는 침묵 추론 구간이 길어 idle watchdog 를
     // family-aware 로 상향(2026-07-19 goal-exec → 아크4 전-family). fast/mini(gpt·other)만 45s 유지.
@@ -8390,6 +8425,26 @@ export async function streamLLMWithTools(
         ]);
       } catch (err) {
         if (idleTimer) clearTimeout(idleTimer);
+        if (err instanceof OverloadFailoverError && !opts.provider) {
+          const switched = providerByName('grok');
+          if (switched && !attemptedProviders.has(switched.name) && switched.available() && evCount === 0) {
+            debug.log('llm.router', 'overload-failover', {
+              turn,
+              blockedProvider: activeProvider.name,
+              fallbackProvider: switched.name,
+              streak: err.streak,
+              status: err.status,
+              kind: err.kind,
+            }, { level: 'warn' });
+            const finalized = finalizeStreamingProviderModel(switched, switched.defaultModel);
+            activeProvider = finalized.provider;
+            activeModel = finalized.model;
+            attemptedProviders.add(activeProvider.name);
+            turnOpts = buildTurnOpts();
+            streamIter = undefined;
+            continue;
+          }
+        }
         // 명시 provider 선택만 폴백 대상이 아니다 — `streamLLM` 과 같은 계약으로
         // «원본 오류»를 그대로 올린다. 모델만 전달된 호출은 다음 provider의 기본 모델로 재시도한다.
         if (opts.provider) throw err;
@@ -10958,6 +11013,7 @@ function makeCodexProvider(cfg: UCLLMConfig): LLMProvider {
           // lastResponseId stays undefined and we fall back to full
           // input on the next turn (safe — just no token savings).
           onResponseCreated: useStore ? (id) => { lastResponseId = id; } : undefined,
+          remainingFallbacks: opts.remainingFallbacks,
         });
         // Snapshot full input AFTER the stream completes so the next
         // call's delta computation uses what the backend actually has
@@ -10991,7 +11047,7 @@ function makeCodexProvider(cfg: UCLLMConfig): LLMProvider {
         ...openAiTemperatureField(apiKeyModel, opts.temperature ?? 0.3),
         ...openAiOutputTokenField(apiKeyModel, opts.maxTokens ?? 2048),
         ...(tools ? { tools } : {}),
-      }, opts.signal);
+      }, opts.signal, undefined, opts.remainingFallbacks);
     },
     async *chat(messages, opts = {}) { yield* textOnly(this.streamChat!(messages, opts)); },
   };
@@ -11085,7 +11141,7 @@ function makeAnthropicProvider(cfg: UCLLMConfig): LLMProvider {
         ...(effort ? { thinking: { type: 'adaptive' }, output_config: { effort } } : {}),
         ...anthropicTemperatureField(anthropicModel, thinkingActive, opts.temperature),
         ...(tools ? { tools } : {}),
-      }, opts.signal);
+      }, opts.signal, opts.remainingFallbacks);
     },
     async *chat(messages, opts = {}) { yield* textOnly(this.streamChat!(messages, opts)); },
   };

package/src/loops/orchestrator/finish-rate.ts

@@ -6,6 +6,8 @@ import { loadRunLedger, resolveFederatedRunLedgerTargets } from '../../self-impl
 import type { LogTarget } from '../../cli/logs-cli.js';
 
 const DAY_MS = 24 * 60 * 60 * 1_000;
+/** Host-side records a Pod-dispatched launch leaves when its run starts inside the Pod. */
+const LAUNCH_ONLY_EVENTS = new Set(['launch-quota-policy', 'author-on-pod-receipt']);
 const GH_LIMIT = 1000;
 
 export type FinishMetric = 'launched' | 'landed' | 'landingRate' | 'staleDrafts' | 'conflictRatio' | 'unknownMergeable';
@@ -38,6 +40,7 @@ function defaultListStarts(cutoff: number, targets?: readonly LogTarget[]): Star
   const childLedgers = new Set<string>();
   let unreadableDirectories = 0;
   let unresolvedDirectories = 0;
+  const launchOnlyIds = new Set<string>();
   for (const { ledgerDirectory } of resolveFederatedRunLedgerTargets({ includeTest: true, ...(targets ? { targets } : {}) })) {
     let dir: string;
     try {
@@ -68,16 +71,24 @@ function defaultListStarts(cutoff: number, targets?: readonly LogTarget[]): Star
         continue;
       }
       const start = entries.find(entry => entry.event === 'start');
-      if (!start?.timestamp) {
+      // A Pod-dispatched launch leaves only a host launch record (launch-quota-policy · author-on-pod-receipt) — the run
+      // itself starts inside the Pod. That is still a launch: its time is the record's timestamp, else the ledger mtime.
+      const launchRecord = !start ? entries.find(entry => LAUNCH_ONLY_EVENTS.has(entry.event)) : undefined;
+      const startedAt = start?.timestamp ?? (launchRecord ? (launchRecord.timestamp ?? new Date(statSync(path).mtimeMs).toISOString()) : undefined);
+      if (!startedAt) {
         if (!starts.has(runId)) unreadable.set(runId, { runId, reason: entries[0]?.event ?? 'start missing' });
         continue;
       }
-      starts.set(runId, { runId, startedAt: start.timestamp });
+      // One runId can leave a host launch record in one directory and a Pod `start` in another: a real `start`
+      // always wins and is never overwritten by a launch record, whatever order the directories are read in.
+      if (launchRecord && starts.has(runId)) continue;
+      if (launchRecord) launchOnlyIds.add(runId); else launchOnlyIds.delete(runId);
+      starts.set(runId, { runId, startedAt });
       unreadable.delete(runId);
     }
   }
   debug.log('loop.orchestrator', 'finish-launch-population', {
-    directories: directories.size + unresolvedDirectories, launched: starts.size, childLedgers: childLedgers.size, unreadable: unreadable.size,
+    directories: directories.size + unresolvedDirectories, launched: starts.size, launchOnly: launchOnlyIds.size, childLedgers: childLedgers.size, unreadable: unreadable.size,
   });
   return { starts: [...starts.values()], unreadable: [...unreadable.values()], unreadableDirectories };
 }

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',