elanous 0.2.41 → 0.2.42

package/src/nexus/api/harness-traversal.ts

@@ -18,6 +18,7 @@
 
 import { loadFederatedRunLedger, loadRunLedger, runLedgerDir, type RunLedgerEntry } from '../../self-implement/run-ledger.js';
 import { redactSecretText } from '../../debug/log.js';
+import { projectRunLedgerSteps, type RunStep } from '../../self-implement/run-step-projection.js';
 
 export interface TraversalStepWire {
   node: string;
@@ -29,6 +30,8 @@ export interface TraversalStepWire {
   visit: number;
   maxVisits: number | null;
   detail: string | null;
+  /** Ledger sequence of this traversal entry; absent on legacy records. */
+  sourceSeq?: number;
 }
 
 export interface RunTraversalWire {
@@ -43,6 +46,8 @@ export interface RunTraversalWire {
   prNumber: number | null;
   substrate: string | null;
   steps: TraversalStepWire[];
+  /** Structural graph changes in the same per-run sequence domain as `steps[].sourceSeq`. */
+  graphEvents?: RunStep[];
   ledgerEvents: number;
 }
 
@@ -153,6 +158,7 @@ export function buildRunTraversal(runId: string, entries: readonly RunLedgerEntr
     if (isLast && terminal) outcome = TERMINAL_FAIL.has(status) ? 'fail' : (outcome ?? 'pass');
     const endIso = nextAt !== undefined ? sorted[nextAt]!.timestamp : terminal?.timestamp;
     const duration = ms(endIso) - ms(entry.timestamp);
+    const sourceSeq = (entry as RunLedgerEntry & { seq?: unknown }).seq ?? entry.data.seq;
     return {
       node,
       round: num(entry.data.round),
@@ -162,11 +168,15 @@ export function buildRunTraversal(runId: string, entries: readonly RunLedgerEntr
       visit,
       maxVisits: num(budget?.data.maxVisits),
       detail,
+      ...(typeof sourceSeq === 'number' && Number.isSafeInteger(sourceSeq) && sourceSeq > 0 ? { sourceSeq } : {}),
     };
   });
 
   const contract = sorted.find((entry) => entry.event === 'graph-run-contract-resolved')?.data;
   const pr = [...sorted].reverse().find((entry) => entry.event === 'pr-opened')?.data;
+  const projected = projectRunLedgerSteps(runId, sorted);
+  const graphEvents = projected.steps.filter((step) =>
+    step.type === 'node-added' || step.type === 'edge-rerouted' || step.type === 'unit-expanded' || step.type === 'unit-collapsed');
   return {
     runId,
     graphId: str(contract?.graphId) ?? str(sorted.find((entry) => entry.event === 'pipeline-node-entry')?.data.graphId),
@@ -178,6 +188,7 @@ export function buildRunTraversal(runId: string, entries: readonly RunLedgerEntr
     prNumber: num(pr?.number),
     substrate: str(contract?.actualSubstrate),
     steps,
+    ...(graphEvents.length ? { graphEvents } : {}),
     ledgerEvents: sorted.length,
   };
 }

package/src/pr-tool/census.ts

@@ -41,7 +41,7 @@ export interface GuardReason { code: GuardCode; detail: string; prs?: readonly n
 /** PR-GUARD-HUNK-WARN (대표 10-17): 줄 겹침은 기본 경고 — 착지 쪽 스마트 머지가 푼다. 'refuse' = 옛 거부 동작. */
 export type HunkOverlapMode = 'refuse' | 'warn';
 export interface GuardVerdict { status: 'allow' | 'refuse' | 'unknown'; reasons: readonly GuardReason[]; warnings: readonly GuardReason[];
-  sameCellConflicts?: readonly { pr: number; cardId: string | null; slice?: { slice: number; total: number } | null }[];
+  sameCellConflicts?: readonly { pr: number; branch: string | null; headSha: string; cardId: string | null; slice?: { slice: number; total: number } | null }[];
   sameCellReuse?: { number: number; branch: string; headSha: string; cellId: string; cardId: string; legacyBound?: true } }
 
 const SEATS = ['OP', 'TC', 'MK', 'UX'] as const;
@@ -511,7 +511,8 @@ export function guardNewPr(input: { files: readonly string[] | null; seat?: Seat
     ? { number: sameCell[0].number, branch: sameCell[0].headRefName, headSha: sameCell[0].headSha,
       cellId: input.cellId!, cardId: input.cardId, ...(legacyBound ? { legacyBound: true as const } : {}) } : undefined;
   return { status, reasons, warnings,
-    ...(sameCell.length ? { sameCellConflicts: sameCell.map(pr => ({ pr: pr.number, cardId: pr.cardId ?? null, slice: pr.slice ?? null })) } : {}),
+    ...(sameCell.length ? { sameCellConflicts: sameCell.map(pr => ({ pr: pr.number, branch: pr.headRefName ?? null,
+      headSha: pr.headSha, cardId: pr.cardId ?? null, slice: pr.slice ?? null })) } : {}),
     ...(reusable ? { sameCellReuse: reusable } : {}) };
 }
 

package/src/pty-shell/tui-run-state.ts

@@ -12,7 +12,7 @@
 // 판독(CLI 쪽): `describePtyRunState` 가 행 ⊕ 설치본 기록 ⊕ (체크아웃이면) 그 뿌리의 HEAD 로 판정한다.
 
 import { spawn } from 'node:child_process';
-import { readFileSync } from 'node:fs';
+import { appendFileSync, mkdirSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -30,6 +30,7 @@ import {
   updatePtyManifestAbortRequested, updatePtyManifestBuild, updatePtyManifestProgress, updatePtyManifestTurn,
   type PtyBuildIdentity, type PtyManifestRow, type PtyTurnState,
 } from './pty-manifest.js';
+import { ptyEventLogDbPath, readPtyEventsAfterAt } from './pty-event-log.js';
 
 const CODE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
 
@@ -496,6 +497,139 @@ export function judgeTurnProgress(input: TurnProgressInput): TurnProgressJudgmen
   return 'progressing';
 }
 
+// ── TUI-SEAT-PILOT-2H-COMPARE — 좌석 대조 판정 신호 한 줄 ──
+//
+// 완료 경계는 «실행 명령·runId·시작/끝 시각·두 표면의 원장 행·산출 바이트·오류 수·결과» 를
+// `seat-state/OP/tools/sim-log.sh` 한 줄로 남기라고 한다. 그 한 줄의 «형식» 은 순수 함수가 정하고,
+// 두 표면의 원장 행은 각자의 생산 원장에서 읽는다 — tui-run-state 는 pty_manifest 행, pty-event-log 는
+// `pty_events` 의 그 표면 행이다. ⛔ 재지 못한 항목은 «미측정» 으로 남긴다 — 측정된 `0` 과 섞지 않는다(null ≠ 0).
+
+/** 재지 못한 항목의 직렬화 값. 측정된 `0`·빈 문자열과 구별된다. */
+export const SEAT_COMPARE_UNMEASURED = '미측정';
+
+/** 한 표면의 원장 요약. `rows === null` 은 «못 읽었다» 이지 «0행» 이 아니다. */
+export interface SeatCompareLedgerSummary {
+  readonly surface: string;
+  readonly rows: number | null;
+  readonly lastSeq: number | null;
+  readonly lastState: string | null;
+}
+
+/** 판정 신호 입력 — 완료 경계가 이름으로 요구한 항목 그대로. */
+export interface SeatCompareSignalInput {
+  readonly runId: string | null;
+  readonly command: string | null;
+  readonly startedAt: number | null;
+  readonly endedAt: number | null;
+  /** 이 TUI 좌석 표면의 원장 행 요약(pty_manifest 턴 행). */
+  readonly tuiRunState: SeatCompareLedgerSummary;
+  /** 비교 상대 표면의 원장 행 요약(`pty_events`). */
+  readonly ptyEventLog: SeatCompareLedgerSummary;
+  readonly outputBytes: number | null;
+  readonly errors: number | null;
+  readonly result: string | null;
+}
+
+function seatCompareText(value: string | null | undefined): string {
+  if (value === null || value === undefined) return SEAT_COMPARE_UNMEASURED;
+  // 한 줄 계약 — 값 안의 개행·연속 공백은 접어서 줄을 쪼개지 못하게 한다.
+  const flat = value.replace(/\s+/g, ' ').trim();
+  return flat.length > 0 ? flat : SEAT_COMPARE_UNMEASURED;
+}
+
+function seatCompareCount(value: number | null | undefined): string {
+  if (value === null || value === undefined || !Number.isFinite(value)) return SEAT_COMPARE_UNMEASURED;
+  return String(value);
+}
+
+function seatCompareAt(ms: number | null | undefined): string {
+  if (ms === null || ms === undefined || !Number.isFinite(ms)) return SEAT_COMPARE_UNMEASURED;
+  return new Date(ms).toISOString();
+}
+
+function seatCompareLedger(summary: SeatCompareLedgerSummary): string {
+  return [
+    `ledger:${seatCompareText(summary.surface)}`,
+    `rows=${seatCompareCount(summary.rows)}`,
+    `lastSeq=${seatCompareCount(summary.lastSeq)}`,
+    `lastState=${seatCompareText(summary.lastState)}`,
+  ].join(' ');
+}
+
+/** 판정 신호 한 줄 — 새 줄 없이 ` · ` 로 잇는다. 못 잰 항목은 «미측정» 으로 남는다. */
+export function buildSeatCompareSignalLine(input: SeatCompareSignalInput): string {
+  return [
+    `run=${seatCompareText(input.runId)}`,
+    `cmd=${seatCompareText(input.command)}`,
+    `start=${seatCompareAt(input.startedAt)}`,
+    `end=${seatCompareAt(input.endedAt)}`,
+    seatCompareLedger(input.tuiRunState),
+    seatCompareLedger(input.ptyEventLog),
+    `bytes=${seatCompareCount(input.outputBytes)}`,
+    `errors=${seatCompareCount(input.errors)}`,
+    `result=${seatCompareText(input.result)}`,
+  ].join(' · ');
+}
+
+/** 생산 이음매 — `pty_events` 원장에서 이 표면의 행을 실제로 읽어 요약한다. 못 읽으면 rows=null(미측정). */
+export function readPtyEventLogLedger(surfaceId: string, dbPath: string = ptyEventLogDbPath()): SeatCompareLedgerSummary {
+  const surface = 'pty-event-log';
+  const read = readPtyEventsAfterAt(dbPath, 0, { surfaceId });
+  if (read.status !== 'ok') return { surface, rows: null, lastSeq: null, lastState: null };
+  const last = read.rows.length > 0 ? read.rows[read.rows.length - 1] : undefined;
+  return { surface, rows: read.rows.length, lastSeq: last ? last.seq : 0, lastState: last?.state ?? null };
+}
+
+/** 기본 기록 위치 — 셸 도구와 같은 파일(`seat-state/OP/tools/sim-log.log`). `ELANOUS_SEAT_COMPARE_LOG` 로 바꾼다. */
+export const SEAT_COMPARE_LOG_PATH = join(CODE_ROOT, 'seat-state', 'OP', 'tools', 'sim-log.log');
+
+export interface SeatCompareWriteDeps {
+  readonly path?: string;
+  /** append 이음매 — 시험이 임시 파일·메모리로 바꾼다. */
+  readonly append?: (path: string, line: string) => void;
+}
+
+/** 판정 신호 한 줄을 sim-log 에 append 한다. 실패(권한 등)는 false — 종료 경로를 깨지 않는다. */
+export function appendSeatCompareSignalLine(line: string, deps: SeatCompareWriteDeps = {}): boolean {
+  const path = deps.path ?? (process.env.ELANOUS_SEAT_COMPARE_LOG?.trim() || SEAT_COMPARE_LOG_PATH);
+  try {
+    if (deps.append) {
+      deps.append(path, line);
+    } else {
+      mkdirSync(dirname(path), { recursive: true });
+      appendFileSync(path, `${line}\n`, 'utf8');
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 생산 진입점 스위치 — `ELANOUS_SEAT_COMPARE_RUN_ID` 가 있을 때만 좌석 대조 원장을 켠다.
+ * 없으면 `null` = 녹음기가 그 한 줄을 안 남긴다(«미실행은 미측정»).
+ */
+export function seatCompareDepsFromEnv(env: NodeJS.ProcessEnv = process.env): TuiSeatCompareDeps | null {
+  const runId = env.ELANOUS_SEAT_COMPARE_RUN_ID?.trim();
+  if (!runId) return null;
+  const command = env.ELANOUS_SEAT_COMPARE_COMMAND?.trim() || [process.execPath, ...process.argv.slice(1)].join(' ');
+  return { runId, command };
+}
+
+/** 좌석 대조 판정 신호를 켜는 손잡이 — 주면 녹음기 종료 경로가 두 표면 원장을 읽어 한 줄을 남긴다. */
+export interface TuiSeatCompareDeps {
+  readonly runId: string | null;
+  readonly command?: string | null;
+  /** 산출 바이트 — 녹음기가 못 재면 생략(«미측정»). */
+  readonly outputBytes?: number | null;
+  /** 결과 판정 문구 — 생략하면 종료 시 마지막 턴 상태. */
+  readonly result?: string | null;
+  /** 원장 요약 읽기 이음매(시험: 가짜 원장). 생략하면 실 `pty_events`. */
+  readonly readLedger?: (surfaceId: string) => SeatCompareLedgerSummary;
+  /** 기록 이음매(시험: 메모리). 생략하면 sim-log 파일 append. */
+  readonly write?: (line: string) => boolean;
+}
+
 // ── 기록(TUI) ──
 
 export interface TuiRunStateRecorderDeps {
@@ -524,6 +658,11 @@ export interface TuiRunStateRecorderDeps {
    * 생략하면 감시를 안 건다 — 이 축을 켜는 것은 호출자(생산 진입점)의 결정이다.
    */
   readonly selfRestart?: TuiSelfRestartDeps;
+  /**
+   * TUI-SEAT-PILOT-2H-COMPARE 좌석 대조 판정 신호. 주면 종료 경로가 두 표면(pty_manifest 턴 행 ⊕
+   * `pty_events`)의 원장행을 읽어 «한 줄» 을 sim-log 에 남긴다. 생략하면 아무것도 안 남긴다(미실행=미측정).
+   */
+  readonly seatCompare?: TuiSeatCompareDeps;
 }
 
 interface ActiveRecorder {
@@ -550,9 +689,29 @@ const defaultLog = (event: string, data: Record<string, unknown>): void => { deb
 export function startTuiRunStateRecorder(surfaceId: string, deps: TuiRunStateRecorderDeps = {}): () => void {
   const now = deps.now ?? Date.now;
   const log = deps.log ?? defaultLog;
-  const writeTurn = deps.writeTurn ?? updatePtyManifestTurn;
+  const writeTurnBase = deps.writeTurn ?? updatePtyManifestTurn;
   const writeProgress = deps.writeProgress ?? updatePtyManifestProgress;
   const writeAbortRequested = deps.writeAbortRequested ?? updatePtyManifestAbortRequested;
+  // 좌석 대조 신호가 켜졌을 때만 턴 행 수·쓰기 실패를 센다 — 꺼져 있으면 판정 신호 비용 0.
+  const seatCompare = deps.seatCompare ?? null;
+  // 시작 시각도 신호가 켜졌을 때만 잰다 — 꺼져 있으면 종전과 같이 now() 를 한 번도 더 부르지 않는다.
+  const seatCompareStartedAt = seatCompare ? now() : 0;
+  let seatCompareTurnRows = 0;
+  let seatCompareWriteFailures = 0;
+  const writeTurn = seatCompare
+    ? (id: string, turn: PtyTurnState, at: number): boolean => {
+      let ok = false;
+      try {
+        ok = writeTurnBase(id, turn, at);
+      } catch (error) {
+        seatCompareWriteFailures += 1;
+        throw error;
+      }
+      if (ok) seatCompareTurnRows += 1;
+      else seatCompareWriteFailures += 1;
+      return ok;
+    }
+    : writeTurnBase;
   // 기본 신고기는 기본 manifest 쓰기와 짝일 때만. writeTurn 주입(시험)은 herdr 를 안 만든다.
   const herdr = deps.herdr !== undefined
     ? deps.herdr
@@ -564,6 +723,7 @@ export function startTuiRunStateRecorder(surfaceId: string, deps: TuiRunStateRec
   if (build) {
     const ok = (() => { try { return (deps.writeBuild ?? updatePtyManifestBuild)(surfaceId, build); } catch { return false; } })();
     log(ok ? 'build-recorded' : 'build-write-failed', { ptyId: surfaceId, sha: build.sha, version: build.version, source: build.source });
+    if (!ok) seatCompareWriteFailures += 1;
   }
   // 기동 순서: 판 → manifest 초기 idle → herdr 신고. herdr start 가 idle 을 신고하므로 초기 idle 을 turn 으로 다시 안 보낸다.
   const recorder: ActiveRecorder = { surfaceId, now, writeTurn, writeProgress, writeAbortRequested, log, herdr, herdrLast: herdr ? 'idle' : undefined };
@@ -662,6 +822,32 @@ export function startTuiRunStateRecorder(surfaceId: string, deps: TuiRunStateRec
     try { unwatch(); } catch { /* 종료 경로를 깨지 않는다 */ }
     try { unguard(); } catch { /* 종료 경로를 깨지 않는다 */ }
     if (herdr) { try { herdr.release(); } catch { /* 종료 경로를 깨지 않는다 */ } }
+    // 좌석 대조 판정 신호 — 두 표면의 원장 행을 «여기서» 읽어 한 줄로 남긴다.
+    if (seatCompare) {
+      try {
+        const readLedger = seatCompare.readLedger ?? readPtyEventLogLedger;
+        const line = buildSeatCompareSignalLine({
+          runId: seatCompare.runId,
+          command: seatCompare.command ?? null,
+          startedAt: seatCompareStartedAt,
+          endedAt: now(),
+          tuiRunState: {
+            surface: 'tui-run-state',
+            rows: seatCompareTurnRows,
+            lastSeq: null,
+            lastState: recorder.last ?? null,
+          },
+          ptyEventLog: readLedger(surfaceId),
+          outputBytes: seatCompare.outputBytes ?? null,
+          errors: seatCompareWriteFailures,
+          result: seatCompare.result ?? recorder.last ?? null,
+        });
+        const written = (seatCompare.write ?? appendSeatCompareSignalLine)(line);
+        log(written ? 'seat-compare-signal' : 'seat-compare-signal-write-failed', { ptyId: surfaceId, line });
+      } catch (error) {
+        log('seat-compare-signal-failed', { ptyId: surfaceId, error: error instanceof Error ? error.message : String(error) });
+      }
+    }
     if (active === recorder) active = null;
   };
 }

package/src/release-loop/checklist-target-path-hint.ts

@@ -0,0 +1,13 @@
+export interface TargetPathHintLine {
+  readonly fragments: readonly string[];
+  readonly labelMissing: boolean;
+}
+
+/** Parse the first declared target-path line shared by checklist storage and ask preflight. */
+export function parseTargetPathHintLine(text: string): TargetPathHintLine {
+  const firstLine = text.split(/\r?\n/).find((line) => line.trim() !== '');
+  if (firstLine === undefined) return { fragments: [], labelMissing: true };
+  const match = /^\s*(?:대상\s*경로|target\s*paths?)\s*[:：]\s*(.*)$/i.exec(firstLine);
+  if (!match) return { fragments: [], labelMissing: true };
+  return { fragments: match[1]!.split(/[·,;]/), labelMissing: false };
+}

package/src/release-loop/checklist.ts

@@ -5,6 +5,9 @@ import { isAbsolute, join } from 'node:path';
 import * as store from './feature-store.js';
 import { debug } from '../debug/log.js';
 import { CliUserError } from '../cli/cli-user-error.js';
+import { parseTargetPathHintLine } from './checklist-target-path-hint.js';
+export { parseTargetPathHintLine } from './checklist-target-path-hint.js';
+export type { TargetPathHintLine } from './checklist-target-path-hint.js';
 
 export type ChecklistStatus = 'green' | 'yellow' | 'red' | 'done';
 export type ChecklistDisposition = 'move' | 'known-issue' | 'block';
@@ -248,6 +251,11 @@ export function isMergeOrTypecheckOnlyEvidence(value: string): boolean {
   return signal;
 }
 
+/** Parsed target path fragments, preserving order and raw path spelling while trimming separator whitespace. */
+export function parseChecklistTargetPaths(text: string): string[] {
+  return parseTargetPathHintLine(text).fragments.map((fragment) => fragment.trim().replace(/^`+|`+$/g, ''));
+}
+
 /** Shadow check at checklist authorship. Callers supply the origin/main file probe and merged-PR file reader. */
 export function inspectChecklistTargetPaths(input: {
   title: string; evidence?: string; refs?: readonly string[]; dispatchKind?: ChecklistDispatchKind;
@@ -256,7 +264,7 @@ export function inspectChecklistTargetPaths(input: {
 } {
   const lines = input.title.split(/\r?\n/);
   const first = /^대상 경로:\s*(.*)$/.exec(lines[0] ?? '');
-  const rawTargets = first?.[1]?.split(' · ').map((path) => path.trim()) ?? [];
+  const rawTargets = parseChecklistTargetPaths(lines[0] ?? '');
   const validPath = (path: string): boolean => path.length > 0 && path.length < 4096
     && !path.startsWith('/') && !path.includes('\\') && !/[\u0000-\u001f\u007f]/u.test(path)
     && path.split('/').every((segment) => segment !== '' && segment !== '.' && segment !== '..');

package/src/repl/index.ts

@@ -41,6 +41,8 @@ import {
   type UserConfig,
 } from '../user-config.js';
 import { setAmbientSessionId, debug } from '../debug/log.js';
+import { buildInstalledSkillCatalogMessage, type InstalledSkillSummary } from '../dashboard/skill-catalog-preamble.js';
+import { resolveModelContextWindow } from '../models/context-window.js';
 import { decideSigintAction } from './sigint.js';
 import { decideSessionStart, observeSessionStart } from '../session/session-start.js';
 import { buildReplayTurnsFromSession } from './replay.js';
@@ -275,13 +277,39 @@ export function buildReplSystemPrompt(ctx: {
   sessionId?: string | undefined;
   /** 시험·임베디드 호출부용 시임 — 기본은 실제 홈·msg 원장·process.env. */
   seatBootDeps?: SeatBootDeps | undefined;
+  /** Installed skill summaries are injectable for deterministic prompt tests. */
+  skillCatalog?: readonly InstalledSkillSummary[] | undefined;
+  skillCatalogContextWindow?: number | null | undefined;
 }): string | undefined {
   const base = ctx.enabledToolNames === undefined
     ? undefined
     : buildAgentSystemPrompt(ctx.cfg, ctx.enabledToolNames);
+  const skillToolsEnabled = ctx.enabledToolNames?.includes('skill_exec') === true
+    && ctx.enabledToolNames.includes('elanous_skills_list');
+  let skillCatalogText = '';
+  if (skillToolsEnabled) {
+    try {
+      const catalog = ctx.skillCatalog ?? (() => {
+        const skills = require('../skills/index.js') as typeof import('../skills/index.js');
+        return skills.applySkillFilter(skills.getSkillIndex(), ctx.cfg.skills)
+          .map(({ name, description }) => ({ name, description }));
+      })();
+      const built = buildInstalledSkillCatalogMessage(
+        catalog,
+        ctx.skillCatalogContextWindow ?? resolveModelContextWindow(ctx.cfg.llm.model),
+      );
+      skillCatalogText = built.message?.content ?? '';
+      debug.log('repl.skill-catalog', 'built', {
+        skillCount: built.skillCount, estimatedTokens: built.estimatedTokens,
+        budgetTokens: built.budgetTokens, mode: built.mode,
+      });
+    } catch (error) {
+      debug.log('repl.skill-catalog', 'failed', { reason: error instanceof Error ? error.message : String(error) }, { level: 'warn' });
+    }
+  }
   const card = buildSeatBootCardText(ctx);
-  if (card.length === 0) return base;
-  return base === undefined || base.length === 0 ? card : `${base}\n\n${card}`;
+  const parts = [skillCatalogText, base ?? '', card].filter(part => part.length > 0);
+  return parts.length > 0 ? parts.join('\n\n') : undefined;
 }
 
 /** 자리 부트 카드 문면(system 메시지 0~1개를 이어 붙인 것). 자리가 아니면 ''. */
@@ -344,6 +372,7 @@ async function runOneTurn(
   nextTuiDelivery?: { pending: PendingTaskNotification[] },
   onJsonDelta?: (delta: string) => void,
   onJsonStatus?: (line: string) => void,
+  onJsonReplace?: (fullText: string) => void,
 ): Promise<{ reply: string; provider: string; model: string | null; durationMs: number; logPath: string | null }> {
   const startedAt = Date.now();
   const replyChunks: string[] = [];
@@ -374,6 +403,7 @@ async function runOneTurn(
     userConfig: cfg,
     sessionId,
     userText,
+    utteranceSurface: 'tui',
     systemPrompt,
     userImages: userImages.length > 0 ? userImages : undefined,
     ...(process.env.ELANOUS_TEST_FAKE_LLM === '1' && Number.isFinite(Number(process.env.ELANOUS_TEST_FAKE_LLM_IDLE_TIMEOUT_MS))
@@ -387,6 +417,14 @@ async function runOneTurn(
       }
       else process.stdout.write(d);
     },
+    onReplaceText: (fullText) => {
+      if (jsonOutput) {
+        replyChunks.splice(0, replyChunks.length, fullText);
+        onJsonReplace?.(fullText);
+      } else {
+        process.stdout.write(`\n\n  [근거 반영된 답변]\n  ${fullText}\n`);
+      }
+    },
     onStatusLine: (line) => { onJsonStatus?.(line); },
     tools: replToolSpecs,
     dispatchTool: tools?.dispatch,
@@ -795,6 +833,9 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
           process.env.ELANOUS_NEXT_TUI_STREAM === '1' && typeof turn.id === 'string'
             ? (text) => { process.stdout.write(`${JSON.stringify({ event: 'status', turnId: turn.id, text })}\n`); }
             : undefined,
+          process.env.ELANOUS_NEXT_TUI_STREAM === '1' && typeof turn.id === 'string'
+            ? (text) => { process.stdout.write(`${JSON.stringify({ event: 'replace', turnId: turn.id, text })}\n`); }
+            : undefined,
         );
       } catch (error) {
         if (!backgroundBridge) throw error;

package/src/research/axis-fanout.ts

@@ -1,7 +1,15 @@
 // Research-only native fanout. The caller supplies Bloom's question ladder;
 // each axis gets its own direct tool call and evidence stays attributed to it.
 import type { BloomResearchQuestion, ResearchEvidenceEnvelope } from '../auto-research/question-ladder-contract.js';
-import type { WebSearchHit } from '../web-search/provider.js';
+import { getAvailableWebSearchProviders } from '../web-search/index.js';
+import type { WebSearchHit, WebSearchProvider } from '../web-search/provider.js';
+import { debug } from '../debug/log.js';
+
+const RESEARCH_SEARCH_ENGINES = ['grok', 'grok-api', 'firecrawl'] as const;
+const RESEARCH_GROK_TIMEOUT_MS = 8_000;
+// Leave scheduler/logging headroom under the user-visible 15s aggregate cap.
+export const RESEARCH_SEARCH_BUDGET_MS = 14_500;
+const ENGINE_BREAKER_FAILURE_LIMIT = 2;
 
 export interface AxisToolCallPlan {
   questionId: string;
@@ -25,10 +33,119 @@ export interface AxisSearchResult {
   hits: AxisSearchHit[];
   errors: string[];
 }
-export type AxisSearch = (query: string) => Promise<AxisSearchHit[] | AxisSearchResult>;
+export type AxisSearch = (query: string, signal?: AbortSignal) => Promise<AxisSearchHit[] | AxisSearchResult>;
 
 export interface AxisFanoutDeps {
   search?: AxisSearch;
+  signal?: AbortSignal;
+}
+
+interface ProviderHealth {
+  failures: number;
+  open: boolean;
+}
+
+/** Build one bounded searcher per research prepass. Free/DDG is deliberately
+ * excluded: it is not a safe fallback for stock research and can consume a
+ * full 15s timeout for every query. Per-engine serialization lets the first
+ * timeout open that engine's breaker before queued Bloom axes start. */
+export function createResearchAxisSearcher(
+  availableProviders: readonly WebSearchProvider[] = getAvailableWebSearchProviders(),
+  now: () => number = Date.now,
+): AxisSearch {
+  const grok = availableProviders.find(provider => provider.id === 'grok')
+    ?? availableProviders.find(provider => provider.id === 'grok-api');
+  const allowed = [
+    ...(grok ? [grok] : []),
+    ...availableProviders.filter(provider => provider.id === 'firecrawl'),
+  ];
+  const health = new Map(allowed.map(provider => [provider.id, { failures: 0, open: false }]));
+  const deadline = now() + RESEARCH_SEARCH_BUDGET_MS;
+  const tails = new Map<string, Promise<void>>();
+
+  debug.log('research.search', 'provider-preflight', {
+    allowed: RESEARCH_SEARCH_ENGINES,
+    available: allowed.map(provider => provider.id),
+    excluded: availableProviders.filter(provider => !(RESEARCH_SEARCH_ENGINES as readonly string[]).includes(provider.id))
+      .map(provider => provider.id),
+    budgetMs: RESEARCH_SEARCH_BUDGET_MS,
+  });
+
+  const enqueue = <T>(providerId: string, run: () => Promise<T>): Promise<T> => {
+    const previous = tails.get(providerId) ?? Promise.resolve();
+    const current = previous.then(run, run);
+    tails.set(providerId, current.then(() => undefined, () => undefined));
+    return current;
+  };
+
+  return async (query, signal) => {
+    const hits: AxisSearchHit[] = [];
+    const errors: string[] = [];
+    const selected = allowed.filter(provider => !health.get(provider.id)?.open);
+    if (selected.length === 0) return { hits, errors: ['no healthy Grok/Firecrawl research provider'] };
+
+    await Promise.all(selected.map(provider => enqueue(provider.id, async () => {
+      const state = health.get(provider.id)!;
+      if (state.open) return;
+      const remainingMs = deadline - now();
+      if (remainingMs <= 0) {
+        state.open = true;
+        errors.push(`${provider.id}: research search budget exhausted`);
+        return;
+      }
+      const activeCount = Math.max(1, allowed.filter(candidate => !health.get(candidate.id)?.open).length);
+      const isGrok = provider.id === 'grok' || provider.id === 'grok-api';
+      const timeoutMs = isGrok
+        ? Math.min(RESEARCH_GROK_TIMEOUT_MS, remainingMs)
+        : Math.max(1, Math.floor(remainingMs / activeCount));
+      const startedAt = now();
+      try {
+        const controller = new AbortController();
+        const abortFromCaller = (): void => controller.abort(signal?.reason);
+        if (signal?.aborted) abortFromCaller();
+        else signal?.addEventListener('abort', abortFromCaller, { once: true });
+        let timer: ReturnType<typeof setTimeout> | undefined;
+        let result;
+        try {
+          result = await Promise.race([
+            provider.search({ query, limit: 5 }, controller.signal),
+            new Promise<never>((_, reject) => {
+              timer = setTimeout(() => {
+                controller.abort();
+                reject(new DOMException(`${provider.id} research search timed out after ${timeoutMs}ms`, 'TimeoutError'));
+              }, timeoutMs);
+            }),
+          ]);
+        } finally {
+          if (timer !== undefined) clearTimeout(timer);
+          signal?.removeEventListener('abort', abortFromCaller);
+        }
+        if (result.hits.length === 0) {
+          state.failures += 1;
+          if (state.failures >= ENGINE_BREAKER_FAILURE_LIMIT) state.open = true;
+        } else {
+          state.failures = 0;
+          hits.push(...result.hits.map(hit => ({ ...hit, engine: provider.id })));
+        }
+        debug.log('research.search', 'provider-complete', {
+          provider: provider.id, queryLength: query.length, hits: result.hits.length,
+          durationMs: now() - startedAt, breakerOpen: state.open,
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const timeout = error instanceof Error && /timeout|timed out|abort/i.test(`${error.name} ${error.message}`);
+        const quota = /quota|credit|rate.?limit|\b429\b|exhaust/i.test(message);
+        state.failures += 1;
+        if (timeout || quota || state.failures >= ENGINE_BREAKER_FAILURE_LIMIT) state.open = true;
+        errors.push(`${provider.id}: ${message}`);
+        debug.log('research.search', 'provider-failed', {
+          provider: provider.id, queryLength: query.length, durationMs: now() - startedAt,
+          timeout, quota, failures: state.failures, breakerOpen: state.open,
+        }, { level: 'warn' });
+      }
+    })));
+    return { hits, errors };
+  };
 }
 
 /** Keep every query attached to the Bloom question that produced it. */
@@ -39,18 +156,6 @@ export function planAxisToolCalls(questions: readonly BloomResearchQuestion[]):
     .map(query => ({ questionId: question.id, tool: 'OmniSearch' as const, query })));
 }
 
-async function directOmniSearch(query: string): Promise<AxisSearchResult> {
-  const { dispatchOmniSearch } = await import('../skills/tools/omni-search.js');
-  const hits: AxisSearchHit[] = [];
-  const result = await dispatchOmniSearch({ query }, { onSource: hit => { hits.push(hit); } });
-  if (Object.keys(result.metadata.perEngine).length === 0) {
-    throw new Error('no available web-search providers');
-  }
-  const errors = Object.entries(result.metadata.perEngine)
-    .flatMap(([engine, info]) => info.error ? [`${engine}: ${info.error}`] : []);
-  return { hits, errors };
-}
-
 function evidenceFromHit(question: BloomResearchQuestion, hit: AxisSearchHit): ResearchEvidenceEnvelope {
   const published = hit.publishedAt;
   const date = published !== undefined && Number.isFinite(published) && published > 0
@@ -89,8 +194,8 @@ export async function fanOutAxisEvidence(
   if (new Set(questions.map(question => question.id)).size !== questions.length) {
     throw new Error('research axis question IDs must be unique');
   }
-  const search = deps.search ?? directOmniSearch;
-  const settled = await Promise.allSettled(plan.map(call => search(call.query)));
+  const search = deps.search ?? createResearchAxisSearcher();
+  const settled = await Promise.allSettled(plan.map(call => search(call.query, deps.signal)));
   const axes: AxisEvidenceGroup[] = questions.map(question => ({ questionId: question.id, evidence: [] }));
   const groups = new Map(axes.map(axis => [axis.questionId, axis]));
   const byQuestion = new Map(questions.map(question => [question.id, question]));

package/src/research/bloom-exemplars.ts

@@ -34,10 +34,12 @@ const BLOOM_BY_LEVEL = Object.fromEntries(COGNITIVE_BY_LEVEL.map((cognitive, ind
   return [index + 1, cell];
 })) as Record<BloomExemplarLevel, Bloom2D>;
 
-// Public source tree intentionally contains only two original exemplars.
+// Public source tree intentionally contains a small set of original exemplars.
 const PUBLIC_EXEMPLARS: readonly BloomExemplar[] = [
   { domain: 'finance', level: 4, bloom: BLOOM_BY_LEVEL[4], question: '채권 금리 변화가 만기 구조와 발행자의 차환 위험에 어떤 경로로 연결되는가?' },
   { domain: 'finance', level: 5, bloom: BLOOM_BY_LEVEL[5], question: '현재 금리 전망을 반박할 수 있는 시장 지표와 그 신뢰도는 무엇인가?' },
+  { domain: 'technology', level: 4, bloom: BLOOM_BY_LEVEL[4], question: 'AI 데이터센터의 추론 처리량 증가가 GPU 전력밀도와 냉각 부하, 랙당 계통용량 요구에 어떤 경로로 이어지는가?' },
+  { domain: 'technology', level: 5, bloom: BLOOM_BY_LEVEL[5], question: 'AI 데이터센터 전력수요 전망을 반박할 수 있는 GPU 이용률·전력사용효율·계통접속 자료는 무엇이며 각 지표의 한계는 무엇인가?' },
 ];
 
 const DOMAIN_TERMS: Record<BloomExemplarDomain, readonly string[]> = {