elanous 0.2.31 → 0.2.32

package/src/cli/pty-takeover-cli.ts

@@ -5,7 +5,7 @@ import { dirname, join, resolve } from 'node:path';
 import { runGitCommand } from '../git-fs/runner.js';
 import { debug } from '../debug/log.js';
 import { getPty, listPty, renamePty, requestPtyTakeover } from '../pty-shell/registry.js';
-import { describePtyRunState, readCheckoutHead, readCurrentInstallRecord, shortSha, type InstalledRecord, type PtyRunStateView } from '../pty-shell/tui-run-state.js';
+import { describePtyRunState, describeTurnCell, formatTurnCell, ptyTurnViewOfRow, readCheckoutHead, readCurrentInstallRecord, shortSha, UNKNOWN_TURN_CELL, type InstalledRecord, type PtyRunStateView, type PtyTurnCell } from '../pty-shell/tui-run-state.js';
 import { getPtyManifest, isProcessAlive, listPtyManifest, listPtyManifestRows, listPtyManifestRowsAt, ptyManifestDbPath, readPtyManifestFrame, reapDeadPtyManifest, reapDeadPtyManifestAt, reapStalePtyManifest, removePtyManifest, PTY_MANIFEST_CLOSED_TTL_MS, PTY_MANIFEST_STALE_MS, type PtyManifestExternalReapResult, type PtyManifestRow } from '../pty-shell/pty-manifest.js';
 import { readPtyEventsAfter, readPtyEventsAfterAt, type PtyEventLogReadResult, type PtyEventRow } from '../pty-shell/pty-event-log.js';
 import { resolvePtyRef, type PtyRefItem } from '../pty-shell/pty-ref.js';
@@ -27,7 +27,7 @@ import { isRunStatus } from '../self-implement/run-status-mapping.js';
 import { terminalTreeLabel } from '../pty-shell/terminal-tree.js';
 import { RemotesStore } from './remotes.js';
 import { bookmarkAttachDefaults } from './remote-resolve.js';
-import { classifyFrameState, type FrameState } from '../capture/frame-state-detect.js';
+import { classifyFrameState, reconcileFrameStateWithTurn, type FrameState } from '../capture/frame-state-detect.js';
 import { installMissingTool, waitForPtyCompletion, type ToolInstallDeps, type ToolInstallResult } from '../agent-mission/tool-install.js';
 
 interface PtyTakeoverCommandResult { readonly exitCode: 0 | 1 | 2; readonly message: string; readonly notice?: string; }
