elanous 0.2.32 → 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

@@ -41,6 +41,8 @@ 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>;
 
@@ -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 {
@@ -160,7 +181,9 @@ function buildDashboardTurnPreambleUnmeasured(
     ...(ctx.modelFamily !== undefined ? { modelFamily: ctx.modelFamily } : {}),
     ...(ctx.enabledTools !== undefined ? { enabledTools: ctx.enabledTools } : {}),
   }));
-  // 🪪 L1 — 자리 부트 카드(세션마다 한 번 만든 스냅샷). 정체성(앵커) 바로 뒤. 자리가 아니면 [].
+  // 🪪 L1 — 자리 부트 카드(세션마다 한 번 만든 스냅샷: 안 읽은 우편·HANDOFF·예약·지난 세션 — `cli/seat-cli.ts` 공용 조립).
+  //    새 세션 부팅·`/session new`·`/session clear` 는 `startSeatBootConversation` 이 스냅샷을 새로 만들어 «첫 턴 = 새 카드» 로 만든다.
+  //    정체성(앵커) 바로 뒤. 자리가 아니면 [].
   const seatBoot = ctx.seatBoot;
   const seatBootSystemMsgs = seatBoot
     ? timed(builderMs, 'seatBoot', () => buildSeatBootSystemMessages(
@@ -235,6 +258,27 @@ function buildDashboardTurnPreambleUnmeasured(
       .filter(Boolean)
       .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,
@@ -254,6 +298,7 @@ function buildDashboardTurnPreambleUnmeasured(
     ...gitSnapshotSystemMsgs,
     ...surfaceSystemMsgs,
     ...selfOpsSystemMsgs,
+    ...selfHealthSystemMsgs,
     ...controllerSystemMsgs,
     ...implDisciplineSystemMsgs,
     ...concisenessSystemMsgs,
@@ -297,6 +342,7 @@ function buildDashboardTurnPreambleUnmeasured(
         gitSnapshot: gitSnapshotSystemMsgs.length,
         surface: surfaceSystemMsgs.length,
         selfOps: selfOpsSystemMsgs.length,
+        selfHealth: selfHealthSystemMsgs.length,
         controller: controllerSystemMsgs.length,
         implDiscipline: implDisciplineSystemMsgs.length,
         conciseness: concisenessSystemMsgs.length,

package/src/dashboard/turn-stream-formatter.ts

@@ -18,6 +18,8 @@ import { debug } from '../debug/log.js';
 import { renderToolBlock } from '../chat/tool-render/block.js';
 import type { ToolRenderModel } from '../chat/tool-render/types.js';
 import { toolOperationKind, type FoldMode } from '../log-entry.js';
+import { sep } from 'node:path';
+import { toolResultsRoot } from '../tool-runtime/truncation-store.js';
 import { stripAnsi } from '../tui.js';
 import type { TurnStreamPresentationEvent } from './turn-stream-presentation-applier.js';
 import { buildFoldedTailLine, splitNoSynthesisTail } from './chat-fold.js';
@@ -161,6 +163,24 @@ export interface TurnStreamFormatter {
   onText(chunk: string, accumulated: string): void;
   onToolCall(call: TurnStreamCall): void;
   onToolResult(call: TurnStreamCall): void;
+  /** TUI-TURN-NARRATION — 추론 요약 한 문단을 흐린 💭 한 줄로 남긴다(결함 #87). */
+  onThought?(text: string): void;
+}
+
+/** 잡무 도구를 접을 때의 종류 이름 — `… (N 내부)`. */
+export const BOOKKEEPING_KIND = '내부';
+const BOOKKEEPING_TOOLS = new Set(['MsgList', 'MsgAck', 'ScheduleWakeup']);
+/** 도구 결과가 길어 넘침 파일로 빠진 것을 다시 읽는 Read — 사람에게는 «같은 결과를 이어 읽음» 이다.
+ *  ⛔ 부분 문자열이 아니라 «실제 넘침 뿌리» 아래인지로 가린다(#28968 리뷰 FU-5 — 남의 같은 이름 경로를 접지 않게). */
+export function isBookkeepingTool(
+  kind: string,
+  args: Record<string, unknown>,
+  spillRoot: string = toolResultsRoot(),
+): boolean {
+  if (BOOKKEEPING_TOOLS.has(kind)) return true;
+  if (kind !== 'Read') return false;
+  const path = args.file_path ?? args.path;
+  return typeof path === 'string' && path.startsWith(`${spillRoot}${sep}`);
 }
 
 export function createTurnStreamFormatter(
@@ -168,6 +188,9 @@ export function createTurnStreamFormatter(
 ): TurnStreamFormatter {
   const groupingKind = (name: string, args: Record<string, unknown>): string | undefined => {
     const kind = toolOperationKind(name, args);
+    // TUI-TURN-NARRATION 조각 3 — 사람이 볼 필요 없는 잡무 도구(우편 확인·깨움 예약 · 넘침 파일 읽기)는
+    //   «내부» 한 종류로 묶어, 연달아 오면 «… (N 내부)» 한 줄로 접는다(결함 #87 화면 소음).
+    if (deps.foldMode && deps.foldMode !== 'line' && isBookkeepingTool(kind, args)) return BOOKKEEPING_KIND;
     return deps.foldMode === 'kind-unit' || (deps.foldMode === 'task-unit' && kind === 'RunShell')
       ? kind
       : undefined;
@@ -189,6 +212,7 @@ export function createTurnStreamFormatter(
   const nonGenericCallIds = new Set<string>();
   let toolCallCount = 0;
   let noSynthesisTailCount = 0;
+  let thoughtCount = 0;
 
   const emitAssistantBlock = (): void => {
     deps.thinking.update('Streaming');
@@ -265,6 +289,13 @@ export function createTurnStreamFormatter(
       }
       emitAssistantBlock();
     },
+    onThought(text: string): void {
+      const line = text.replace(/\s+/g, ' ').trim();
+      if (line.length === 0) return;
+      // 생각 줄은 답 글 «사이»에 끼지 않게 지금까지의 라운드 글을 닫고 붙인다.
+      closeRound();
+      deps.emit({ type: 'tool.appendLine', callId: `thought-${++thoughtCount}`, line: deps.muted(`💭 ${line}`) });
+    },
     onToolCall(call: TurnStreamCall): void {
       toolCallCount += 1;
       deps.thinking.update(`Streaming ${call.name} (${toolCallCount} ${toolCallCount === 1 ? 'tool' : 'tools'})`);
@@ -338,7 +369,9 @@ export function createTurnStreamFormatter(
         collapsedLines: variants.collapsed,
         expandedLines: variants.expanded,
         ...(groupingKind(call.name, args)
-          ? { operationKind: deps.foldMode === 'task-unit'
+          ? { operationKind: groupingKind(call.name, args) === BOOKKEEPING_KIND
+            ? BOOKKEEPING_KIND
+            : deps.foldMode === 'task-unit'
             ? 'RunShell'
             : ('operationKind' in variants ? variants.operationKind : undefined) ?? toolOperationKind(call.name, args) }
           : {}),

package/src/dashboard/turn-stream-runtime.ts

@@ -66,6 +66,7 @@ export interface DashboardTurnStreamRuntime {
   onText(chunk: string, accumulated: string): void;
   onToolCall(call: DashboardTurnStreamCall): void;
   onToolResult(call: DashboardTurnStreamCall): void;
+  onThought?(text: string): void;
 }
 
 export function createDashboardTurnStreamRuntime(
@@ -102,5 +103,6 @@ export function createDashboardTurnStreamRuntime(
     onText: formatter.onText,
     onToolCall: formatter.onToolCall,
     onToolResult: formatter.onToolResult,
+    ...(formatter.onThought ? { onThought: formatter.onThought } : {}),
   };
 }

package/src/dashboard/turn-typeahead-prompt-zone.ts

@@ -0,0 +1,67 @@
+import { debug } from '../debug/log.js';
+import type { LayoutZone } from '../layout/composer.js';
+import {
+  drawTurnTypeaheadPromptRows,
+  type TurnTypeaheadPromptPaintSink,
+  type TurnTypeaheadPromptRowsInput,
+} from './input/turn-typeahead-prompt.js';
+
+/** Dashboard draw entry for the input-prompt zone. Streaming redraws reach
+ * this production binding through the zone renderer below. */
+export function drawDashboardTurnTypeaheadPromptRows(
+  input: TurnTypeaheadPromptRowsInput,
+  sink?: TurnTypeaheadPromptPaintSink,
+): string[] {
+  return drawTurnTypeaheadPromptRows(input, sink);
+}
+
+/** Essential frames own the fallback prompt caret; Z-axis state only wins
+ * when a modal has made a visible claim. */
+export function buildDashboardTurnTypeaheadPromptZone(input: TurnTypeaheadPromptRowsInput & {
+  suppressPromptArea: boolean;
+}): LayoutZone {
+  return {
+    id: 'input-prompt',
+    height: input.frame.inputHeight,
+    render: (height, width) => {
+      if (input.suppressPromptArea) return Array.from({ length: height }, () => ' '.repeat(width));
+      return drawDashboardTurnTypeaheadPromptRows({ ...input, height, width });
+    },
+  };
+}
+
+/** 프롬프트 zone 에 관측만 덧입힌다 — 렌더 산출은 `inner` 가 소유한다.
+ *
+ *  ⭐ **왜 뽑았나**(무인 리뷰 must-fix · 2026-08-01): 종전엔 이 래퍼가 `zones.push({...})` 안에
+ *  인라인이라, 테스트가 `inner`(=`buildDashboardTurnTypeaheadPromptZone`)만 불러도 통과했다.
+ *  ⇒ ***래퍼가 `inner.render` 를 부르는 것을 끊어도 검사가 침묵***했다. 이제 그 결선이 검사된다.
+ *
+ *  ⛔⚠️ **여전히 검사 밖인 한 겹**: 이 함수의 반환이 실제로 `zones` 배열에 **push 되는지**는
+ *  `showDashboard` 안의 지역 조립부라 단위 검사가 닿지 않는다. ***무한 후퇴이므로 여기서 경계를 긋는다*** —
+ *  그 한 겹은 **라이브 검증**(`dev --elanous --hold` ⊕ `pty snapshot`)이 맡는다. */
+export function observeDashboardTurnTypeaheadPromptZone(
+  inner: LayoutZone,
+  deps: {
+    promptBottomRow: number;
+    state: { buffer: string; queuedSubmissions: string[] };
+    isDebugEnabled?: () => boolean;
+    log?: (category: string, event: string, data: Record<string, unknown>) => void;
+  },
+): LayoutZone {
+  return {
+    ...inner,
+    render: (height, width) => {
+      const rows = inner.render(height, width);
+      const enabled = deps.isDebugEnabled ? deps.isDebugEnabled() : debug.enabled;
+      if (deps.state.buffer && enabled) {
+        (deps.log ?? ((c, e, d) => debug.log(c, e, d)))('dashboard.turn-typeahead-prompt', 'dashboard-draw-prompt', {
+          row: deps.promptBottomRow,
+          text: rows.at(-1) ?? '',
+          bufferLength: deps.state.buffer.length,
+          queuedSubmissionCount: deps.state.queuedSubmissions.length,
+        });
+      }
+      return rows;
+    },
+  };
+}

package/src/domains/guardian-tick.ts

@@ -1,4 +1,5 @@
 import type { Database } from 'bun:sqlite';
+import { hostname } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { debug } from '../debug/log.js';
 import { calendarFields, resolveTimeZone } from '../time/format.js';
@@ -16,6 +17,43 @@ export interface GuardianDeps {
   config?: { guardian?: { mode?: 'shadow' | 'live' } };
   /** Inject a cron-run-compatible executor in tests; shadow never calls it. */
   execute?: (command: string) => Promise<SpawnOutcome>;
+  /** Injected only for deterministic expiry-alert tests. Production reads the local Grok auth file. */
+  grokExpiry?: () => string | null;
+  hostName?: string;
+}
+
+export const GROK_EXPIRY_ALERT_WINDOW_MS = 4 * 60 * 60 * 1000;
+
+function durationLabel(ms: number): string {
+  const minutes = Math.max(0, Math.ceil(ms / 60_000));
+  const hours = Math.floor(minutes / 60);
+  const rest = minutes % 60;
+  return hours ? `${hours}h${String(rest).padStart(2, '0')}m` : `${rest}m`;
+}
+
+/** Return a token-free alert line only when expiry is within four hours (or already past). */
+export function grokExpiryAlertLine(opts: {
+  now: Date; expiresAt: string | null; host?: string;
+}): string | null {
+  if (!opts.expiresAt) return null;
+  const expiresAtMs = Date.parse(opts.expiresAt);
+  if (!Number.isFinite(expiresAtMs)) return null;
+  const remainingMs = expiresAtMs - opts.now.getTime();
+  if (remainingMs > GROK_EXPIRY_ALERT_WINDOW_MS) return null;
+  return `Grok 자격 만료 경보 · host=${opts.host ?? hostname()} · expires=${new Date(expiresAtMs).toISOString()} · remaining=${remainingMs <= 0 ? '만료됨' : durationLabel(remainingMs)} · device-auth=https://accounts.x.ai/oauth2/device · 코드 생성/Allow는 OP(grok login --device-auth)`;
+}
+
+export function grokExpiryStatusLine(opts: {
+  now: Date; expiresAt: string | null; host?: string;
+}): string {
+  const host = opts.host ?? hostname();
+  if (!opts.expiresAt) return `Grok 자격 만료 확인 · host=${host} · expires=unknown · alert=not-set`;
+  const expiresAtMs = Date.parse(opts.expiresAt);
+  if (!Number.isFinite(expiresAtMs)) return `Grok 자격 만료 확인 · host=${host} · expires=invalid · alert=not-set`;
+  const remainingMs = expiresAtMs - opts.now.getTime();
+  const remaining = remainingMs <= 0 ? '만료됨' : durationLabel(remainingMs);
+  const alert = remainingMs <= GROK_EXPIRY_ALERT_WINDOW_MS ? 'active' : `in ${durationLabel(remainingMs - GROK_EXPIRY_ALERT_WINDOW_MS)}`;
+  return `Grok 자격 만료 확인 · host=${host} · expires=${new Date(expiresAtMs).toISOString()} · remaining=${remaining} · 4h-alert=${alert}`;
 }
 
 function shellQuote(value: string): string {
@@ -45,9 +83,23 @@ function liveCommand(jobId: string, raw: string): string {
 }
 
 /** One five-minute guardian observation. No schedule state or crontab is mutated in shadow mode. */
-export async function guardianTick(now: Date, plan: GuardianPlan, deps: GuardianDeps = {}): Promise<{ mode: 'shadow' | 'live'; wouldRun: string[]; executed: number }> {
+export async function guardianTick(now: Date, plan: GuardianPlan, deps: GuardianDeps = {}): Promise<{ mode: 'shadow' | 'live'; wouldRun: string[]; executed: number; credentialAlert?: string }> {
   if (!Number.isFinite(now.getTime())) throw new RangeError('invalid tick time');
   const mode = deps.config?.guardian?.mode === 'live' ? 'live' : 'shadow';
+  let expiryLine: string | null = null;
+  try {
+    const expiryAt = deps.grokExpiry ? deps.grokExpiry() : (await import('../grok/credential.js')).readGrokSubscriptionExpiry();
+    expiryLine = grokExpiryAlertLine({
+      now,
+      expiresAt: expiryAt,
+      ...(deps.hostName ? { host: deps.hostName } : {}),
+    });
+    if (expiryLine) debug.log('guardian.credential-expiry', 'warning', { line: expiryLine });
+  } catch (error) {
+    debug.log('guardian.credential-expiry', 'read-failed', {
+      errorName: error instanceof Error ? error.name : 'unknown',
+    });
+  }
   const timeZone = plan.timeZone ?? resolveTimeZone().timeZone;
   const wouldRun: string[] = [];
   let executed = 0;
@@ -64,7 +116,7 @@ export async function guardianTick(now: Date, plan: GuardianPlan, deps: Guardian
       if (outcome.code !== 0) throw new Error(`guardian job ${job.id} exited ${outcome.code}`);
     }
   }
-  return { mode, wouldRun, executed };
+  return { mode, wouldRun, executed, ...(expiryLine ? { credentialAlert: expiryLine } : {}) };
 }
 
 export interface GuardianDayDeps {

package/src/domains/outbound-alert.ts

@@ -203,8 +203,8 @@ function deliverToOrigin(origin: MissionOrigin, text: string, onBot?: (bot: stri
   if (origin.channel !== 'telegram' || origin.chatId == null) return false;
   const token = resolveBotToken(origin.botId);
   if (!token) return false;
-  onBot?.(botLabel(token));
   assertTestSendFaked('send a real Telegram message to the origin');
+  onBot?.(botLabel(token));
   try { return sendTelegramRaw(token, origin.chatId, text, origin.threadId); } catch { return false; }
 }
 
@@ -742,7 +742,7 @@ export function sendTelegramDirect(
     } catch { /* unavailable main bot */ }
     const rcToken = cfg?.telegram.reportChannel?.botToken;
     logKindRouteFallback(kind, home ? 'main-home' : 'none', !!mainToken && !!cfg?.telegram.reportChannel && (!rcToken || rcToken === mainToken));
-    if (home) { onBot?.(botLabel(home.botToken)); return sendRaw(home.botToken, String(home.chatId), text); }
+    if (home) { assertTestSendFaked('send a real Telegram message', !deps.sendRaw); onBot?.(botLabel(home.botToken)); return sendRaw(home.botToken, String(home.chatId), text); }
     console.error('[outbound] 운영 kind 메인 봇/홈 미설정 — 콘솔 출력\n' + text);
     return false;
   }
@@ -755,6 +755,7 @@ export function sendTelegramDirect(
   }
   logKindRouteFallback(kind, tok && chat ? 'conatus-env' : 'none', false);
   if (!tok || !chat) { console.error('[outbound] 토큰/chat 미설정 — 콘솔 출력\n' + text); return false; }
+  assertTestSendFaked('send a real Telegram message', !deps.sendRaw);
   onBot?.(botLabel(tok));
   return sendRaw(tok, chat, text);
 }

package/src/extractors.ts

@@ -8,7 +8,6 @@
 // not the v1 default-function export. Verified at Phase 0 smoke test.
 
 import { readFile } from 'fs/promises';
-import { PDFParse } from 'pdf-parse';
 import mammoth from 'mammoth';
 import * as XLSX from 'xlsx';
 
@@ -69,6 +68,9 @@ export async function readText(path: string): Promise<ExtractResult> {
 
 export async function extractPdf(path: string): Promise<ExtractResult> {
   const buf = await readFile(path);
+  // pdf-parse loads pdfjs-dist and @napi-rs/canvas (system fonts) at import time.
+  // A plain text/CLI help request must not pay for the PDF renderer.
+  const { PDFParse } = await import('pdf-parse');
   const parser = new PDFParse({ data: new Uint8Array(buf) });
   try {
     const result = await parser.getText();

package/src/git-fs/retry.ts

@@ -4,6 +4,7 @@ const MAX_GIT_RETRY_ATTEMPTS = 6;
 export type GitRunResult = {
   status: number | null;
   signal?: NodeJS.Signals | null;
+  errorCode?: string;
   stdout: string;
   stderr: string;
 };
@@ -43,6 +44,9 @@ export function runGitWithRetry(
       if (attempt > 1) onRetrySuccess?.(attempt);
       return result;
     }
+    // A killed or timed-out process did not report a Git failure. Its partial
+    // output may mention a lock, but repeating the checkout hides its cause.
+    if (result.status === null) return result;
     const error = result.stderr || result.stdout || '';
     if (!isTransientGitError(error) || attempt === MAX_GIT_RETRY_ATTEMPTS) return result;
     sleepSyncMs(80 * attempt);

package/src/git-fs/runner.ts

@@ -27,9 +27,11 @@ export function runGitCommand(
   const run = runner ?? ((gitArgs: string[]): GitRunResult => {
     if (testRunner) return testRunner(cwd, gitArgs, options);
     const result = spawnSync('git', gitArgs, { ...options, cwd });
+    const errorCode = (result.error as NodeJS.ErrnoException | undefined)?.code;
     return {
       status: result.status,
       ...(result.signal ? { signal: result.signal } : {}),
+      ...(errorCode ? { errorCode } : {}),
       stdout: outputText(result.stdout),
       stderr: outputText(result.stderr),
     };