elanous 0.2.31 → 0.2.34

package/src/dashboard/slash-runtime/dashboard-log-slash.ts

@@ -0,0 +1,208 @@
+import type { DashboardSlashContext, DashboardSlashReturn } from './dashboard-handlers.js';
+import type { SlashCommandRegistry } from './registry.js';
+import { stripAnsi } from '../../tui.js';
+import { resolveDashboardChatMainLogCommand } from '../input/chat-main-log-command.js';
+import {
+  dashboardLogHelpLines,
+  resolveDashboardLogFilterAction,
+  resolveDashboardLogFoldAction,
+  resolveDashboardLogSearchAction,
+  resolveDashboardLogSizeAction,
+  resolveDashboardLogTurnAction,
+} from '../input/chat-main-log-actions.js';
+import { debug } from '../../debug/log.js';
+
+type EmitReplyToChat = (ctx: Pick<DashboardSlashContext, 'pushChatLine'>, line: string) => void;
+
+export function registerDashboardLogSlash(
+  registry: SlashCommandRegistry<DashboardSlashContext, DashboardSlashReturn>,
+  emitReplyToChat: EmitReplyToChat,
+): void {
+  registry.register('log', async (args, ctx) => {
+    // Log pane control. Routes through resolveDashboardChatMainLog
+    // Command + resolveDashboardLog*Action helpers are imported
+    // in this module. Host-local state — heightBias / filter / search / freeze /
+    // turnSeparator / foldMode / chatOnly — comes via ctx.logSlash.
+    // Replies go to the chat buffer the person is looking at — never the
+    // debug buffer, which the default layout does not draw.
+    const logCommand = resolveDashboardChatMainLogCommand(args);
+    if (debug.enabled) {
+      debug.log('slash.log.handler', 'enter', {
+        argsCount: args.length,
+        args0: args[0] ?? null,
+        kind: logCommand.kind,
+        // unknown branch carries subcommand
+        unknownSub: logCommand.kind === 'unknown' ? logCommand.subcommand : null,
+      });
+    }
+    if (logCommand.kind === 'help') {
+      const lines = dashboardLogHelpLines();
+      for (const [index, line] of lines.entries()) {
+        if (line === '') {
+          emitReplyToChat(ctx, '');
+        } else if (index === 0) {
+          emitReplyToChat(ctx, ctx.accent(line));
+        } else {
+          emitReplyToChat(ctx, ctx.muted(line));
+        }
+      }
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    if (logCommand.kind === 'size') {
+      const action = resolveDashboardLogSizeAction(logCommand.delta, ctx.logSlash.getLogHeightBias());
+      if (action.kind === 'invalid') {
+        emitReplyToChat(ctx, ctx.warning(action.message));
+      } else {
+        ctx.logSlash.setLogHeightBias(action.nextBias);
+        ctx.logSlash.recomputePaneHeight();
+        emitReplyToChat(ctx, ctx.muted(action.message));
+      }
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    if (logCommand.kind === 'copy-all') {
+      await ctx.logSlash.copyEntireLog();
+      return;
+    }
+    if (logCommand.kind === 'return-to-input') {
+      ctx.logSlash.returnFocusToInput();
+      return;
+    }
+    if (logCommand.kind === 'clear') {
+      ctx.chatLines.length = 0;
+      ctx.attachmentRowMap.clear();
+      ctx.clearLogSearch();
+      ctx.clearLogFilter();
+      emitReplyToChat(ctx, ctx.muted('Log cleared.'));
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    if (logCommand.kind === 'filter') {
+      const q = logCommand.query;
+      const currentQuery = ctx.logSlash.getLogFilterQuery();
+      const activeCount = ctx.chatLines.filter(
+        line => stripAnsi(line).toLowerCase().includes((q || currentQuery).toLowerCase()),
+      ).length;
+      const action = resolveDashboardLogFilterAction(q, currentQuery, activeCount);
+      if (action.kind === 'clear') {
+        ctx.clearLogFilter();
+        emitReplyToChat(ctx, ctx.muted(action.message));
+      } else if (action.kind === 'show-status') {
+        emitReplyToChat(ctx, ctx.muted(action.message));
+      } else {
+        ctx.logSlash.applyLogFilter(q);
+        emitReplyToChat(ctx, ctx.muted(action.message));
+        ctx.setChatScrollOffset(-1);
+      }
+      return;
+    }
+    if (logCommand.kind === 'search') {
+      const q = logCommand.query;
+      const action = resolveDashboardLogSearchAction(q);
+      if (action.kind === 'clear') {
+        ctx.clearLogSearch();
+        emitReplyToChat(ctx, ctx.muted(action.message));
+      } else if (action.kind === 'open-modal') {
+        ctx.logSlash.openLogSearchModal();
+      } else {
+        ctx.logSlash.applyLogSearch(action.query);
+        const count = ctx.logSlash.getLogSearchResultsCount();
+        if (count === 0) {
+          emitReplyToChat(ctx, ctx.muted(`  no matches for "${action.query}"`));
+        } else {
+          emitReplyToChat(ctx, ctx.muted(
+            `  ${count} match${count === 1 ? '' : 'es'} for "${action.query}" — n / N to cycle, Esc to clear`,
+          ));
+          // Jump to the first one.
+          const firstIdx = ctx.logSlash.firstSearchResultLineIdx();
+          if (firstIdx !== null) ctx.logSlash.scrollToSearchLineIdx(firstIdx);
+        }
+      }
+      // Original case had `chatScrollOffset = chatScrollOffset` no-op
+      // — preserved here as no setChatScrollOffset call (intentional).
+      return;
+    }
+    if (logCommand.kind === 'freeze') {
+      if (!ctx.logSlash.isLogFreezeEnabled()) {
+        emitReplyToChat(ctx, ctx.muted('  scroll-freeze DISABLED (ELANOUS_LOG_PAUSE_ON_SCROLL=0).'));
+      } else {
+        const frozenIdx = ctx.logSlash.getLogFrozenTailIndex();
+        if (frozenIdx === null) {
+          emitReplyToChat(ctx, ctx.muted('  scroll-freeze inactive — log tail is live.'));
+        } else {
+          const queued = Math.max(0, ctx.logSlash.chatLinesLength() - frozenIdx);
+          emitReplyToChat(ctx, ctx.muted(`  scroll-freeze active — ${queued} line${queued === 1 ? '' : 's'} queued. Press G to resume.`));
+        }
+      }
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    if (logCommand.kind === 'solo') {
+      const next = ctx.logSlash.toggleSolo();
+      const message = next
+        ? '  log solo ON — chat-only layout active.'
+        : '  log solo OFF — dashboard layout restored.';
+      emitReplyToChat(ctx, ctx.muted(message));
+      if (debug.enabled) {
+        debug.log('slash.log.solo', next ? 'on' : 'off', {
+          newChatOnlyMode: next,
+        });
+      }
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    if (logCommand.kind === 'fold-all') {
+      if (!ctx.logSlash.setAllFolds) {
+        // A host without a fold controller cannot know whether anything is folded — say so, not «nothing».
+        debug.log('log.fold', 'slash-set-all', { expanded: logCommand.expanded, changed: null, reason: 'no-fold-controller' });
+        emitReplyToChat(ctx, ctx.warning('  fold controls are not available in this view'));
+        ctx.setChatScrollOffset(-1);
+        return;
+      }
+      const changed = ctx.logSlash.setAllFolds(logCommand.expanded);
+      debug.log('log.fold', 'slash-set-all', { expanded: logCommand.expanded, changed });
+      emitReplyToChat(ctx, ctx.muted(changed > 0
+        ? `  ${logCommand.expanded ? 'unfolded' : 'folded'} ${changed} block${changed === 1 ? '' : 's'}`
+        : `  (nothing to ${logCommand.expanded ? 'unfold' : 'fold'})`));
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    if (logCommand.kind === 'fold') {
+      const action = resolveDashboardLogFoldAction(logCommand.mode, ctx.logSlash.getLogFoldMode());
+      if (action.kind === 'set-mode') {
+        ctx.logSlash.setLogFoldMode(action.mode);
+        emitReplyToChat(ctx, ctx.muted(action.message));
+        ctx.setChatScrollOffset(-1);
+        return;
+      }
+      emitReplyToChat(ctx, ctx.warning(action.message));
+      emitReplyToChat(ctx, ctx.muted(action.usage));
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    if (logCommand.kind === 'turn') {
+      const action = resolveDashboardLogTurnAction(logCommand.arg, ctx.logSlash.getLogTurnSeparatorMode());
+      if (action.kind === 'emit-now') {
+        const prev = ctx.logSlash.getLogTurnSeparatorMode();
+        ctx.logSlash.setLogTurnSeparatorMode(action.nextModeWhileEmitting);
+        ctx.logSlash.pushTurnSeparator();
+        ctx.logSlash.setLogTurnSeparatorMode(prev);
+        ctx.setChatScrollOffset(-1);
+        return;
+      }
+      if (action.kind === 'set-mode') {
+        ctx.logSlash.setLogTurnSeparatorMode(action.mode);
+        emitReplyToChat(ctx, ctx.muted(action.message));
+        ctx.setChatScrollOffset(-1);
+        return;
+      }
+      emitReplyToChat(ctx, ctx.muted(action.message));
+      emitReplyToChat(ctx, ctx.muted(action.usage));
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    emitReplyToChat(ctx, ctx.warning(`  Unknown /log subcommand: ${logCommand.subcommand}. Try /log help.`));
+    ctx.setChatScrollOffset(-1);
+  });
+}

package/src/dashboard/turn-preamble.ts

@@ -39,6 +39,10 @@ import {
 } from '../agent/task-notification.js';
 import type { getUserConfig } from '../user-config.js';
 import { isNativeStructureEnabledForProvider, resolveActiveProvider } from '../user-config.js';
+import { measureInputLagTurnStart } from '../tui/input-lag-probe.js';
+import { effectiveInstanceRoot, prodInstanceRoot } from '../instance/resolve.js';
+import { buildSelfHealthLine, type InstalledRecord, type SelfHealthErrors } from '../pty-shell/tui-run-state.js';
+import type { PtyBuildIdentity } from '../pty-shell/pty-manifest.js';
 
 type UserConfig = ReturnType<typeof getUserConfig>;
 
@@ -61,8 +65,6 @@ export interface DashboardTurnPreambleContext {
   modelFamily?: ModelFamily;
   /** Current request session ID. It is injected only while this preamble is built for the turn. */
   sessionId?: string;
-  /** Catalog richness for non-dashboard callers; the essential dashboard passes false. */
-  rich?: boolean;
   /** Active tool names for session-specific guidance (Wave 3,
    *  2026-05-04). When provided, the universal preamble emits per-tool
    *  one-liner directives (e.g. AskUserQuestion → use for tool-deny
@@ -76,6 +78,25 @@ export interface DashboardTurnPreambleContext {
   controlEnv?: { controller?: string; channels?: string };
   /** File-memory layer seam: a store root and env for scope resolution (tests), or false to omit it. */
   memory?: { root?: string; env?: NodeJS.ProcessEnv } | false;
+
+  /** 🫀 매 턴 자기 건강 한 줄(TUI-SELF-HEALTH-LINE · 0.2.34) 재료. 판(실행 판 vs 설치본) 축은
+   *  이 블록 없이도 tui-run-state 의 실물 판정(runningBuild ⊕ readCurrentInstallRecord)으로 매 턴
+   *  나간다. `errors`·`creditUsage` 는 호출자가 집계한 값 — «직전 30분 창에서 어떤 이벤트를 자기
+   *  오류로 세는지»·«크레딧 사용을 무엇으로 잴지» 는 미결 항목이라 이 빌더가 정하지 않는다. */
+  selfHealth?: {
+    /** 직전 30분 자기 오류 집계 — 없으면(undefined·null) 오류 축은 아예 말하지 않는다. */
+    errors?: SelfHealthErrors | null;
+    /** 크레딧 사용 재료(호출자가 만든 값) — 없으면 그 축은 생략된다. */
+    creditUsage?: string;
+    /** 재기동 명령에 얹을 대화 id — 생략하면 ctx.sessionId. */
+    sessionId?: string;
+    /** 새 판 안내 회차(stale-install-check notifiedCount 회차 문면) — 기본 1. */
+    notifiedCount?: number;
+    /** 판정 seam(시험 격리) — 기본은 실물(runningBuild·readCurrentInstallRecord·readCheckoutHead). */
+    build?: () => PtyBuildIdentity;
+    readInstalled?: () => InstalledRecord;
+    readCheckoutHead?: (codeRoot: string) => string | undefined;
+  };
 }
 
 export function buildControllerSystemMessage(controller: string, channels?: string): LLMMessage {
@@ -85,40 +106,110 @@ export function buildControllerSystemMessage(controller: string, channels?: stri
   };
 }
 
+/** How old a git snapshot the TUI preamble may serve while it rebuilds in the background.
+ *  Edits (post-Edit force refresh) and HEAD moves invalidate it earlier; the dashboard's
+ *  5s git tick keeps it younger than this so an idle-then-type turn still hits. */
+const DASHBOARD_GIT_SNAPSHOT_STALE_MS = 60_000;
+
+/** TUI-TYPING-LAG-OBS 시험 seam — 이 ms 만큼 turn-preamble 을 «동기로» 막아 타이핑 지연을 일으킨다.
+ *  운영 기본 0. 켜는 길 둘: ux-sim·단위 시험은 `setPreambleSyncBlockMsForTesting` · 격리 TUI 는
+ *  env `ELANOUS_TEST_PREAMBLE_SYNC_BLOCK_MS`(⛔ test 우주에서만 읽는다 — 운영 우주에선 무시).
+ *  test 우주 = 이 프로세스의 실효 뿌리가 운영 집이 아닌 것. `--test` 플래그만 보면 pty-drive 가
+ *  `--test` 를 `--config-dir <격리 뿌리>` 로 바꿔 띄운 시험 자식에서 seam 이 안 켜진다. */
+export const PREAMBLE_SYNC_BLOCK_ENV = 'ELANOUS_TEST_PREAMBLE_SYNC_BLOCK_MS';
+let preambleSyncBlockOverrideMs: number | null = null;
+
+export function setPreambleSyncBlockMsForTesting(ms: number | null): void {
+  preambleSyncBlockOverrideMs = ms;
+}
+
+export function preambleSyncBlockMs(
+  env: NodeJS.ProcessEnv = process.env,
+  instanceRoot: () => string = effectiveInstanceRoot,
+): number {
+  if (preambleSyncBlockOverrideMs !== null) return Math.max(0, preambleSyncBlockOverrideMs);
+  const raw = env[PREAMBLE_SYNC_BLOCK_ENV];
+  if (!raw || instanceRoot() === prodInstanceRoot()) return 0;
+  const ms = Number(raw);
+  return Number.isFinite(ms) && ms > 0 ? ms : 0;
+}
+
+/** 일부러 이벤트 루프를 동기로 막는다(시험 seam). 시계를 돌며 도는 바쁜 루프 대신 `Atomics.wait` —
+ *  CPU 를 태우지 않고, 시험이 시계를 가짜로 바꿔도 끝난다. */
+function blockPreambleSync(ms: number): void {
+  if (ms <= 0) return;
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
 export function buildDashboardTurnPreamble(
   ctx: DashboardTurnPreambleContext,
 ): LLMMessage[] {
+  return measureInputLagTurnStart(() => {
+    blockPreambleSync(preambleSyncBlockMs());
+    return buildDashboardTurnPreambleUnmeasured(ctx);
+  });
+}
+
+/** TURN-START-BLOCK-REST 1단계 — 빌더마다 걸린 ms(0.1ms 반올림)를 `chat.turn-preamble built` 의
+ *  `builderMs` 칸에 싣는다. 시계는 빌더마다 앞뒤 한 번씩이고, `built` 이벤트가 안 나가는
+ *  (`debug.enabled` 꺼짐) 턴에서는 재지 않는다. 이 함수의 빌더는 전부 동기라 잰 ms 가 곧
+ *  이벤트 루프를 막은 시간이다(`builderMsKind: 'sync'`). */
+type BuilderMs = Record<string, number>;
+
+function timed<T>(ms: BuilderMs | null, name: string, fn: () => T): T {
+  if (ms === null) return fn();
+  const t0 = performance.now();
+  try {
+    return fn();
+  } finally {
+    ms[name] = Math.round((performance.now() - t0) * 10) / 10;
+  }
+}
+
+function buildDashboardTurnPreambleUnmeasured(
+  ctx: DashboardTurnPreambleContext,
+): LLMMessage[] {
+  const builderMs: BuilderMs | null = debug.enabled ? {} : null;
+  const startedAt = builderMs === null ? 0 : performance.now();
   // Universal preamble — surface-agnostic anchor (AGENTS.md +
   // CLAUDE.md). Spread first so the project context lands BEFORE any
   // surface-specific guidance, mirroring Claude Code's Phase 0
   // ordering. Returns [] when neither anchor file exists, so the
   // spread is a no-op outside actual project repos (tests etc.).
-  const universalPreamble = buildUniversalPreamble({
+  const universalPreamble = timed(builderMs, 'universal', () => buildUniversalPreamble({
     cwd: ctx.cwd,
     ...(ctx.modelFamily !== undefined ? { modelFamily: ctx.modelFamily } : {}),
     ...(ctx.enabledTools !== undefined ? { enabledTools: ctx.enabledTools } : {}),
-  });
-  // 🪪 L1 — 자리 부트 카드(세션마다 한 번 만든 스냅샷). 정체성(앵커) 바로 뒤. 자리가 아니면 [].
-  const seatBootSystemMsgs = ctx.seatBoot
-    ? buildSeatBootSystemMessages(
+  }));
+  // 🪪 L1 — 자리 부트 카드(세션마다 한 번 만든 스냅샷: 안 읽은 우편·HANDOFF·예약·지난 세션 — `cli/seat-cli.ts` 공용 조립).
+  //    새 세션 부팅·`/session new`·`/session clear` 는 `startSeatBootConversation` 이 스냅샷을 새로 만들어 «첫 턴 = 새 카드» 로 만든다.
+  //    정체성(앵커) 바로 뒤. 자리가 아니면 [].
+  const seatBoot = ctx.seatBoot;
+  const seatBootSystemMsgs = seatBoot
+    ? timed(builderMs, 'seatBoot', () => buildSeatBootSystemMessages(
       { cwd: ctx.cwd, ...(ctx.sessionId !== undefined ? { sessionId: ctx.sessionId } : {}) },
-      ctx.seatBoot === true ? {} : ctx.seatBoot,
-    )
+      seatBoot === true ? {} : seatBoot,
+    ))
     : [];
-  const planModeSystemMsgs = buildPlanModeSystemMessages();
-  const askSystemMsgs = buildExecutionAskSystemMessages() as LLMMessage[];
-  const approvalSystemMsgs = buildApprovalPolicySystemMessages() as LLMMessage[];
-  const sandboxSystemMsgs = buildSandboxEscalationSystemMessages() as LLMMessage[];
+  const planModeSystemMsgs = timed(builderMs, 'planMode', () => buildPlanModeSystemMessages());
+  const askSystemMsgs = timed(builderMs, 'ask', () => buildExecutionAskSystemMessages() as LLMMessage[]);
+  const approvalSystemMsgs = timed(builderMs, 'approval', () => buildApprovalPolicySystemMessages() as LLMMessage[]);
+  const sandboxSystemMsgs = timed(builderMs, 'sandbox', () => buildSandboxEscalationSystemMessages() as LLMMessage[]);
   // Session-scoped (built once, rebuilt on change) — see turn-session-layers.ts.
   const sessionKey = ctx.sessionId ?? 'tui';
-  const memorySystemMsgs = ctx.memory === false
+  const memory = ctx.memory;
+  const memorySystemMsgs = memory === false
     ? []
-    : sessionMemoryLayer({ sessionKey, cwd: ctx.cwd, ...(ctx.memory ?? {}) });
-  const gitSnapshotSystemMsgs = buildSessionRuntimeSystemMessages({
+    : timed(builderMs, 'memory', () => sessionMemoryLayer({ sessionKey, cwd: ctx.cwd, ...(memory ?? {}) }));
+  // TUI-TYPING-LAG — the snapshot is built twice per turn (dashboard ⊕ ACP) with 5+ git
+  // subprocesses each; a recent one is served and rebuilt off the event loop instead.
+  const gitSnapshotSystemMsgs = timed(builderMs, 'gitSnapshot', () => buildSessionRuntimeSystemMessages({
     cwd: ctx.cwd,
-  });
-  const surfaceSystemMsgs = ctx.turnProfile
-    ? buildSessionRuntimeTurnSystemMessages(ctx.turnProfile, ctx.userText)
+    gitSnapshotStaleMs: DASHBOARD_GIT_SNAPSHOT_STALE_MS,
+  }));
+  const turnProfile = ctx.turnProfile;
+  const surfaceSystemMsgs = turnProfile
+    ? timed(builderMs, 'surface', () => buildSessionRuntimeTurnSystemMessages(turnProfile, ctx.userText))
     : ([] as LLMMessage[]);
   // ⭐⭐ `tools.nativeStructure` 는 «어느 provider 에 켤지»를 목록으로 고를 수 있다(2026-08-18).
   //   ⛔ 목록이 없으면 종전대로 «전 provider» — 기존 설정을 쓰는 사람의 값이 안 바뀐다.
@@ -134,43 +225,67 @@ export function buildDashboardTurnPreamble(
     && isNativeStructureEnabledForProvider(nativeStructureConfig, resolveActiveProvider(ctx.userConfig));
   let nativeTools: NativeToolCatalogEntry[] | undefined;
   if (nativeStructureEnabled) {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const { findNativeTool } = require('../native-tool-catalog.js') as typeof import('../native-tool-catalog.js');
-    nativeTools = [...new Map((ctx.enabledTools ?? [])
-      .map(findNativeTool)
-      .filter((tool): tool is NativeToolCatalogEntry => tool !== undefined)
-      .map(tool => [tool.id, tool])).values()];
+    nativeTools = timed(builderMs, 'nativeTools', () => {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const { findNativeTool } = require('../native-tool-catalog.js') as typeof import('../native-tool-catalog.js');
+      return [...new Map((ctx.enabledTools ?? [])
+        .map(findNativeTool)
+        .filter((tool): tool is NativeToolCatalogEntry => tool !== undefined)
+        .map(tool => [tool.id, tool])).values()];
+    });
   }
-  const implDisciplineSystemMsgs = buildImplDisciplineSystemMessages({
+  const implDisciplineSystemMsgs = timed(builderMs, 'implDiscipline', () => buildImplDisciplineSystemMessages({
     text: ctx.userText,
   }, {
     nativeStructureEnabled,
     ...(nativeTools !== undefined ? { enabledTools: nativeTools } : {}),
-  }) as LLMMessage[];
-  const concisenessSystemMsgs = buildConcisenessSystemMessages(
+  }) as LLMMessage[]);
+  const concisenessSystemMsgs = timed(builderMs, 'conciseness', () => buildConcisenessSystemMessages(
     ctx.userConfig.chat.conciseness,
-  ) as LLMMessage[];
+  ) as LLMMessage[]);
   // ★ elanous 자기접근 규율 + 자기인지 ambient(P3 · 2026-07-13) — 텔레그램/디스코드
   //   (makeElanousAgentRunTurn)와 단일 출처(agent/self-ambient.ts). TUI 채팅에서도 미션
   //   진단("P2 왜 실패?")·자율 시스템 관측·회상이 규율+ambient+툴(self-ops family) 3박자로
   //   성립한다. fail-soft: ambient 조회 실패가 턴을 막지 않는다.
   let selfOpsSystemMsgs: LLMMessage[] = [];
   try {
-    selfOpsSystemMsgs = [
+    selfOpsSystemMsgs = timed(builderMs, 'selfOps', () => [
       elanousSelfAccessPrompt(ctx.sessionId),
       ...sessionSelfAmbientParts(sessionKey),
       investigationRecallAmbient(ctx.userText),
       localRefGroundingAmbient(ctx.userText),
     ]
       .filter(Boolean)
-      .map((content): LLMMessage => ({ role: 'system', content }));
+      .map((content): LLMMessage => ({ role: 'system', content })));
   } catch { /* fail-soft */ }
+  // 🫀 매 턴 자기 건강 한 줄(TUI-SELF-HEALTH-LINE · 0.2.34) — 자기 관측 → 자기 인지의 사실 칸.
+  //    판(실행 판 vs 설치본) 축은 tui-run-state 의 실물 판정(judgeBuildStaleness ⊕ readCurrentInstallRecord)을
+  //    매 턴 소비하고, 오류·크레딧 축은 호출자가 집계한 재료(ctx.selfHealth)를 얹는다. fail-soft:
+  //    판정이 깨져도 줄만 빠지고 턴은 간다.
+  const selfHealth = ctx.selfHealth;
+  const selfHealthSystemMsgs = timed(builderMs, 'selfHealth', (): LLMMessage[] => {
+    try {
+      const line = buildSelfHealthLine(selfHealth?.errors ?? undefined, {
+        ...(ctx.sessionId !== undefined ? { sessionId: ctx.sessionId } : {}),
+        ...(selfHealth?.sessionId !== undefined ? { sessionId: selfHealth.sessionId } : {}),
+        ...(selfHealth?.build !== undefined ? { build: selfHealth.build } : {}),
+        ...(selfHealth?.readInstalled !== undefined ? { readInstalled: selfHealth.readInstalled } : {}),
+        ...(selfHealth?.readCheckoutHead !== undefined ? { readCheckoutHead: selfHealth.readCheckoutHead } : {}),
+        ...(selfHealth?.notifiedCount !== undefined ? { notifiedCount: selfHealth.notifiedCount } : {}),
+        ...(selfHealth?.creditUsage !== undefined ? { creditUsage: selfHealth.creditUsage } : {}),
+      });
+      return line === null ? [] : [{ role: 'system', content: line }];
+    } catch {
+      return []; // fail-soft — 자기 건강 줄이 턴을 막지 않는다
+    }
+  });
   const controlEnv = ctx.controlEnv ?? {
     controller: process.env.ELANOUS_CONTROLLER,
     channels: process.env.ELANOUS_CONTROL_CHANNELS,
   };
-  const controllerSystemMsgs = controlEnv.controller
-    ? [buildControllerSystemMessage(controlEnv.controller, controlEnv.channels)]
+  const controller = controlEnv.controller;
+  const controllerSystemMsgs = controller
+    ? timed(builderMs, 'controller', () => [buildControllerSystemMessage(controller, controlEnv.channels)])
     : [];
   const preamble = [
     ...universalPreamble,
@@ -183,6 +298,7 @@ export function buildDashboardTurnPreamble(
     ...gitSnapshotSystemMsgs,
     ...surfaceSystemMsgs,
     ...selfOpsSystemMsgs,
+    ...selfHealthSystemMsgs,
     ...controllerSystemMsgs,
     ...implDisciplineSystemMsgs,
     ...concisenessSystemMsgs,
@@ -196,24 +312,25 @@ export function buildDashboardTurnPreamble(
   // or (c) the model is simply ignoring what we sent.
   let taskNotificationCount = 0;
   try {
-    const pendingNotifications = globalTaskNotificationQueue.drain();
-    taskNotificationCount = pendingNotifications.length;
-    const taskNotificationsXml = renderTaskNotificationsXml(pendingNotifications);
-    if (taskNotificationsXml) {
-      preamble.push({ role: 'user', content: taskNotificationsXml });
-    }
+    timed(builderMs, 'taskNotifications', () => {
+      const pendingNotifications = globalTaskNotificationQueue.drain();
+      taskNotificationCount = pendingNotifications.length;
+      const taskNotificationsXml = renderTaskNotificationsXml(pendingNotifications);
+      if (taskNotificationsXml) {
+        preamble.push({ role: 'user', content: taskNotificationsXml });
+      }
+    });
   } catch {
     // Fail-soft: a task-notification delivery failure must not block the turn.
   }
 
-  if (debug.enabled) {
+  if (debug.enabled && builderMs !== null) {
     const total = preamble.reduce((sum, m) => {
       const c = m.content;
       return sum + (typeof c === 'string' ? c.length : JSON.stringify(c).length);
     }, 0);
     debug.log('chat.turn-preamble', 'built', {
       hasTurnProfile: ctx.turnProfile != null,
-      rich: ctx.rich === true,
       builderCounts: {
         universal: universalPreamble.length,
         seatBoot: seatBootSystemMsgs.length,
@@ -225,10 +342,15 @@ export function buildDashboardTurnPreamble(
         gitSnapshot: gitSnapshotSystemMsgs.length,
         surface: surfaceSystemMsgs.length,
         selfOps: selfOpsSystemMsgs.length,
+        selfHealth: selfHealthSystemMsgs.length,
         controller: controllerSystemMsgs.length,
         implDiscipline: implDisciplineSystemMsgs.length,
         conciseness: concisenessSystemMsgs.length,
       },
+      // 실린 빌더만 키가 있다(seatBoot·memory·surface·nativeTools·controller 는 조건부로 안 불린다).
+      builderMs,
+      builderMsKind: 'sync',
+      builderTotalMs: Math.round((performance.now() - startedAt) * 10) / 10,
       totalMessageCount: preamble.length,
       taskNotificationCount,
       totalChars: total,

package/src/dashboard/turn-session-layers.ts

@@ -16,7 +16,7 @@ import { join } from 'node:path';
 import type { LLMMessage } from '../llm.js';
 import { debug } from '../debug/log.js';
 import { buildMemoryInjection, memoryRoot, type MemoryEntry } from '../memory.js';
-import { elanousSelfAmbientParts } from '../agent/self-ambient.js';
+import { cachedSelfAmbientBaseParts } from '../agent/self-ambient-cache.js';
 
 /** Token budget for the TUI memory layer — the same default chat.ts gives buildMemoryInjection. */
 export const TUI_MEMORY_BUDGET_TOKENS = 1500;
@@ -157,7 +157,9 @@ export function sessionSelfAmbientParts(sessionKey: string, opts: SessionSelfAmb
     return cached.parts;
   }
   try {
-    const parts = (opts.build ?? (() => elanousSelfAmbientParts()))();
+    // TUI-TYPING-LAG — the stores are scanned by a worker (self-ambient-cache.ts); expiry here must
+    // not bring a synchronous `ps`/crontab/sqlite scan back onto the TUI turn path.
+    const parts = (opts.build ?? (() => cachedSelfAmbientBaseParts()))();
     const hash = contentHash(parts.join('\0'));
     if (cached && cached.hash === hash) {
       remember(ambientCache, sessionKey, { ...cached, at: now });