@@ -1441,6 +1441,10 @@ interface PtyListJsonRow extends PtyWebAddress {
    *    그 값은 거의 항상 몇 초이고 「얼마나 오래 있었나」를 못 답한다.
    *  ⚠️ `startedAt` 이 0(미상)이면 이 칸을 «비운다» — 「0분」과 「못 잼」은 다른 값이다. */
   readonly ageMs?: number;
+  /** ⭐ H10 — TUI 가 스스로 적은 턴(화면 추정 아님) ⊕ 그 상태 경과 초. 턴 기록 없는 행·원격 행은 `state:'unknown'`. */
+  readonly turn: PtyTurnCell;
+  /** ⭐ H10 — 기동 판(실행판 sha) ⊕ 낡음. 판 기록 없는 행·판독 실패는 null. */
+  readonly build: { readonly version: string; readonly sha: string; readonly source: string; readonly stale: boolean | null; readonly staleReason: string } | null;
 }
 
 function defaultRunTermination(runId: string, opts: { includeTest: boolean }, log: (event: string, data: Record<string, unknown>) => void): RunTermination {
@@ -1457,7 +1461,7 @@ function ptyAgeField(startedAt: number, now: number): { ageMs?: number } {
   return ageMs >= 0 ? { ageMs } : {};
 }
 
-function ptyListJsonRow(row: PtyManifestRow, instance: string, sourceRoot: PtyManifestSourceRoot, deps: PtyTakeoverCommandDeps, opts: { includeTest: boolean }, pwa?: NexusPwaResolution): PtyListJsonRow {
+function ptyListJsonRow(row: PtyManifestRow, instance: string, sourceRoot: PtyManifestSourceRoot, deps: PtyTakeoverCommandDeps, opts: { includeTest: boolean }, pwa?: NexusPwaResolution, installed: () => InstalledRecord = () => deps.readInstalledBuild?.() ?? {}): PtyListJsonRow {
   // ⛔⭐ 리뷰 should-fix (2026-08-19): 기준 시각을 «한 번만» 읽는다.
   //   종전엔 proof(updatedAgeMs)와 ageMs 가 각각 `deps.now?.()` 를 불러, 한 행의 두 값이
   //   ***«다른 순간»을 가리킬 수 있었다***. 두 값을 나란히 놓고 판정하는 것이 이 축의 용도인데
@@ -1498,9 +1502,56 @@ function ptyListJsonRow(row: PtyManifestRow, instance: string, sourceRoot: PtyMa
     runTerminationSource: resolution?.source ?? 'unknown',
     runStoreIo: resolution?.runStoreIo ?? 'not-checked',
     ownerRunUsage,
+    ...ptyListRunFields(row, deps, observedAt, installed),
   };
 }
 
+/** `pty list --json` 의 턴·판 칸 — ⛔ 키는 «언제나» 싣는다(값으로만 갈린다 · 모르면 unknown/null).
+ *  ⭐ 턴은 행의 자기보고 값만 읽는다 — 판 판독(설치본·git)이 실패해도 기록된 턴은 버리지 않는다. */
+function ptyListRunFields(row: PtyManifestRow, deps: PtyTakeoverCommandDeps, observedAt: number, installed: () => InstalledRecord): Pick<PtyListJsonRow, 'turn' | 'build'> {
+  const turn = describeTurnCell(ptyTurnViewOfRow(row), observedAt);
+  try {
+    if (!row.build) return { turn, build: null };
+    // 판독 예외 계약: 판 sha 는 기록값이라 그대로 두고 낡음만 «모른다»(stale=null · unknown) ⊕ `list-build-read-failed` 관측.
+    //   그 밖의 뜻밖 예외는 판을 null 로(아래 catch) — 어느 쪽이든 기록된 턴은 버리지 않는다.
+    const run = describePtyRunState(row, {
+      readInstalled: installed,
+      readCheckoutHead: (codeRoot) => {
+        try { return deps.readCheckoutHead?.(codeRoot); } catch (error) {
+          deps.log('list-build-read-failed', { ptyId: row.id, source: 'checkout-head', error: error instanceof Error ? error.message : String(error) });
+          return undefined;
+        }
+      },
+    });
+    return { turn, build: run.build ? { version: run.build.version, sha: run.build.sha, source: run.build.source, stale: run.stale, staleReason: run.staleReason } : null };
+  } catch (error) {
+    deps.log('list-build-read-failed', { ptyId: row.id, source: 'describe', error: error instanceof Error ? error.message : String(error) });
+    return { turn, build: null };
+  }
+}
+
+/** 목록 한 번에 설치본 기록을 «한 번만» 읽는다. 예외는 «모른다»({}) ⊕ `list-build-read-failed`(목록당 한 줄) — 목록·턴 칸을 깨지 않는다. */
+function listInstalledReader(deps: PtyTakeoverCommandDeps): () => InstalledRecord {
+  let once: InstalledRecord | undefined;
+  return () => {
+    if (once === undefined) {
+      try { once = deps.readInstalledBuild?.() ?? {}; } catch (error) {
+        once = {};
+        deps.log('list-build-read-failed', { source: 'installed', error: error instanceof Error ? error.message : String(error) });
+      }
+    }
+    return once;
+  };
+}
+
+/** 글 표의 판 칸 — 판독이 어떻게 실패해도 그 행(과 뒤따르는 턴 칸)을 깨지 않는다: 판 칸만 비우고 관측 한 줄. */
+function safeListRunColumn(row: PtyManifestRow | undefined, deps: PtyTakeoverCommandDeps, installed: () => InstalledRecord): string {
+  try { return formatListRunColumn(row, deps, installed); } catch (error) {
+    deps.log('list-build-read-failed', { ptyId: row?.id ?? '', source: 'run-column', error: error instanceof Error ? error.message : String(error) });
+    return '';
+  }
+}
+
 function federatedManifestTargets(
   targets: readonly { name: string; dbPath: string }[],
   currentDbPath: string,
@@ -1771,6 +1822,9 @@ function remotePtyListJsonRow(row: RemoteTerminalListItem): PtyListJsonRow {
     runTerminationSource: 'unknown',
     runStoreIo: 'not-checked',
     ownerRunUsage: 'unknown',
+    // 원격 응답은 턴·판을 안 싣는다 — «모른다»로(로컬과 같은 키).
+    turn: UNKNOWN_TURN_CELL,
+    build: null,
   };
 }
 
@@ -1893,9 +1947,11 @@ function runPtyListJson(deps: PtyTakeoverCommandDeps, opts: { all?: boolean; inc
   }
   // Keep the existing list contract: rows whose selected PTY/owner process is dead are not listable.
   const pwa = deps.resolveNexusPwa?.();
+  // 설치본 기록은 목록 한 번에 한 번만 읽는다(행마다 다시 읽으면 I/O 와 행 사이 불일치). 실패는 «모른다» ⊕ 관측 한 줄.
+  const installed = listInstalledReader(deps);
   const payload = rows
     .filter(({ row }) => row.alive && (row.ptyPid > 0 ? deps.isProcessAlive!(row.ptyPid) : deps.isProcessAlive!(row.ownerPid)))
-    .map(({ row, instance, sourceRoot }) => ptyListJsonRow(row, instance, sourceRoot, deps, { includeTest: opts.includeTest === true }, pwa));
+    .map(({ row, instance, sourceRoot }) => ptyListJsonRow(row, instance, sourceRoot, deps, { includeTest: opts.includeTest === true }, pwa, installed));
   deps.log('list', { count: payload.length, federated: opts.all === true, includeTest: opts.includeTest === true, json: true });
   return { exitCode: 0, message: JSON.stringify(payload, null, 2), ...(payload.length === 0 ? { notice: ptyListEmptyNotice(opts) } : {}) };
 }
@@ -1966,12 +2022,15 @@ export function runPtyList(
   const pwa = deps.resolveNexusPwa?.();
   // 판 칸(맨 끝) — 설치본 기록은 목록 한 번에 한 번만 읽는다.
   //    설치본 판독기가 없는 구성(시험 deps)은 이 칸을 안 낸다 — 기계마다 다른 값이 목록에 새지 않게.
-  const manifestRowById = new Map((deps.readInstalledBuild ? deps.listManifestRows?.() ?? [] : []).map((row) => [row.id, row] as const));
-  let installedOnce: InstalledRecord | undefined;
-  const installed = (): InstalledRecord => (installedOnce ??= deps.readInstalledBuild?.() ?? {});
+  //    ⭐ H10 턴 칸은 판독기와 «무관하게» TUI ref 마다 낸다(기계마다 다른 값이 아니다) — 행을 못 얻으면 `turn=?`.
+  let manifestRows: readonly PtyManifestRow[] = [];
+  try { manifestRows = deps.listManifestRows?.() ?? []; } catch { manifestRows = []; }
+  const manifestRowById = new Map(manifestRows.map((row) => [row.id, row] as const));
+  const listedAt = deps.now?.() ?? Date.now();
+  const installed = listInstalledReader(deps);
   const rendered = refs.map((ref) => {
     const provenance = (deps.resolveWorktreeProvenance ?? resolvePtyWorktreeProvenance)(ref.workdir);
-    return { known: ptyPurposeKnown(provenance, ref.purpose), line: `${ref.id}\t${ref.kind}\t${ref.nickname ?? '-'}\t${ref.source}\t${ref.alive ? 'alive' : 'dead'}\t${ref.mode ?? '?'}\t${ref.workdir ?? '-'}\t${ref.runId ?? '-'}${ownerRunUsageById.has(ref.id) ? `\t${ownerRunUsageById.get(ref.id)}` : ''}\t${formatTerminalOrigin(ref)}\t${formatPtyPurpose(provenance, ref.purpose)}${pwa ? `\t${formatPtyWebAddress(ptyWebAddress(ref.id, pwa))}` : ''}${formatListRunColumn(manifestRowById.get(ref.id), deps, installed)}` };
+    return { known: ptyPurposeKnown(provenance, ref.purpose), line: `${ref.id}\t${ref.kind}\t${ref.nickname ?? '-'}\t${ref.source}\t${ref.alive ? 'alive' : 'dead'}\t${ref.mode ?? '?'}\t${ref.workdir ?? '-'}\t${ref.runId ?? '-'}${ownerRunUsageById.has(ref.id) ? `\t${ownerRunUsageById.get(ref.id)}` : ''}\t${formatTerminalOrigin(ref)}\t${formatPtyPurpose(provenance, ref.purpose)}${pwa ? `\t${formatPtyWebAddress(ptyWebAddress(ref.id, pwa))}` : ''}${safeListRunColumn(manifestRowById.get(ref.id), deps, installed)}${formatListTurnColumn(ref.kind, manifestRowById.get(ref.id), listedAt)}` };
   });
   return {
     exitCode: 0,
@@ -2067,24 +2126,30 @@ export async function runPtyState(ref: string, deps: PtyTakeoverCommandDeps = li
     if (run.turn === 'unknown' && run.build === null) return { exitCode: 1, message: formatSnapshotResult(acquired.id, acquired.control) };
     const screenUnavailable = acquired.control.reason ?? acquired.control.status;
     deps.log('state-screen-unavailable', { ptyId: acquired.id, reason: screenUnavailable, turn: run.turn });
-    return formatPtyStateResult(acquired.id, { state: 'unknown', label: null }, run, deps.now?.() ?? Date.now(), json, screenUnavailable);
+    return formatPtyStateResult(acquired.id, { state: 'unknown', label: null }, run, deps.now?.() ?? Date.now(), json, deps, screenUnavailable);
   }
   const verdict = classifyFrameState(acquired.control.screen ?? '');
   const at = deps.now?.() ?? Date.now();
   if (run.turn === 'unknown' || run.stale === null) deps.log('state-run-unknown', { ptyId: acquired.id, turn: run.turn, staleReason: run.staleReason, hasBuild: run.build !== null });
-  return formatPtyStateResult(acquired.id, { state: verdict.state, label: verdict.matchedLabel }, run, at, json);
+  return formatPtyStateResult(acquired.id, { state: verdict.state, label: verdict.matchedLabel }, run, at, json, deps);
 }
 
-function formatPtyStateResult(id: string, screen: { state: string; label?: string | null }, run: PtyRunStateView, at: number, json: boolean, screenUnavailable?: string): PtyTakeoverCommandResult {
+// ⭐ H10 조각 1 — `state` 는 «하나»다: TUI 가 스스로 적은 턴이 있으면 그것이 바쁜가/한가한가를 정하고(`stateSource=turn`),
+//   화면 추정은 턴을 모를 때·턴과 모순 없는 더 구체적인 상태(blocked·waiting·done)일 때만 쓴다(`stateSource=screen`).
+//   화면 원값은 `screenState`(JSON) · `guess=`(글, 갈렸을 때만)로 남긴다 — 둘이 갈린 순간은 `state-reconciled` 관측.
+function formatPtyStateResult(id: string, screen: { state: FrameState; label?: string | null }, run: PtyRunStateView, at: number, json: boolean, deps: PtyTakeoverCommandDeps, screenUnavailable?: string): PtyTakeoverCommandResult {
+  const reconciled = reconcileFrameStateWithTurn(screen.state, run.turn);
+  if (reconciled.overridden) deps.log('state-reconciled', { ptyId: id, turn: run.turn, screenState: reconciled.screenState, label: screen.label ?? null, state: reconciled.state });
+  const guess = reconciled.screenState !== reconciled.state && !screenUnavailable ? ` guess=${reconciled.screenState}` : '';
   return { exitCode: 0, message: json
     ? JSON.stringify({
-      id, state: screen.state, label: screen.label, at,
+      id, state: reconciled.state, stateSource: reconciled.source, screenState: reconciled.screenState, label: screen.label, at,
       ...(screenUnavailable ? { screenUnavailable } : {}),
       turn: run.turn, ...(run.turnAt !== undefined ? { turnAt: run.turnAt } : {}),
       build: run.build ? { version: run.build.version, sha: run.build.sha, source: run.build.source } : null,
       installed: run.installed, stale: run.stale, staleReason: run.staleReason,
     })
-    : `pty state: ${id} state=${screen.state} label=${screen.label ?? '-'}${screenUnavailable ? ` screen=unavailable(${screenUnavailable})` : ''} turn=${run.turn} build=${formatRunBuild(run)} installed=${shortSha(run.installed)} stale=${run.stale ?? 'unknown'}${run.stale === null ? '' : ` (${run.staleReason})`}` };
+    : `pty state: ${id} state=${reconciled.state} source=${reconciled.source}${guess} label=${screen.label ?? '-'}${screenUnavailable ? ` screen=unavailable(${screenUnavailable})` : ''} turn=${run.turn} build=${formatRunBuild(run)} installed=${shortSha(run.installed)} stale=${run.stale ?? 'unknown'}${run.stale === null ? '' : ` (${run.staleReason})`}` };
 }
 
 function ptyRunStateFor(id: string, deps: PtyTakeoverCommandDeps): PtyRunStateView {
@@ -2103,7 +2168,8 @@ function formatRunBuild(run: PtyRunStateView): string {
 
 /** `pty list` 한 칸 — 판을 적는 행(TUI)만. `run=<sha>` · 낡았으면 `,stale` · 옛 행 추정은 `run=?,stale`. */
 function formatListRunColumn(row: PtyManifestRow | undefined, deps: PtyTakeoverCommandDeps, installed: () => InstalledRecord): string {
-  if (!row || (!row.build && row.kind !== 'tui')) return '';
+  // 설치본 판독기가 없는 구성(시험 deps)은 이 칸을 안 낸다 — 기계마다 다른 값이 목록에 새지 않게.
+  if (!deps.readInstalledBuild || !row || (!row.build && row.kind !== 'tui')) return '';
   const run = describePtyRunState(row, {
     readInstalled: installed,
     ...(deps.readCheckoutHead ? { readCheckoutHead: deps.readCheckoutHead } : {}),
@@ -2112,6 +2178,14 @@ function formatListRunColumn(row: PtyManifestRow | undefined, deps: PtyTakeoverC
   return `\trun=${run.build?.sha ? shortSha(run.build.sha) : '?'}${run.stale === true ? ',stale' : ''}`;
 }
 
+/** ⭐ H10 «턴 칸» — ref 가 TUI 면 «언제나» 낸다: `turn=busy,42s` · `turn=idle,300s` · 행 없음·종류 불일치·기록 없음 `turn=?`.
+ *  OP·TF 가 화면(«Streaming…/완료»)을 긁지 않고 «지금 턴 중인가·얼마나 됐나»를 읽는다. 턴은 자기보고 값만 쓴다(설치본·git 무관). */
+function formatListTurnColumn(refKind: string, row: PtyManifestRow | undefined, now: number): string {
+  if (refKind !== 'tui') return '';
+  if (!row || row.kind !== 'tui') return '\tturn=?';
+  return `\tturn=${formatTurnCell(describeTurnCell(ptyTurnViewOfRow(row), now))}`;
+}
+
 export async function runPtyWait(ref: string, until: string, options: { readonly timeoutMs?: number; readonly pollMs?: number } = {}, deps: PtyTakeoverCommandDeps = liveDeps): Promise<PtyTakeoverCommandResult> {
   if (!WAITABLE_FRAME_STATES.includes(until as Exclude<FrameState, 'unknown'>)) return { exitCode: 2, message: `pty wait: --until must be one of ${WAITABLE_FRAME_STATES.join(', ')} (got ${until})` };
   const target = until as Exclude<FrameState, 'unknown'>;

package/src/cli/sim-cli.ts

@@ -0,0 +1,18 @@
+import type { Command } from 'commander';
+import { runScenarioFile } from '../ux-sim/scenario.js';
+
+export function registerSimCommands(program: Command): void {
+  const sim = program.command('sim').description('격리 시나리오를 실행하고 화면·로그 기대값을 대조한다');
+  sim.command('run <scenario-file>')
+    .description('등록된 UX simulation 시나리오를 test 우주에서 실행한다')
+    .action(async (scenarioFile: string) => {
+      try {
+        const result = await runScenarioFile(scenarioFile);
+        console.log(JSON.stringify(result));
+        if (!result.pass) process.exitCode = 1;
+      } catch (error) {
+        console.error(`sim run: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 2;
+      }
+    });
+}

package/src/context-bus/ops-events.ts

@@ -1,6 +1,7 @@
 import type { Database } from 'bun:sqlite';
 import { debug, redactSecretText } from '../debug/log.js';
 import { openSurfaceEventsDb, recordEvent, surfaceEventsDbPath } from '../domains/surface-events.js';
+import { canonicalSeatId } from '../msg/msg-store.js';
 
 export const OPS_EVENT_KINDS = [
   'land.start', 'land.refused', 'land.merged',
@@ -17,6 +18,8 @@ export interface OpsEventInput {
   text: string;
   /** Optional locator — PR number, checklist cell id, config key, release version. */
   ref?: string;
+  /** Optional seat identity, normalized by the shared message-address registry. */
+  seat?: string;
   /** Optional ISO timestamp; unparseable values are dropped. */
   at?: string;
 }
@@ -47,6 +50,7 @@ export function emitOpsEvent(input: OpsEventInput, deps: OpsEventDeps = {}): str
     const text = oneLine(input.text);
     if (!text) return null;
     const ref = oneLine(input.ref) || null;
+    const seat = typeof input.seat === 'string' && input.seat.trim() ? canonicalSeatId(input.seat) : undefined;
     const at = typeof input.at === 'string' && !Number.isNaN(Date.parse(input.at)) ? input.at : undefined;
     if (!db) {
       // Test runners must never fall through to the user's production memory DB
@@ -61,11 +65,11 @@ export function emitOpsEvent(input: OpsEventInput, deps: OpsEventDeps = {}): str
     return record(db, {
       surface: 'ops', direction: 'outbound', domain: 'elanous', category: 'ops',
       kind: input.kind, text, summary: text.slice(0, 120),
-      refs: JSON.stringify({ kind: input.kind, ref, url: null }),
+      refs: JSON.stringify({ kind: input.kind, ref, url: null, ...(seat ? { seat } : {}) }),
       ...(at ? { ts: at } : {}),
     });
   } catch (error) {
-    try { debug.log('ops.event', 'record-failed', {
+    try { debug.log('context.bus', 'write-failed', {
       kind: input.kind, reason: error instanceof Error ? error.message : String(error),
     }, { level: 'warn' }); } catch { /* A broken logger cannot change the caller's result. */ }
     return null;

package/src/core-turn/run-core-turn.ts

@@ -289,6 +289,7 @@ export async function runCoreTurn(
         ...(ctx.callbacks?.onResolvedProvider !== undefined ? { onResolvedProvider: ctx.callbacks.onResolvedProvider } : {}),
         ...(ctx.budgetGrant !== undefined ? { budgetGrant: ctx.budgetGrant } : {}),
         ...(ctx.terminalToolNames !== undefined ? { terminalToolNames: ctx.terminalToolNames } : {}),
+        ...(ctx.terminalPriorAnswerVisible !== undefined ? { terminalPriorAnswerVisible: ctx.terminalPriorAnswerVisible } : {}),
         // ⭐⭐⭐ `B3`(2026-08-19 · 대표 지시 ②) — 도는 턴 «안»으로 들어오는 사용자 발화의 배수구.
         //   ⛔ 종전엔 스트리밍 중 친 발화가 ***턴이 끝난 뒤***에야 나갔다.
         //   ⭐ 이제 «다음 모델 요청을 만들기 직전»(루프 경계)에 이력으로 들어가고,

package/src/core-turn/run-goal-loop.ts

@@ -397,6 +397,10 @@ function findRejectedToolCalls(newMessages: readonly LLMMessage[]): string[] {
   return [...rejected];
 }
 
+/** `streamLLMWithTools` 의 빈 턴·예산 포기 경고(`buildNoFinalSynthesisNotice`) 문면 — 완료 판정 관측에서 «답 없음»으로 센다.
+ *  머리 표지만 보지 않고 런타임 문장까지 맞춰, 그 표지를 인용한 정상 답을 «경고»로 세지 않는다. */
+const NO_FINAL_SYNTHESIS_NOTICE = /\[NO FINAL SYNTHESIS\] The model (?:stopped after repeated empty turns|used the available tool-loop turns without writing a plain-text answer)\./;
+
 /** 이 turn 의 새 메시지에서 마지막 `update_goal` 도구 호출을 찾아 구조화 종결 상태를
  *  반환한다. status 가 enum 밖이면 무시(null). evidence/reason 은 문자열만 수용. */
 function findGoalUpdate(
@@ -559,6 +563,20 @@ export async function runGoalLoop(
   ): GoalLoopResult => {
     if (terminalPublished) return result;
     terminalPublished = true;
+    // TUI-H1-GOALLOOP-EMPTY-TAIL — 완료 판정 한 줄: 목표가 닫혔나(goal-complete) · 사람에게 보일 답이 있나
+    //   (answer-present) · 둘 다 아니다(none — 빈 답이거나 «[NO FINAL SYNTHESIS]» 경고가 최종 답).
+    try {
+      const finalTrimmed = result.finalText.trim();
+      const reason = result.goalComplete
+        ? 'goal-complete'
+        : finalTrimmed.length > 0 && !NO_FINAL_SYNTHESIS_NOTICE.test(finalTrimmed) ? 'answer-present' : 'none';
+      debug.log('goal.loop', 'completion-verdict', {
+        sessionId: ctx.sessionId, ...runAttribution,
+        iterations, reason, stopReason: result.stopReason, finalChars: result.finalText.length,
+      }, { level: 'info' });
+    } catch {
+      // Observability must not change the loop result.
+    }
     try {
       if (result.goalComplete) {
         publishGoalLifecycle(bus, 'complete', completePayload ?? {
@@ -778,6 +796,9 @@ export async function runGoalLoop(
       ...(surfaceUserText !== undefined ? { userText: surfaceUserText } : {}),
       // TUI-GOAL-LOOP-FRICTION(#46·#63) — update_goal 은 도구 예산 거부를 받지 않고, 답과 함께 오면 그 턴으로 마감한다.
       terminalToolNames: [...(ctx.terminalToolNames ?? []), UPDATE_GOAL_TOOL_NAME],
+      // TUI-H1-GOALLOOP-EMPTY-TAIL — 앞 iteration 의 답이 이미 화면에 있으면 «update_goal 만 → 빈 턴» 은 할 말이 없는
+      //   것이다 — 재촉·경고 없이 빈 답으로 끝내고 아래 완료 판정이 앞 답으로 마감한다(중복 접기와 같은 길).
+      ...(previousFinalText.trim().length > 0 ? { terminalPriorAnswerVisible: true } : {}),
       // update_goal 은 종결 신호 — 실 dispatcher 로 새지 않게 가로채 ack 만 돌려준다.
       dispatchTool: (name, args, dctx) => {
         dispatchCount += 1;

package/src/core-turn/types.ts

@@ -158,6 +158,9 @@ export interface CoreTurnContext {
   /** TUI-GOAL-LOOP-FRICTION — 종결 신호 도구 이름. `streamLLMWithTools` 의 `terminalToolNames` 로 그대로 간다
    *  (예산 거부 면제 · 신호뿐인 턴 ⊕ 답 = 마감). goal loop 가 `update_goal` 을 넣는다. */
   terminalToolNames?: LLMOpts['terminalToolNames'];
+  /** TUI-H1-GOALLOOP-EMPTY-TAIL — 이 턴 «앞»에 사람에게 답을 이미 보였다. `streamLLMWithTools` 의
+   *  `terminalPriorAnswerVisible` 로 그대로 간다(종결 신호 뒤 빈 턴 = 경고 없이 빈 답). goal loop 가 넣는다. */
+  terminalPriorAnswerVisible?: LLMOpts['terminalPriorAnswerVisible'];
   /** Optional model override (forwarded to `streamLLMWithTools`). */
   modelOverride?: string;
 }

package/src/dashboard/acp-active-model.ts

@@ -6,7 +6,7 @@
 
 import { debug } from '../debug/log.js';
 import { effectiveReasoningLevel } from '../llm.js';
-import { recordCurrentRouteDecision, resolveRouteDecision, sessionModelPin } from '../llm/route-decision.js';
+import { clearSurfaceRouteDecision, currentRouteDecision, recordCurrentRouteDecision, recordRouteExecution, resolveRouteDecision, sessionModelPin } from '../llm/route-decision.js';
 import { inspectActiveProvider } from '../provider-summary.js';
 import { getUserConfig } from '../user-config.js';
 
@@ -38,3 +38,44 @@ export function resolveDashboardActiveModel(userText: string): string | null {
   });
   return decision.model || null;
 }
+
+/** 턴 사용량(ACP `elanous/ui/usage`)이 실어 온 «실제» 공급자·모델을 이 표면의 실행으로 적는다
+ *  (TUI-MODEL-BADGE-ACTUAL · 10-16). 완료 배지가 결정과 다르면 «A → B» 로 보인다.
+ *  폴백(결정과 다른 모델)이면 관측 이벤트 `llm.route-decision` / `dashboard-executed-fallback` 를 «항상» 남긴다. */
+export function recordDashboardTurnExecution(
+  usage: { model?: string; routeProvider?: string } | null | undefined,
+  /** 필수 — 세션 위치를 모르면(null) 적지 않는다(원격 사용량을 로컬 실행으로 꾸미지 않게). */
+  session: { remote: boolean } | null,
+): void {
+  // ⛔ 순서: 원격·세션 미상 판정(⊕ 비우기)을 model 검사보다 «먼저» 한다 — 사용량 봉투의 model 은 선택 칸이라,
+  //   모델 없는 원격 사용량이 먼저 반환하면 지난 로컬 턴의 «A → B» 가 남는다(r6 리뷰).
+  const model = usage?.model?.trim() || null;
+  if (session === null) {
+    // 짝을 모르는 턴 — 지난 턴의 결정·실행이 이 턴의 배지로 «다시» 보이지 않게 비운다.
+    clearSurfaceRouteDecision('dashboard');
+    debug.log('llm.route-decision', 'dashboard-executed-session-unknown', { model }, { level: 'warn' });
+    return;
+  }
+  // ⛔ 원격 데몬 세션은 적지 않는다 — 결정은 데몬 쪽에서 서므로 이 프로세스의 결정과 짝이 안 맞는다.
+  //   후속 칸 TUI-MODEL-BADGE-REMOTE.
+  if (session.remote) {
+    // 원격 턴은 로컬 결정과 짝이 없다 — 지난 로컬 턴의 «A → B» 가 이 턴의 배지로 다시 나오지 않게 비운다(r5 리뷰).
+    clearSurfaceRouteDecision('dashboard');
+    if (debug.enabled) debug.log('llm.route-decision', 'dashboard-executed-remote-skipped', { model });
+    return;
+  }
+  if (!model) return;
+  const provider = usage?.routeProvider?.trim() || undefined;
+  const decision = currentRouteDecision('dashboard');
+  // 결정이 없는 실행은 짝이 없다 — 적지 않는다.
+  if (!decision) return;
+  recordRouteExecution('dashboard', { model, ...(provider ? { provider } : {}) });
+  if (decision.model !== '' && decision.model !== model) {
+    debug.log('llm.route-decision', 'dashboard-executed-fallback', {
+      planned: { provider: decision.provider, model: decision.model },
+      actual: { provider: provider ?? null, model },
+    }, { level: 'warn' });
+  } else if (debug.enabled) {
+    debug.log('llm.route-decision', 'dashboard-executed', { provider: provider ?? null, model });
+  }
+}

package/src/dashboard/background-jobs-status.ts

@@ -0,0 +1,66 @@
+// ── 상태줄 «⧗ 백그라운드 N» 상태 (TUI-BG-JOB-VISIBILITY · TUI 결함 #71 · 0.2.31) ──────────────
+//
+// 🚨 무엇을 푸는가: 10-16 07:3x OPT 가 «남은 리뷰 4건 실행 중 · 다음 점검 = …» 으로 턴을 «✔ 완료» 로
+//   끝냈다. 상태줄엔 백그라운드 표시가 없어 바깥(OP·대표)에선 «12분 유휴» 로 보였다.
+// ⭐ 이 모듈은 «상태줄에 몇 개를 그릴지» 와 그 관측만 쥔다 — 렌더는 `backgroundJobsSegment`
+//   (src/status/bar.ts), 집계는 BackgroundSurface 의 `background`(src/shell-runner/background-surface.ts).
+// ⛔ 깨우기(끝나면 턴을 여는 것)는 하지 않는다 — TUI-AGENT-IDLE-WAKE 칸(onEnqueue 배선 · H2 문) 몫.
+// ⛔ 입력칸·외부 입력 대기열 주입 0(대표 비침투).
+//
+// 세 얼굴:
+//   관측 = debug.log('status.bar', 'bg-jobs', { running, backgrounded, background, trigger:'rollup' })
+//          — 등록된 백그라운드 수가 «바뀔 때만»(렌더마다·같은 수 반복엔 안 남긴다 · 처음 기준 = 0)
+//   인지 = 등록된 백그라운드 일 > 0 이면 턴이 유휴여도 «일하는 중»
+//   힐링 = 상태줄 «⧗ 백그라운드 N» — 사람·OP 가 «유휴인데 일하는 중» 을 본다 · 수가 바뀌면 다시 그린다 ·
+//          읽기 실패는 0 으로 보고 상태줄을 막지 않는다 · 실패 시 TF(관측 로그)
+
+import { debug } from '../debug/log.js';
+import type { BackgroundJobsSummary } from '../status/bar.js';
+
+export interface ShellRollupCounts {
+  running: number;
+  backgrounded: number;
+  /** 턴을 넘어 사는 핸들(bg 모드 ⊕ backgrounded). 필수 — backgrounded 로 추정하면 도는 bg 모드 일을 빠뜨린다. */
+  background: number;
+}
+
+export interface BackgroundJobsStatusDeps {
+  log?: (event: string, data: Record<string, unknown>) => void;
+}
+
+export interface BackgroundJobsStatus {
+  /** 집계가 왔다 — 등록된 백그라운드 수가 바뀌었으면 관측 한 줄 ⊕ true(호출자가 다시 그린다). */
+  noteRollup(rollup: ShellRollupCounts): boolean;
+  /** 상태줄 입력. */
+  summary(): BackgroundJobsSummary;
+}
+
+function countOf(n: number): number {
+  return Number.isFinite(n) ? Math.max(0, Math.floor(n)) : 0;
+}
+
+export function createBackgroundJobsStatus(deps: BackgroundJobsStatusDeps = {}): BackgroundJobsStatus {
+  const log = deps.log ?? ((event, data) => { debug.log('status.bar', event, data); });
+  // 처음 기준은 0 — 백그라운드 0 인 첫 집계(인라인 실행 등)는 «변화 없음» 이라 안 남긴다.
+  let background = 0;
+
+  return {
+    noteRollup(rollup) {
+      const next = countOf(rollup.background);
+      if (next === background) return false;
+      background = next;
+      try {
+        log('bg-jobs', {
+          running: countOf(rollup.running),
+          backgrounded: countOf(rollup.backgrounded),
+          background: next,
+          trigger: 'rollup',
+        });
+      } catch { /* 관측 실패가 상태줄을 막지 않는다 */ }
+      return true;
+    },
+    summary() {
+      return { background };
+    },
+  };
+}