elanous 0.2.34 → 0.2.35

package/src/release-loop/landed-but-yellow.ts

@@ -23,9 +23,64 @@ export function evidencePlan(rows: readonly LandedButYellowRow[]): Array<{ id: s
   }));
 }
 
+interface PrIndex {
+  /** Shape of the list when indexed — a mismatch means the caller changed the array in place. */
+  length: number;
+  firstNumber: number | undefined;
+  lastNumber: number | undefined;
+  /** PR positions per body `칸:` line id — the whole-line label the matcher accepts. */
+  cellIds: Map<string, number[]>;
+  /** PR positions per maximal ASCII-alphanumeric run in the title or body. */
+  runs: Map<string, number[]>;
+}
+
+const ALNUM_RUN = /[A-Za-z0-9]+/g;
+const CELL_LINE = /^[ \t]*칸(?:[ \t]*:[ \t]*|[ \t]+)([A-Za-z0-9_-]+(?:[ \t]*,[ \t]*[A-Za-z0-9_-]+)*)[ \t]*$/;
+const prIndexes = new WeakMap<readonly MergedChecklistPr[], PrIndex>();
+
+function push(map: Map<string, number[]>, key: string, position: number): void {
+  const list = map.get(key);
+  if (!list) map.set(key, [position]);
+  else if (list[list.length - 1] !== position) list.push(position);
+}
+
+/**
+ * Built once per PR list (the open audit reuses one list across every version). Contract: callers treat the list as
+ * read-only after passing it. A cheap guard still re-indexes when the length or the first/last PR number changed;
+ * an in-place edit that keeps all three is not detected.
+ */
+function prIndex(prs: readonly MergedChecklistPr[]): PrIndex {
+  const cached = prIndexes.get(prs);
+  if (cached && cached.length === prs.length && cached.firstNumber === prs[0]?.number && cached.lastNumber === prs[prs.length - 1]?.number) return cached;
+  const index: PrIndex = { length: prs.length, firstNumber: prs[0]?.number, lastNumber: prs[prs.length - 1]?.number, cellIds: new Map(), runs: new Map() };
+  prs.forEach((pr, position) => {
+    const body = pr.body ?? '';
+    for (const line of body.split('\n')) {
+      const match = CELL_LINE.exec(line.endsWith('\r') ? line.slice(0, -1) : line);
+      for (const candidate of match?.[1]?.split(',') ?? []) push(index.cellIds, candidate.trim(), position);
+    }
+    for (const text of [pr.title, body]) for (const [run] of text.matchAll(ALNUM_RUN)) push(index.runs, run, position);
+  });
+  prIndexes.set(prs, index);
+  return index;
+}
+
+/**
+ * PRs that can match `id` at all — a necessary condition, never a verdict. Every non-cell-line basis needs `id`
+ * in the title or body with no ASCII letter/digit on either side, so its leading alphanumeric run appears there
+ * as a maximal run. Ids that do not start with a letter or digit fall back to every PR.
+ */
+function candidatePositions(index: PrIndex, id: string, total: number): number[] {
+  const lead = /^[A-Za-z0-9]+/.exec(id)?.[0];
+  if (!lead) return Array.from({ length: total }, (_, position) => position);
+  const merged = new Set([...(index.cellIds.get(id) ?? []), ...(index.runs.get(lead) ?? [])]);
+  return [...merged].sort((a, b) => a - b);
+}
+
 /** Prefer a dedicated body cell line over title evidence; incidental mentions only qualify for long ids. */
 export function landedButYellow(items: readonly ChecklistItem[], prs: readonly MergedChecklistPr[], { owner }: { owner?: string } = {}): LandedButYellowRow[] {
   const rows: LandedButYellowRow[] = [];
+  const index = prIndex(prs);
   for (const item of items) {
     if (item.status !== 'yellow' && item.status !== 'red') continue;
     if (owner !== undefined && !ownerMatches(item.owner, owner)) continue;
@@ -37,11 +92,10 @@ export function landedButYellow(items: readonly ChecklistItem[], prs: readonly M
       : new RegExp(`^${id}(?:\\s|$)`);
     const explicitTitle = new RegExp(`(?<![A-Za-z0-9])${id}\\s+(?:수확|(?:첫|둘째|셋째)\\s*조각)(?![A-Za-z0-9가-힣])|\\(${id}\\)`);
     const rank: Record<PrMatchBasis, number> = { 'cell-line': 0, 'title-strong': 1, mention: 2 };
-    const matched = prs.flatMap((pr) => {
-      const cellLine = (pr.body ?? '').split('\n').some((line) => {
-        const match = /^[ \t]*칸(?:[ \t]*:[ \t]*|[ \t]+)([A-Za-z0-9_-]+(?:[ \t]*,[ \t]*[A-Za-z0-9_-]+)*)[ \t]*$/.exec(line.endsWith('\r') ? line.slice(0, -1) : line);
-        return match?.[1]?.split(',').some((candidate) => candidate.trim() === item.id) ?? false;
-      });
+    const cellLines = new Set(index.cellIds.get(item.id) ?? []);
+    const matched = candidatePositions(index, item.id, prs.length).flatMap((position) => {
+      const pr = prs[position]!;
+      const cellLine = cellLines.has(position);
       const basis: PrMatchBasis | undefined = cellLine ? 'cell-line'
         : titleStart.test(pr.title) || explicitTitle.test(pr.title) ? 'title-strong'
           : !shortId && (word.test(pr.title) || word.test(pr.body ?? '')) ? 'mention' : undefined;
@@ -58,3 +112,73 @@ export function landedButYellow(items: readonly ChecklistItem[], prs: readonly M
   }
   return rows.sort((a, b) => Number(b.newer) - Number(a.newer));
 }
+
+export interface MergedPrRunResult { status: number | null; stdout: string; stderr: string }
+/** One `gh` invocation; resolves when the process exits. */
+export type MergedPrRunner = (command: string, args: readonly string[], cwd: string) => Promise<MergedPrRunResult>;
+
+export const MERGED_PR_LIMIT = 400;
+/** Concurrent `gh pr list` calls once the first page is full (LANDED-YELLOW-FAST · 10-21 prod: 24 sequential calls ≈ 145s). */
+export const MERGED_PR_CONCURRENCY = 6;
+const DAY_MS = 86_400_000;
+
+/**
+ * Merged PRs since `since` (UTC date). One call answers when it returns fewer than the cap. Otherwise the range
+ * splits into UTC-day windows fetched with a concurrency cap; a full window is halved down to one second as before,
+ * and a full one-second window probes one extra row to tell exactly 400 from truncation.
+ * The returned set and the truncation flag match the former sequential bisection; only call shape and time differ.
+ */
+export async function fetchMergedChecklistPrs(since: string, now: Date, run: MergedPrRunner, cwd: string,
+  { concurrency = MERGED_PR_CONCURRENCY }: { concurrency?: number } = {}): Promise<{ prs: MergedChecklistPr[]; truncated: boolean; calls: number }> {
+  let calls = 0;
+  const fetch = async (lower: string, upper?: string, limit = MERGED_PR_LIMIT): Promise<MergedChecklistPr[]> => {
+    const search = `merged:>=${lower}${upper ? ` merged:<${upper}` : ''}`;
+    calls++;
+    const r = await run('gh', ['pr', 'list', '--state', 'merged', '--search', search, '--limit', String(limit), '--json', 'number,title,body,mergedAt'], cwd);
+    if (r.status !== 0) throw new Error(`병합 PR 조회(gh) 실패 rc=${r.status}: ${(r.stderr || r.stdout).trim().slice(0, 400)}`);
+    const page = JSON.parse(r.stdout.trim()) as MergedChecklistPr[];
+    if (!Array.isArray(page)) throw new Error('병합 PR 조회(gh): 배열이 아니다');
+    return page;
+  };
+  const first = await fetch(since);
+  if (first.length < MERGED_PR_LIMIT) return { prs: first, truncated: false, calls };
+  // Bounded pool: at most `concurrency` gh processes at once; a failure stops new calls and rejects.
+  let active = 0;
+  let failed: unknown;
+  const waiting: Array<() => void> = [];
+  const limited = async <T>(task: () => Promise<T>): Promise<T> => {
+    while (active >= Math.max(1, concurrency) && failed === undefined) await new Promise<void>((resolve) => waiting.push(resolve));
+    if (failed !== undefined) throw failed;
+    active++;
+    try { return await task(); }
+    catch (error) { failed ??= error; throw error; }
+    finally { active--; if (failed !== undefined) for (const wake of waiting.splice(0)) wake(); else waiting.shift()?.(); }
+  };
+  let truncated = false;
+  const visit = async (start: number, end: number): Promise<MergedChecklistPr[]> => {
+    const from = new Date(start).toISOString();
+    const to = new Date(end).toISOString();
+    const page = await limited(() => fetch(from, to));
+    if (page.length < MERGED_PR_LIMIT) return page;
+    if (end - start <= 1000) {
+      // The second-precision search cannot be subdivided; probe one extra row to distinguish exactly 400 from a real truncation.
+      const probe = await limited(() => fetch(from, to, MERGED_PR_LIMIT + 1));
+      if (probe.length > MERGED_PR_LIMIT) truncated = true;
+      return probe.slice(0, MERGED_PR_LIMIT);
+    }
+    const middle = start + Math.floor((end - start) / 2000) * 1000;
+    const [left, right] = await Promise.all([visit(start, middle), visit(middle, end)]);
+    return [...left, ...right];
+  };
+  const lower = Date.parse(`${since}T00:00:00Z`);
+  const upper = Math.max(lower + 1000, Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 1));
+  const windows: Array<[number, number]> = [];
+  for (let start = lower; start < upper; start += DAY_MS) windows.push([start, Math.min(start + DAY_MS, upper)]);
+  const settled = await Promise.allSettled(windows.map(([start, end]) => visit(start, end)));
+  const rejected = settled.find((result): result is PromiseRejectedResult => result.status === 'rejected');
+  if (rejected) throw failed ?? rejected.reason;
+  // Chronological window order, first occurrence wins — the same de-duplication as before.
+  const unique = new Map<number, MergedChecklistPr>();
+  for (const result of settled) for (const pr of (result as PromiseFulfilledResult<MergedChecklistPr[]>).value) if (!unique.has(pr.number)) unique.set(pr.number, pr);
+  return { prs: [...unique.values()], truncated, calls };
+}

package/src/release-loop/light-rc.ts

@@ -209,6 +209,7 @@ export async function runLightRc(version: string, opts: LightRcOptions = {}, dep
   };
   const captured: Buffer[] = [];
   const rc = await (deps.dispatch ?? dispatchHeavyCheck)({
+    // Keep the self-gate contract: an unavailable remote leaves this release check unmeasured; do not start a heavy gate locally.
     tool: 'self-gate', repo: cwd, installPwa: true, refs: [base], json: true, commit: measuredCommit,
     // The host re-runs this command with --local (and ELANOUS_GATE_REMOTE_CHILD=1), so it never recurses.
     remoteArgv: (sha) => ['bun', 'bin/elanous.mjs', 'release', 'light-rc', '--version', version, '--base', sha(base), '--head', measuredCommit, '--shards', String(shards), ...(opts.fixedShardDistribution ? ['--fixed-shard-distribution'] : []), '--local', '--json', ...(opts.rehearsalTui ? ['--rehearsal-tui'] : [])],

package/src/release-loop/rehearsal.ts

@@ -15,6 +15,7 @@ import { LIGHT_RC_UNKNOWN_HOST, runLightRc, type LightRcResult } from './light-r
 import { planRehearsalShards, type RehearsalShardPlan, type RehearsalShardPlanDeps } from './rehearsal-shard-plan.js';
 import { listSchedules, type ReleaseSchedule } from './release-schedule.js';
 import { SPAWN_SYNC_MAX_BUFFER } from '../util/spawn-sync-output.js';
+import { hardRehearsalGateArgs } from '../../scripts/release-loop/gate-radius-live.js';
 
 export type StepId = 'hard-mid' | 'rc-7h' | 'hard-5h' | 'rc-150m';
 export type RehearsalOutcome = 'ok' | 'regression' | 'unmeasured' | 'error' | 'no-checkout' | 'checkout-dirty' | 'superseded' | 'interrupted';
@@ -200,8 +201,7 @@ async function runHardGate(version: string, checkout: string, sha: string, ledge
   mkdirSync(dirname(logPath), { recursive: true });
   const run = (() => {
     const log = openSync(logPath, 'wx', 0o600);
-    try { return spawnSync('bun', ['scripts/release-loop/gate-node.ts', '--commit', sha, '--version', version,
-      '--baseline-version', previous, '--executor', 'pod', '--pod-pool', pool, '--pod-shards', '12', '--json'], {
+    try { return spawnSync('bun', hardRehearsalGateArgs(version, runId, sha, previous, pool), {
       cwd: checkout, encoding: 'utf8', stdio: ['ignore', log, log], timeout: 4 * 60 * 60_000,
       env: { ...process.env, ELANOUS_STATE_DIR: ledgerRoot, ELANOUS_STATE_DIR_SOURCE: stateDirSourceForChild(ledgerRoot) },
     }); } finally { closeSync(log); }

package/src/repl/index.ts

@@ -47,6 +47,46 @@ import { buildReplayTurnsFromSession } from './replay.js';
 import type { LLMToolSpec, ContentBlock } from '../llm.js';
 import { inspectActiveProvider } from '../provider-summary.js';
 import { parse as parseYaml } from 'yaml';
+import type { PendingTaskNotification } from '../agent/task-notification.js';
+import { dispatchReplMessageTool, isReplMessageTool } from './ops-msg-bridge.js';
+import { buildSeatBootSystemMessages, type SeatBootDeps } from '../dashboard/seat-boot-preamble.js';
+
+/** Private side channel for the next TUI. Ordinary REPL JSONL stdout is unchanged. */
+const NEXT_TUI_BG_PREFIX = 'ELANOUS_TUI_BG_STATUS\t';
+
+export function createNextTuiBackgroundBridge(sessionId: string, bufferedCount: () => number) {
+  if (process.env.ELANOUS_NEXT_TUI_BG_STATUS !== '1') return null;
+  const { globalAgentRegistry } = require('../agent/registry.js') as typeof import('../agent/registry.js');
+  const { globalTaskNotificationQueue } = require('../agent/task-notification.js') as typeof import('../agent/task-notification.js');
+  const unregisteredPromises = new Set<string>();
+  let last = '';
+  const emit = () => {
+    const tasks = globalAgentRegistry.list();
+    for (const task of tasks) unregisteredPromises.delete(task.id);
+    const running = tasks.filter((task) => task.background && (task.state === 'pending' || task.state === 'running')).length;
+    const frame = JSON.stringify({ sessionId, promised: unregisteredPromises.size > 0, running, pending: globalTaskNotificationQueue.size + bufferedCount() });
+    if (frame === last) return;
+    last = frame;
+    process.stderr.write(`${NEXT_TUI_BG_PREFIX}${frame}\n`);
+  };
+  const done = globalAgentRegistry.onTaskDone(emit);
+  const timer = setInterval(emit, 250);
+  timer.unref();
+  emit();
+  return {
+    beginTurn() { emit(); },
+    observeToolResult(name: string, args: Record<string, unknown>, result: unknown) {
+      if (name !== 'Agent' || args.run_in_background !== true) return;
+      if (!result || typeof result !== 'object') return;
+      const spawned = result as { taskId?: unknown; background?: unknown };
+      if (spawned.background !== true || typeof spawned.taskId !== 'string') return;
+      unregisteredPromises.add(spawned.taskId);
+      emit();
+    },
+    emit,
+    dispose() { clearInterval(timer); done.dispose(); },
+  };
+}
 
 /** REPL public entry — wires whichever input source the caller chose
  *  to the shared turn dispatcher. The CLI command (in src/index.ts)
@@ -141,6 +181,11 @@ function buildReplTools(): {
   })) {
     specs.push(spec);
   }
+  // The ops ledger is a runtime family, so the native-only catalog above
+  // cannot advertise it. Keep the REPL surface limited to seat mail.
+  const ledger = require('../skills/tools/ops-ledger.js') as typeof import('../skills/tools/ops-ledger.js');
+  const ask = require('../skills/tools/msg-ask.js') as typeof import('../skills/tools/msg-ask.js');
+  specs.push(ledger.buildMsgListTool(), ledger.buildMsgPostTool(), ask.buildMsgAskTool(), ledger.buildMsgAckTool());
   const bashMod = require('../skills/tools/index.js') as typeof import('../skills/tools/index.js');
   specs.push(bashMod.buildBashTool());
   dispatchByName.set('Bash', async (args) => bashMod.dispatchBash(args, { cwd: process.cwd() }));
@@ -149,6 +194,7 @@ function buildReplTools(): {
     try {
       const direct = dispatchByName.get(name);
       if (direct) return await direct(args);
+      if (isReplMessageTool(name)) return await dispatchReplMessageTool(name, args);
       return await sr.dispatchSessionRuntimeTool(name, args, {
         signal: undefined,
         userText: '',
@@ -192,6 +238,59 @@ function buildAgentSystemPrompt(
   }
 }
 
+/**
+ * 새 TUI REPL 의 시스템 프롬프트 «한 곳» — 범용 preamble ⊕ 자리 부트 카드(TUI-SESSION-BOOT).
+ *
+ * 새 TUI(`src/tui/entry.ts` → `src/tui-client/local-chat-turn.ts`)는 `elanous repl --json --stdin-jsonl`
+ * 자식으로 턴을 돌린다. 그래서 legacy 대시보드의 `buildDashboardTurnPreamble` 부트 경로는 지나지 않고
+ * «여기»만 지난다 — 자리 역할·미읽음 수를 첫 턴의 모델 입력에 싣는 자리도 여기 하나뿐이다.
+ *
+ * 카드는 `dashboard/seat-boot-preamble.ts` 의 `buildSeatBootSystemMessages` 를 그대로 쓴다(새 주입 로직 없음).
+ * 자리 판정이 서면 카드 한 장(대화마다 한 번 만든 같은 문면) · 자리가 아니면 빈 배열이라 주입 0건이다.
+ * 도구 표면이 꺼져 있으면(`enabledToolNames === undefined`) 종전처럼 범용 preamble 은 빠지고 카드만 남는다.
+ */
+export function buildReplSystemPrompt(ctx: {
+  cfg: UserConfig;
+  /** 도구 표면이 꺼져 있으면 undefined — 그때도 자리 부트 카드는 실린다. */
+  enabledToolNames: readonly string[] | undefined;
+  cwd: string;
+  sessionId?: string | undefined;
+  /** 시험·임베디드 호출부용 시임 — 기본은 실제 홈·msg 원장·process.env. */
+  seatBootDeps?: SeatBootDeps | undefined;
+}): string | undefined {
+  const base = ctx.enabledToolNames === undefined
+    ? undefined
+    : buildAgentSystemPrompt(ctx.cfg, ctx.enabledToolNames);
+  const card = buildSeatBootCardText(ctx);
+  if (card.length === 0) return base;
+  return base === undefined || base.length === 0 ? card : `${base}\n\n${card}`;
+}
+
+/** 자리 부트 카드 문면(system 메시지 0~1개를 이어 붙인 것). 자리가 아니면 ''. */
+function buildSeatBootCardText(ctx: {
+  cwd: string;
+  sessionId?: string | undefined;
+  seatBootDeps?: SeatBootDeps | undefined;
+}): string {
+  try {
+    return buildSeatBootSystemMessages(
+      { cwd: ctx.cwd, ...(ctx.sessionId !== undefined ? { sessionId: ctx.sessionId } : {}) },
+      ctx.seatBootDeps ?? {},
+    )
+      .map((message) => (typeof message.content === 'string' ? message.content : ''))
+      .filter((text) => text.length > 0)
+      .join('\n\n');
+  } catch (error) {
+    // 카드 오류가 턴을 막지는 않지만, 조용히 자리 문맥을 잃지 않도록 실패를 기록한다.
+    debug.log('dashboard.seat-boot', 'card-error', {
+      cwd: ctx.cwd,
+      sessionId: ctx.sessionId,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return '';
+  }
+}
+
 function loadAttachment(rawPath: string, baseDir: string): PendingAttachment | null {
   const resolved = isAbsolute(rawPath) ? rawPath : resolvePath(baseDir, rawPath);
   if (!existsSync(resolved)) {
@@ -224,10 +323,12 @@ async function runOneTurn(
   tools: ReturnType<typeof buildReplTools> | undefined,
   systemPrompt: string | undefined,
   jsonOutput: boolean,
+  nextTuiDelivery?: { pending: PendingTaskNotification[] },
+  onJsonDelta?: (delta: string) => void,
 ): Promise<{ reply: string; provider: string; model: string | null; durationMs: number; logPath: string | null }> {
   const startedAt = Date.now();
   const replyChunks: string[] = [];
-  const userImages = pendingAttachments.length > 0 ? pendingAttachments.map(a => a.block) : undefined;
+  const userImages = pendingAttachments.length > 0 ? pendingAttachments.map(a => a.block) : [];
   if (!jsonOutput) {
     process.stdout.write('  ');
   }
@@ -238,14 +339,29 @@ async function runOneTurn(
     const { applyToolPolicy } = require('../tool-runtime/tool-policy.js') as typeof import('../tool-runtime/tool-policy.js');
     replToolSpecs = applyToolPolicy(replToolSpecs, { deny: cfg.chat.toolDeny }) ?? replToolSpecs;
   }
+  // The classic dashboard has its own turn preamble. The next TUI's sticky
+  // REPL must deliver this child's completed tasks on the next parent turn.
+  let nextTuiNotifications = '';
+  if (nextTuiDelivery) {
+    const { globalTaskNotificationQueue, renderTaskNotificationsXml } =
+      require('../agent/task-notification.js') as typeof import('../agent/task-notification.js');
+    nextTuiDelivery.pending.push(...globalTaskNotificationQueue.drain());
+    nextTuiNotifications = renderTaskNotificationsXml(nextTuiDelivery.pending);
+  }
+  // Completion output is untrusted task data. Carry it as a user-role content
+  // block for this call, leaving the human prompt and system prompt intact.
+  if (nextTuiNotifications) userImages.unshift({ type: 'text', text: nextTuiNotifications });
   const result = await runTurn({
     userConfig: cfg,
     sessionId,
     userText,
     systemPrompt,
-    userImages,
+    userImages: userImages.length > 0 ? userImages : undefined,
     onDelta: (d) => {
-      if (jsonOutput) replyChunks.push(d);
+      if (jsonOutput) {
+        replyChunks.push(d);
+        onJsonDelta?.(d);
+      }
       else process.stdout.write(d);
     },
     tools: replToolSpecs,
@@ -272,6 +388,8 @@ async function runOneTurn(
       }
     },
   });
+  // A failed turn keeps the buffered notifications for the next JSONL prompt.
+  nextTuiDelivery?.pending.splice(0);
   const reply = jsonOutput ? replyChunks.join('') : '';
   const logPath = (() => {
     try {
@@ -477,10 +595,24 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
   }
   const sessionIdRef = { current: session.id };
 
-  const tools = opts.enableTools ? buildReplTools() : undefined;
-  const systemPrompt = tools
-    ? buildAgentSystemPrompt(cfg, tools.specs.map(s => s.name))
-    : undefined;
+  const nextTuiDelivery = process.env.ELANOUS_NEXT_TUI_BG_STATUS === '1'
+    ? { pending: [] as PendingTaskNotification[] } : undefined;
+  const backgroundBridge = createNextTuiBackgroundBridge(session.id, () => nextTuiDelivery?.pending.length ?? 0);
+  const baseTools = opts.enableTools ? buildReplTools() : undefined;
+  const tools = baseTools && backgroundBridge ? {
+    ...baseTools,
+    dispatch: async (name: string, args: Record<string, unknown>) => {
+      const result = await baseTools.dispatch(name, args);
+      backgroundBridge.observeToolResult(name, args, result);
+      return result;
+    },
+  } : baseTools;
+  const systemPrompt = buildReplSystemPrompt({
+    cfg,
+    enabledToolNames: tools?.specs.map(s => s.name),
+    cwd: process.cwd(),
+    sessionId: session.id,
+  });
   const pendingAttachments: PendingAttachment[] = [];
 
   if (!opts.jsonOutput) {
@@ -548,6 +680,7 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
         ui.header(`turn ${turnId}${turn.rotate ? ` · ${turn.rotate}` : ''}`);
         console.log(`  ❯ ${turn.prompt}`);
       }
+      backgroundBridge?.beginTurn();
       const result = await runOneTurn(
         cfg,
         sessionIdRef.current,
@@ -556,7 +689,9 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
         tools,
         systemPrompt,
         opts.jsonOutput,
+        nextTuiDelivery,
       );
+      backgroundBridge?.emit();
       const failures = applyAsserts(result.reply, turn.asserts, sc.defaults?.asserts, turnId);
       if (opts.jsonOutput) {
         const out = {
@@ -577,7 +712,10 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
       }
       assertFailures += failures.length;
     }
-    if (opts.exitAfterScenario) return assertFailures > 0 ? 2 : 0;
+    if (opts.exitAfterScenario) {
+      backgroundBridge?.dispose();
+      return assertFailures > 0 ? 2 : 0;
+    }
   } // end if (scriptedScenario)
 
   // Phase B — interactive (TTY) or JSONL stdin (pipe).
@@ -608,15 +746,29 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
         const att = loadAttachment(ap, process.cwd());
         if (att) turnAttachments.push(att);
       }
-      const result = await runOneTurn(
-        cfg,
-        sessionIdRef.current,
-        turn.prompt,
-        turnAttachments,
-        tools,
-        systemPrompt,
-        true, // JSONL stream → always JSON output
-      );
+      backgroundBridge?.beginTurn();
+      let result: Awaited<ReturnType<typeof runOneTurn>>;
+      try {
+        result = await runOneTurn(
+          cfg,
+          sessionIdRef.current,
+          turn.prompt,
+          turnAttachments,
+          tools,
+          systemPrompt,
+          true, // JSONL stream → always JSON output
+          nextTuiDelivery,
+          process.env.ELANOUS_NEXT_TUI_STREAM === '1' && typeof turn.id === 'string'
+            ? (delta) => { process.stdout.write(`${JSON.stringify({ event: 'delta', turnId: turn.id, text: delta })}\n`); }
+            : undefined,
+        );
+      } catch (error) {
+        if (!backgroundBridge) throw error;
+        backgroundBridge.emit();
+        console.log(JSON.stringify({ sessionId: sessionIdRef.current, error: error instanceof Error ? error.message : String(error) }));
+        continue;
+      }
+      backgroundBridge?.emit();
       const failures = applyAsserts(result.reply, turn.asserts, undefined, turn.id ?? 't?');
       const out = {
         turnId: turn.id ?? null,
@@ -630,6 +782,7 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
       };
       console.log(JSON.stringify(out));
     }
+    backgroundBridge?.dispose();
     return 0;
   }
 
@@ -709,6 +862,7 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
     }
     // Ordinary prompt.
     const turnAttachments = pendingAttachments.splice(0);
+    backgroundBridge?.beginTurn();
     await runOneTurn(
       cfg,
       sessionIdRef.current,
@@ -717,10 +871,13 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
       tools,
       systemPrompt,
       opts.jsonOutput,
+      nextTuiDelivery,
     );
+    backgroundBridge?.emit();
     if (exitRequested) break;
     rl.prompt();
   }
+  backgroundBridge?.dispose();
   return 0;
 }
 

package/src/repl/ops-msg-bridge.ts

@@ -0,0 +1,32 @@
+import type { MsgLedgerDeps } from '../skills/tools/ops-ledger.js';
+import type { MsgAskDeps } from '../skills/tools/msg-ask.js';
+
+const MESSAGE_TOOL_NAMES = new Set(['MsgList', 'MsgPost', 'MsgAsk', 'MsgAck']);
+
+/** The next TUI REPL can dispatch only its durable message tools directly.
+ * Other native runtimes keep the REPL's existing unavailable boundary. */
+export function isReplMessageTool(name: string): boolean {
+  return MESSAGE_TOOL_NAMES.has(name);
+}
+
+export async function dispatchReplMessageTool(
+  name: string,
+  args: Record<string, unknown>,
+  deps: { ledger?: MsgLedgerDeps; ask?: MsgAskDeps; signal?: AbortSignal } = {},
+): Promise<Record<string, unknown>> {
+  if (!isReplMessageTool(name)) throw new Error(`not a REPL message tool: ${name}`);
+  const { observeLedgerCall } = await import('../skills/tools/ops-ledger.js');
+  if (name === 'MsgAsk') {
+    const { dispatchMsgAsk } = await import('../skills/tools/msg-ask.js');
+    return observeLedgerCall(name, args,
+      () => dispatchMsgAsk(args, { ...deps.ask, signal: deps.signal ?? deps.ask?.signal }),
+      (a, r) => ({ from: a.from, to: a.to, ...(r ? { id: r.question.id, replied: r.reply !== null } : {}) }));
+  }
+  const { dispatchMsgList, dispatchMsgPost, dispatchMsgAck } = await import('../skills/tools/ops-ledger.js');
+  if (name === 'MsgList') return observeLedgerCall(name, args, () => dispatchMsgList(args, deps.ledger),
+    (a, r) => ({ to: a.to, ...(r ? { count: r.count, after: r.after } : {}) }));
+  if (name === 'MsgPost') return observeLedgerCall(name, args, () => dispatchMsgPost(args, deps.ledger),
+    (a, r) => ({ from: a.from, to: a.to, ...(r ? { id: r.message.id } : {}) }));
+  return observeLedgerCall(name, args, () => dispatchMsgAck(args, deps.ledger),
+    (a, r) => ({ to: a.to, id: a.id, ...(r ? { cursor: r.cursor } : {}) }));
+}

package/src/self-dev/ask-launch-flow.ts

@@ -44,7 +44,7 @@ import {
   type GoalClarificationSelfResolver,
 } from '../self-implement/goal-author-clarification.js';
 import { classifyReauthoredAsk, countMissingAuthoredConstraintMarkers, askGoalTypeDeclaration, declaredGoalType, parseGoalId } from '../self-implement/goal-author.js';
-import { observeFrontNodeEntry } from './graph-front-nodes.js';
+import { observeFrontNodeEntry, observeFrontNodeExit, observeFrontNodeUnit, type AuthorExitOutcome } from './graph-front-nodes.js';
 import { emitDecision } from '../live/detail-switch.js';
 import { decomposeSelfDevGoal, type SelfDevDecomposeOptions, type SelfDevDecomposition } from './decompose.js';
 import { observeDecomposerSelection, readFabricDecomposeConfig, selectFabricDecomposer } from './self-orchestrate-runtime.js';
@@ -392,7 +392,7 @@ export async function recommendLaunchDecomposition(
       ...(input.runId === undefined ? {} : { runId: input.runId }),
       ...(decomposeGoalType === null ? {} : { goalType: decomposeGoalType }),
     });
-    const result = await Promise.race([
+    const result = await observeFrontNodeUnit('decompose', input.runId ?? process.env.ELANOUS_RUN_ID, decomposeGoalType ?? undefined, () => Promise.race([
       deps.decomposeGoal
         ? deps.decomposeGoal(document!)
         : decomposeSelfDevGoal(document!, {
@@ -401,7 +401,7 @@ export async function recommendLaunchDecomposition(
           observation: prelaunchDecompositionObservation(document!),
         }),
       timeout,
-    ]);
+    ]));
     if (result === timedOut) {
       // ⛔ 「시간 초과」를 「못 쟀다」로 뭉개지 않는다 — 분해기는 «아직 답하는 중»이고
       //   그 답은 `prelaunch-decomposition` 이름으로 «따로» 내려앉는다(위 주석).
@@ -886,7 +886,7 @@ export async function runAskLaunchFlow(
   if (launchPreflight === false) return { kind: 'stopped-before-authoring' };
 
   await deps.beforeAuthoring?.();
-  const authorAndPreflight = async (authorAskText: string = input.askText, machineSuggestedTargetPaths: readonly string[] = []): Promise<{
+  const authorAndPreflight = async (authorAskText: string = input.askText, machineSuggestedTargetPaths: readonly string[] = [], attempt = 1): Promise<{
     readonly goalFile: string;
     readonly decision: ReturnType<typeof decideAskPreflight>;
   }> => {
@@ -918,6 +918,12 @@ export async function runAskLaunchFlow(
       })(),
       ...(launchPreflight === undefined ? {} : { launchPreflight }),
       selfResolveClarifications: selfResolveClarifications.value,
+    }).catch((error: unknown) => {
+      // GRAPH-AUTHOR-FAIL-EDGE: 저작기가 던진 자리 = author `fail` 출구. ⛔ 관측만 하고 같은 오류를 그대로 다시 던진다.
+      observeFrontNodeExit({ node: 'author', outcome: 'fail' }, {
+        ...frontObservation, attempt, reason: error instanceof Error ? error.message : String(error),
+      });
+      throw error;
     });
     deps.print(`[ask] 저작됨: ${authored.path}`);
     // AUTHOR-TRACE: the authored goal file can be cleaned up later — keep path ⊕ sha256 ⊕ size in the run ledger and
@@ -1064,16 +1070,47 @@ export async function runAskLaunchFlow(
     return { goalFile, decision };
   };
 
+  // GRAPH-AUTHOR-FAIL-EDGE ① — 저작 «끝»의 결과를 그래프 이름으로 남긴다(관측 · 다음 걸음은 아래 코드가 그대로 정한다).
+  const authorNotGrounded = (decision: ReturnType<typeof decideAskPreflight>): boolean =>
+    decision.result.blockers.length > 0 && decision.result.blockers.every((blocker) => blocker.kind === 'no-target-paths');
+  const observeAuthorExit = (
+    attempt: number,
+    result: { readonly goalFile: string; readonly decision: ReturnType<typeof decideAskPreflight> },
+    outcome: AuthorExitOutcome,
+    taken?: { readonly node: string; readonly reason: string },
+  ): void => {
+    const goalType = input.goalType ?? declaredGoalType(input.askText);
+    observeFrontNodeExit({ node: 'author', outcome }, {
+      attempt,
+      goalFile: result.goalFile,
+      ...(input.runId === undefined ? {} : { runId: input.runId }),
+      ...(goalType === null ? {} : { goalType }),
+      ...(taken === undefined ? {} : { taken: taken.node, reason: taken.reason }),
+      ...(outcome === 'not-grounded' ? { blockers: result.decision.result.blockers } : {}),
+    });
+  };
+
   let authored = await authorAndPreflight();
   let reauthored = false;
   const retryableNoTargetPaths = !input.forceRequested
     && !authored.decision.shouldLaunch
     && authored.decision.result.blockers.length > 0
     && authored.decision.result.blockers.every((blocker) => blocker.kind === 'no-target-paths');
+  if (authorNotGrounded(authored.decision)) {
+    // 재시도 대상이면 그래프 답(re-ground) 그대로 · --force 로 재시도를 안 하면 코드가 간 곳을 실제 걸음으로 남긴다.
+    observeAuthorExit(1, authored, 'not-grounded', retryableNoTargetPaths ? undefined : {
+      node: authored.decision.shouldLaunch ? 'plan' : 'needs-human', reason: 'force-requested · no auto re-author',
+    });
+  } else {
+    observeAuthorExit(1, authored, 'ok');
+  }
   if (retryableNoTargetPaths) {
     const first = authored;
     reauthored = true;
     deps.print('[ask] ⑴ ⚠️ 대상 경로를 못 찾아 자동 재저작 한 번을 시도한다');
+    observeFrontNodeExit({ node: 're-ground', outcome: 'retry' }, {
+      attempt: 1, goalFile: first.goalFile, ...(input.runId === undefined ? {} : { runId: input.runId }),
+    });
     let candidates: ReturnType<typeof findAskPathCandidates> = { tokens: [], paths: [] };
     if (parseAskTargetPathHintsResult(input.askText).labelMissing) {
       try {
@@ -1107,7 +1144,9 @@ export async function runAskLaunchFlow(
     recordPodAuthoring('ask-auto-reauthor', { candidatePathCount: candidates.paths.length, firstPathCount: first.decision.result.paths.length, outcome: 'started' });
     authored = await authorAndPreflight(selectedPaths.length > 0
       ? `대상 경로: ${selectedPaths.join(' · ')}\n${input.askText}`
-      : input.askText, selectedPaths);
+      : input.askText, selectedPaths, 2);
+    // 두 번째 not-grounded 는 re-ground 예산(max_visits 1)을 넘어 needs-human(근거 카드)으로 — 판정은 observeFrontNodeExit 가 선언에서 읽는다.
+    observeAuthorExit(2, authored, !authored.decision.shouldLaunch && authorNotGrounded(authored.decision) ? 'not-grounded' : 're-authored');
     deps.log('ask-auto-reauthor', {
       candidatePathCount: candidates.paths.length,
       firstGoalFile: first.goalFile,

package/src/self-dev/cli-help-text.ts

@@ -0,0 +1,17 @@
+import { CLI_HARNESS_RUN_ENTRANCE, describeEntranceCommand } from './entrance-registry.js';
+
+/** Shared help text stays independent of the CLI execution graphs.
+ * The deprecated harness help comes from the entrance registry so its
+ * destination and status cannot drift from the declared entrance. */
+export const HARNESS_RUN_REPLACEMENT = 'elanous harness say <objective>';
+export const HARNESS_RUN_DEPRECATION_HELP = describeEntranceCommand(
+  CLI_HARNESS_RUN_ENTRANCE,
+  HARNESS_RUN_REPLACEMENT,
+  '이 입구는 더 이상 실행되지 않습니다.',
+).trimEnd();
+
+/** `dev --plan` help points to this one replacement. */
+export const DEV_PLAN_REPLACEMENT = 'elanous harness say';
+export function formatDevPlanOptionHelp(replacement: string = DEV_PLAN_REPLACEMENT): string {
+  return `은퇴한 staged 하니스 옵션 — 지정하면 명시적으로 거부됨 · 대응 문 \`${replacement}\``;
+}