elanous 0.2.35 → 0.2.37

package/src/tui/chat/goal-interim.ts

@@ -0,0 +1,177 @@
+// ── 골 중간 답 접기 `goal-interim` (TUI-GOAL-INTERIM-QUIET 조각 2 · 2026-10-22 · 대표 «대화 연결이 이상하다») ──────
+//
+// 🚨 무엇을 푸는가: 골 하나를 도는 동안 작은 단계마다 턴이 끝나고(«…아직 못 했습니다»·«…하겠습니다»),
+//   goal-continue / child-complete 내부 턴이 다시 열린다. 그 사이 «못 했다» 문단이 대화에 단계 수만큼 쌓이고
+//   (n8n 세션 10-22 22:4x), next TUI 는 내부 턴 입력을 «나: [골 이어가기] …» 로 사람 발화처럼 그렸다.
+// ⭐ 이 모듈은 «그리는 층»의 판정만 한다(순수):
+//   ① 내부 턴 입력 글(우리 포매터가 만든 접두)을 알아본다 → 사람 머리(«나:»·«❯») 대신 «↻ 자동 재개(<origin>)».
+//   ② 내부 이어가기 턴 «바로 앞» 답이 중간 보고(못 했다·약속)면 한 줄 «· 진행 — <첫 줄> (접힘)» 로 접는다.
+//      마지막 답(골 끝·막힘)은 접지 않는다 → 미완 목록 문단은 한 번만 남는다.
+// ⛔ 세션 기록·모델 입력은 그대로다(화면만 접는다). 판정이 애매하면 접지 않는다(정보를 숨기지 않는 쪽).
+//
+// 세 얼굴:
+//   관측 = debug.log('tui.goal-interim', 'folded' | 'kept', { surface:'classic', origin, reason, lines }) ·
+//          next 는 턴 끝마다 접힘 수가 바뀌면 'folded' { surface:'next', folded, internal } (src/tui/entry.ts)
+//   인지 = 다음 턴이 내부 이어가기인가 ∧ 앞 답이 중간 보고 꼴인가 ∧ (classic) 그 줄들이 아직 제자리인가
+//   힐링 = 앞 문단을 한 줄로 접는다 · 줄이 움직였으면(버퍼 잘림·끼워 넣은 에코) 접지 않고 'kept' 사유를 남긴다
+
+import { debug } from '../../debug/log.js';
+import { classifyReplyTail, replyTailFromLines } from '../../chat/goal-continue-verdict.js';
+import type { InternalTurnOrigin } from '../../chat/internal-turn-origin.js';
+
+/** 내부 턴 입력 접두 — goal-continue.ts `formatGoalContinuePrompt` · agent-wake.ts `formatAgentWakePrompt` ·
+ *  seat-autowake.ts `formatSeatAutowakePrompt` 와 같아야 한다(goal-interim.test.ts 가 세 포매터를 문다). */
+const INTERNAL_TURN_TEXT_PREFIXES: ReadonlyArray<{ prefix: string; origin: InternalTurnOrigin }> = [
+  { prefix: '[골 이어가기] ', origin: 'goal-continue' },
+  { prefix: '[자동 재개] 위임 끝: ', origin: 'child-complete' },
+  { prefix: '[자동 재개] 남은 일: ', origin: 'autowake' },
+];
+
+/** 이 글이 우리가 연 내부 턴의 입력이면 그 출처, 아니면 null(사람 글). */
+export function internalTurnOriginOfText(text: string): InternalTurnOrigin | null {
+  const head = text.trimStart();
+  for (const { prefix, origin } of INTERNAL_TURN_TEXT_PREFIXES) if (head.startsWith(prefix)) return origin;
+  return null;
+}
+
+/** 앞 답을 접는 이어가기 출처 — 같은 골을 «이어서» 도는 턴만(goal-continue · child-complete).
+ *  autowake(«남은 일: 우편·큐»)·예약·우편 깨움은 새 일이라 앞 답을 건드리지 않는다(입력 줄 머리만 바꾼다). */
+const FOLDING_ORIGINS: ReadonlySet<InternalTurnOrigin> = new Set(['goal-continue', 'child-complete']);
+function isFoldingOrigin(origin: InternalTurnOrigin | null | undefined): boolean {
+  return origin != null && FOLDING_ORIGINS.has(origin);
+}
+
+// eslint-disable-next-line no-control-regex
+const ANSI = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+/** 답이 아닌 줄(턴 상태·도구·배너) — goal-continue 의 NON_REPLY 와 같은 뜻. */
+const NON_REPLY_LINE = /^\s*(?:✔ 완료|✘ 실패|응답 완료|응답 중|라우팅:|󰧑|⚙️|도구:|나:|↻ 자동 재개|⏰|⏸|⏹|❯|[─━]{3,})/u;
+
+/** 미완 고백 — «못 했다 / 보고할 수 없다 / 아직 안 됐다» ⊕ 영어. */
+const INCOMPLETE_RE = new RegExp([
+  '못\\s?했',
+  '하지\\s?못(?:했|함|하였)',
+  '(?:완료|끝내|마치|만들|보고하)지\\s?못',
+  '보고할\\s?수\\s?없',
+  '아직\\s?(?:안\\s?(?:됐|되었|끝)|없습니다|미완)',
+  "couldn['’]t",
+  'could not',
+  "was(?:n['’]t| not) able",
+  'unable to',
+  'not (?:yet )?(?:done|finished|completed?)\\b',
+].join('|'), 'iu');
+
+export type InterimVerdict =
+  | { interim: true; reason: 'incomplete' | 'pledge'; summary: string }
+  | { interim: false; reason: 'no-reply' | 'final' };
+
+/** 답 줄(색 코드 포함 가능)이 «중간 보고»인가 — 미완 고백 또는 약속으로 끝난 답. */
+export function classifyInterimReply(lines: readonly string[]): InterimVerdict {
+  const plain = lines.map((l) => l.replace(ANSI, '').trim()).filter((l) => l && !NON_REPLY_LINE.test(l));
+  if (plain.length === 0) return { interim: false, reason: 'no-reply' };
+  const summary = plain[0]!.replace(/^엘라누스:\s*/u, '');
+  // 끝 문장만 본다 — 중간의 «X 는 못 했지만 Y 는 끝냈다» 한 구절로 결과 답을 접지 않는다(goal-continue 와 같은 규칙).
+  const tail = replyTailFromLines(lines);
+  const last = tail ? (tail.split(/(?<=[.!?。？])\s+/u).filter(Boolean).at(-1) ?? tail) : '';
+  if (INCOMPLETE_RE.test(last)) return { interim: true, reason: 'incomplete', summary };
+  if (classifyReplyTail(tail).pledge) return { interim: true, reason: 'pledge', summary };
+  return { interim: false, reason: 'final' };
+}
+
+const SUMMARY_CHARS = 60;
+/** 접힌 한 줄 — «· 진행 — <첫 줄> (접힘)». */
+export function formatInterimFoldLine(summary: string): string {
+  const flat = summary.replace(/\s+/g, ' ').trim();
+  const cut = [...flat].length > SUMMARY_CHARS ? `${[...flat].slice(0, SUMMARY_CHARS).join('')}…` : flat;
+  return `· 진행 — ${cut} (접힘)`;
+}
+
+// ── next: 세션 메시지 위의 그리기 계획(순수) ─────────────────────────────────────────────
+
+export type InterimDisplay =
+  | { kind: 'internal-input'; origin: InternalTurnOrigin }
+  | { kind: 'folded'; line: string };
+
+/** 메시지 인덱스 → 그리기 바꿈. 내부 턴 입력은 출처 한 줄, 그 «바로 앞» 중간 보고 답은 한 줄로 접는다. */
+export function planInterimDisplay(messages: ReadonlyArray<{ role: string; content?: unknown; goalInterim?: boolean }>): Map<number, InterimDisplay> {
+  const plan = new Map<number, InterimDisplay>();
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i]!;
+    if (m.role === 'assistant' && m.goalInterim === true && typeof m.content === 'string') {
+      const verdict = classifyInterimReply(m.content.split('\n'));
+      if (verdict.interim) plan.set(i, { kind: 'folded', line: formatInterimFoldLine(verdict.summary) });
+    }
+    if (m.role !== 'user' || typeof m.content !== 'string') continue;
+    const origin = internalTurnOriginOfText(m.content);
+    if (!origin) continue;
+    plan.set(i, { kind: 'internal-input', origin });
+    if (!isFoldingOrigin(origin)) continue;
+    // 앞 사람/내부 입력 뒤의 마지막 답 하나만 — 도구 블록은 그대로 둔다.
+    for (let j = i - 1; j >= 0; j--) {
+      const prev = messages[j]!;
+      if (prev.role === 'user') break;
+      if (prev.role !== 'assistant' || typeof prev.content !== 'string') continue;
+      const verdict = classifyInterimReply(prev.content.split('\n'));
+      if (verdict.interim) plan.set(j, { kind: 'folded', line: formatInterimFoldLine(verdict.summary) });
+      break;
+    }
+  }
+  return plan;
+}
+
+/** 계획의 접힌 답 수 ⊕ 내부 입력 줄 수 — next 관측용. */
+export function countInterimDisplay(plan: ReadonlyMap<number, InterimDisplay>): { folded: number; internal: number } {
+  let folded = 0;
+  let internal = 0;
+  for (const d of plan.values()) { if (d.kind === 'folded') folded += 1; else internal += 1; }
+  return { folded, internal };
+}
+
+// ── classic: 화면 줄(chatLines) 위의 접기 상태 ──────────────────────────────────────────
+
+export interface ClassicInterimFoldDeps {
+  /** 접어도 되는 때인가 — 대시보드는 «끼워 넣은 사람 에코가 없다»를 넘긴다(줄 위치가 확실할 때만). */
+  canFold?: () => boolean;
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+}
+
+export interface ClassicInterimFold {
+  /** 턴이 끝났다 — 이번 턴의 «마지막 답 블록» 시작(스트림 applier 의 assistantStart)부터 끝까지를 사본으로 잡는다.
+   *  도구·라우팅 줄은 그 앞이라 접히지 않는다(next 가 답 메시지만 접는 것과 같다). */
+  noteTurnEnded(chatLines: readonly string[], start: number): void;
+  /** 사람이 턴을 열었다 — 잡아 둔 답을 놓는다(사람 턴 앞 답은 접지 않는다). */
+  noteHumanTurn(): void;
+  /** 내부 이어가기 턴이 막 열린다 — 잡아 둔 앞 답이 중간 보고면 그 자리를 한 줄로 바꾼다. */
+  foldBeforeInternalTurn(chatLines: string[], origin: InternalTurnOrigin, style?: (line: string) => string): { folded: boolean; reason: string };
+}
+
+export function createClassicInterimFold(deps: ClassicInterimFoldDeps = {}): ClassicInterimFold {
+  const log = deps.log ?? ((c, e, d) => debug.log(c, e, d));
+  let last: { start: number; lines: string[] } | null = null;
+  const kept = (origin: InternalTurnOrigin, reason: string, extra: Record<string, unknown> = {}) => {
+    log('tui.goal-interim', 'kept', { surface: 'classic', origin, reason, ...extra });
+    return { folded: false, reason };
+  };
+  return {
+    noteTurnEnded(chatLines, start) {
+      const from = Math.max(0, Math.min(start, chatLines.length));
+      last = { start: from, lines: chatLines.slice(from) };
+    },
+    noteHumanTurn() { last = null; },
+    foldBeforeInternalTurn(chatLines, origin, style = (l) => l) {
+      const snap = last;
+      last = null;
+      if (!isFoldingOrigin(origin)) return kept(origin, 'not-continuation');
+      if (!snap || snap.lines.length === 0) return kept(origin, 'no-previous-reply');
+      if (deps.canFold && !deps.canFold()) return kept(origin, 'lines-unstable');
+      // 그 줄들이 아직 제자리인가 — 버퍼 앞이 잘렸거나 무엇이 끼어들었으면 위치를 믿지 않는다.
+      const here = chatLines.slice(snap.start, snap.start + snap.lines.length);
+      if (here.length !== snap.lines.length || here.some((line, k) => line !== snap.lines[k])) return kept(origin, 'lines-moved');
+      const verdict = classifyInterimReply(snap.lines);
+      if (!verdict.interim) return kept(origin, verdict.reason);
+      const line = formatInterimFoldLine(verdict.summary);
+      chatLines.splice(snap.start, snap.lines.length, style(`  ${line}`));
+      log('tui.goal-interim', 'folded', { surface: 'classic', origin, reason: verdict.reason, lines: snap.lines.length });
+      return { folded: true, reason: verdict.reason };
+    },
+  };
+}

package/src/tui/chat/log-view.ts

@@ -1,5 +1,7 @@
 import type { SerializedMessage } from '../../session/index.js';
 import { redactSecretText } from '../../debug/log.js';
+import { planInterimDisplay, type InterimDisplay } from './goal-interim.js';
+import { parseToolResultEnvelope, toolResultBodyText, toolResultErrorText } from '../../chat/tool-render/result-text.js';
 
 const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
 
@@ -53,28 +55,213 @@ export function wheelScroll(scroll: number, direction: 'up' | 'down', maxScroll:
   return Math.max(0, Math.min(limit, next));
 }
 
-/** Ephemeral reply preview until the persisted assistant message replaces it. */
-export function streamReplyLines(text: string, columns: number): string[] {
-  const parts = safeLogText(text).split('\n');
-  const lines = parts.flatMap((part, index) => wrapLine(`${index === 0 ? '엘라누스: ' : '  '}${part}`, columns));
-  return lines.slice(-80);
+/** Tool output longer than this many wrapped lines renders collapsed to one line. */
+export const TOOL_FOLD_LINE_LIMIT = 9;
+
+/**
+ * Collapsed single-line summary for a long tool output (the cell's «▸ 도구 <이름> · N줄 (접힘)»).
+ * With `columns`, a long name is shortened with «…» so the line count and fold marker stay
+ * visible; if even that cannot fit, the whole line is cut to the width.
+ */
+export function toolFoldSummary(toolName: string, totalLines: number, columns?: number): string {
+  const prefix = '▸ 도구 ';
+  const suffix = ` · ${totalLines}줄 (접힘)`;
+  const name = safeStatusText(toolName);
+  const full = `${prefix}${name}${suffix}`;
+  if (columns === undefined || Bun.stringWidth(full) <= columns) return full;
+  const room = columns - Bun.stringWidth(prefix) - Bun.stringWidth(suffix) - 1; // 1 cell for «…»
+  if (room < 1) return fitLogLine(full, columns);
+  let short = '';
+  let used = 0;
+  for (const { segment } of segmenter.segment(name)) {
+    const cells = Bun.stringWidth(segment);
+    if (used + cells > room) break;
+    short += segment;
+    used += cells;
+  }
+  return `${prefix}${short}…${suffix}`;
+}
+
+/**
+ * What a tool block shows (TUI-NEXT-TOOL-RESULT-RENDER). The persisted result is a JSON
+ * envelope string (`{"output":"…\n…","linesRead":20,…}`); showing it raw put the whole
+ * file on one wrapped line with escaped `\n`, so the fold never triggered. The envelope
+ * is parsed back and its human text taken with the classic renderer's own extractor
+ * (chat/tool-render/result-text.ts); a short status («20줄 · 251B» · «exit 0» · «오류»)
+ * stays on the header line. A plain-text result keeps the old layout (`envelope: false`).
+ */
+interface ToolDisplay { envelope: boolean; status: string; body: string }
+
+function formatToolBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+function toolDisplay(message: SerializedMessage): ToolDisplay {
+  const raw = typeof message.toolResult === 'string' ? message.toolResult : '';
+  const parsed = parseToolResultEnvelope(raw);
+  if (typeof parsed.value === 'string' || parsed.value === null || typeof parsed.value !== 'object') {
+    return { envelope: false, status: '', body: safeLogText(raw) };
+  }
+  const record = parsed.value as Record<string, unknown>;
+  const error = toolResultErrorText(record);
+  const status: string[] = [];
+  if (error !== null) status.push('오류');
+  if (typeof record.totalLines === 'number') status.push(`${record.totalLines}줄`);
+  if (typeof record.totalBytes === 'number') status.push(formatToolBytes(record.totalBytes));
+  if (typeof record.exitCode === 'number') status.push(`exit ${record.exitCode}`);
+  if (record.truncated === true || parsed.truncated) status.push('잘림');
+  const text = error ?? toolResultBodyText(record) ?? '';
+  // Tabs (Read's «     1\tline» gutter) would be dropped as control characters — keep them as a space.
+  return { envelope: true, status: status.join(' · '), body: safeLogText(text.replace(/\t/g, ' ')) };
 }
 
-/** Plain, width-bounded history; no terminal control bytes from stored messages. */
-export function logViewLines(messages: readonly SerializedMessage[], columns: number): string[] {
+/** Tool output that is not finished yet (no result) must never fold. */
+function toolLinesUnfolded(message: SerializedMessage, columns: number): string[] {
+  const label = safeLogText(message.toolName || '실행');
+  const display = toolDisplay(message);
   const lines: string[] = [];
-  for (const message of messages) {
-    if (message.role !== 'user' && message.role !== 'assistant' && message.role !== 'tool') continue;
-    const label = message.role === 'user' ? '나: ' : message.role === 'tool' ? '도구: ' : '엘라누스: ';
-    const content = safeLogText(message.role === 'tool'
-      ? `${message.toolName || '실행'} ${typeof message.toolResult === 'string' ? message.toolResult : ''}`
-      : message.content);
-    const parts = content.split('\n');
-    for (let i = 0; i < parts.length; i++) {
-      const prefix = i === 0 ? label : '  ';
-      lines.push(...wrapLine(prefix + parts[i], columns));
+  if (display.envelope) {
+    lines.push(...wrapLine(`도구: ${label}${display.status ? ` · ${display.status}` : ''}`, columns));
+    for (const part of display.body.split('\n')) lines.push(...wrapLine(`  ${part}`, columns));
+    return lines;
+  }
+  const parts = `${label} ${display.body}`.split('\n');
+  for (let i = 0; i < parts.length; i++) {
+    const prefix = i === 0 ? '도구: ' : '  ';
+    lines.push(...wrapLine(prefix + parts[i], columns));
+  }
+  return lines;
+}
+
+/** Wrapped line count of a finished tool's output alone (label and tool name excluded) — the fold measure. */
+function toolOutputLineCount(message: SerializedMessage, columns: number): number {
+  return toolDisplay(message).body.split('\n').reduce((sum, part) => sum + wrapLine(`  ${part}`, columns).length, 0);
+}
+
+/**
+ * History view with tool-output folding. A finished tool output over
+ * TOOL_FOLD_LINE_LIMIT wrapped lines renders as one collapsed summary line
+ * unless its message index is in `expandedToolIndexes`; a tool block that is
+ * still running (no result yet) never folds.
+ */
+/** One message's rendered lines (with its trailing blank separator). `display` is the goal-interim plan entry:
+ *  an internal turn's input draws as its origin line (not «나: …»), and a folded interim reply as one line. */
+function messageLines(
+  message: SerializedMessage,
+  index: number,
+  columns: number,
+  expandedToolIndexes: ReadonlySet<number> | undefined,
+  display: InterimDisplay | undefined,
+): string[] {
+  if (message.role === 'tool') {
+    const running = message.toolResult === undefined;
+    const outputLines = running ? 0 : toolOutputLineCount(message, columns);
+    if (running || outputLines <= TOOL_FOLD_LINE_LIMIT || expandedToolIndexes?.has(index)) {
+      return [...toolLinesUnfolded(message, columns), ''];
     }
-    lines.push('');
+    return [toolFoldSummary(message.toolName || '실행', outputLines, columns), ''];
+  }
+  // TUI-GOAL-INTERIM-QUIET — 내부 턴 입력은 사람 머리 없이 출처 한 줄 · 이어가기 앞 중간 보고는 한 줄로 접는다.
+  if (display?.kind === 'internal-input') return [fitLogLine(`↻ 자동 재개(${display.origin})`, columns), ''];
+  if (display?.kind === 'folded') return [...wrapLine(`엘라누스: ${display.line}`, columns), ''];
+  const lines: string[] = [];
+  const label = message.role === 'user' ? '나: ' : '엘라누스: ';
+  const parts = safeLogText(message.content).split('\n');
+  for (let i = 0; i < parts.length; i++) {
+    const prefix = i === 0 ? label : '  ';
+    lines.push(...wrapLine(prefix + parts[i], columns));
+  }
+  lines.push('');
+  return lines;
+}
+
+const isLogRole = (message: SerializedMessage): boolean =>
+  message.role === 'user' || message.role === 'assistant' || message.role === 'tool';
+
+export function logViewLines(
+  messages: readonly SerializedMessage[],
+  columns: number,
+  expandedToolIndexes?: ReadonlySet<number>,
+): string[] {
+  const plan = planInterimDisplay(messages);
+  const lines: string[] = [];
+  for (const [index, message] of messages.entries()) {
+    if (!isLogRole(message)) continue;
+    lines.push(...messageLines(message, index, columns, expandedToolIndexes, plan.get(index)));
   }
   return lines.length > 0 ? lines : ['대화 기록 없음'];
 }
+
+/** Message indexes of tool blocks that would render collapsed (long + finished). */
+export function toolFoldBlockStarts(messages: readonly SerializedMessage[], columns: number): number[] {
+  const starts: number[] = [];
+  for (const [index, message] of messages.entries()) {
+    if (message.role !== 'tool' || message.toolResult === undefined) continue;
+    if (toolOutputLineCount(message, columns) > TOOL_FOLD_LINE_LIMIT) starts.push(index);
+  }
+  return starts;
+}
+
+/** Keys that toggle a folded tool block while the log has focus: Enter or Tab (the cell's keys) and F. */
+export function isToolFoldToggleKey(name: string | undefined): boolean {
+  return name === 'return' || name === 'enter' || name === 'tab' || name === 'f';
+}
+
+/** A foldable tool block's message index and its rendered line range [start, end] in logViewLines. */
+export interface ToolFoldBlockRange { index: number; start: number; end: number }
+
+/**
+ * Line ranges of the foldable tool blocks as logViewLines renders them with `expanded`.
+ * Line positions match logViewLines exactly (it is the same rendering), so a caller's
+ * scroll window over that history can be matched against them.
+ */
+export function toolFoldBlockRanges(
+  messages: readonly SerializedMessage[],
+  columns: number,
+  expanded?: ReadonlySet<number>,
+): ToolFoldBlockRange[] {
+  const foldable = new Set(toolFoldBlockStarts(messages, columns));
+  const plan = planInterimDisplay(messages);
+  const ranges: ToolFoldBlockRange[] = [];
+  let line = 0;
+  for (const [index, message] of messages.entries()) {
+    if (!isLogRole(message)) continue;
+    // Same per-message rendering as logViewLines (lines + one blank separator), interim plan included.
+    const height = messageLines(message, index, columns, expanded, plan.get(index)).length;
+    if (foldable.has(index)) ranges.push({ index, start: line, end: line + height - 2 });
+    line += height;
+  }
+  return ranges;
+}
+
+/**
+ * Expand or fold the foldable tool block on screen nearest the bottom of the visible window
+ * (`view.start` = first visible history line, `view.rows` = visible rows). Returns false when no
+ * foldable block is on screen, so the caller can keep the key's ordinary meaning. Fold state
+ * lives only in `expanded` (screen state) — the session messages are never touched.
+ */
+export function toggleVisibleToolFold(
+  expanded: Set<number>,
+  messages: readonly SerializedMessage[],
+  columns: number,
+  view: { start: number; rows: number },
+): boolean {
+  const top = view.start;
+  const bottom = view.start + Math.max(0, view.rows) - 1;
+  const target = toolFoldBlockRanges(messages, columns, expanded)
+    .filter((range) => range.end >= top && range.start <= bottom)
+    .at(-1);
+  if (!target) return false;
+  if (expanded.has(target.index)) expanded.delete(target.index);
+  else expanded.add(target.index);
+  return true;
+}
+
+/** Ephemeral reply preview until the persisted assistant message replaces it. */
+export function streamReplyLines(text: string, columns: number): string[] {
+  const parts = safeLogText(text).split('\n');
+  const lines = parts.flatMap((part, index) => wrapLine(`${index === 0 ? '엘라누스: ' : '  '}${part}`, columns));
+  return lines.slice(-80);
+}

package/src/tui/chat/self-health-status.ts

@@ -0,0 +1,232 @@
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { debug } from '../../debug/log.js';
+import type { LogRecord } from '../../mss/logging/record.js';
+import { codeRevision } from '../../version/code-revision.js';
+
+export const NEXT_TUI_SELF_HEALTH_WINDOW_MS = 30 * 60_000;
+const MAX_OBSERVATIONS = 512;
+const MAX_SESSION_LINKS = 256;
+
+export interface NextTuiSelfHealthSnapshot {
+  readonly sessionId: string;
+  readonly capturedAt: number;
+  readonly line: string;
+  readonly source: 'installed' | 'checkout' | 'unknown';
+  readonly runningSha: string | null;
+  readonly installedSha: string | null;
+  readonly errorCount: number | null;
+  readonly representativeError: string | null;
+  readonly creditSource: string | null;
+  readonly creditKnown: boolean;
+}
+
+interface Observation {
+  readonly at: number;
+  readonly sessionId: string | null;
+  readonly summary: string;
+  readonly provider?: string;
+}
+
+interface CreditObservation {
+  readonly at: number;
+  readonly sessionId: string | null;
+  readonly source: string;
+}
+
+export interface NextTuiSelfHealthDeps {
+  readonly now?: () => number;
+  readonly runningRevision?: () => string | undefined;
+  readonly installedRevision?: () => string | undefined;
+  readonly loggingLive?: () => boolean;
+}
+
+function object(value: unknown): Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {};
+}
+
+function shortSha(value: string | null | undefined): string | null {
+  return value && /^[0-9a-f]{7,40}$/i.test(value) ? value.slice(0, 7) : null;
+}
+
+function currentInstalledRevision(): string | undefined {
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(join(homedir(), '.local', 'share', 'elanous', 'current', 'install.json'), 'utf8'));
+    const commit = object(parsed).commit;
+    return typeof commit === 'string' && /^[0-9a-f]{7,40}$/i.test(commit) ? commit : undefined;
+  } catch { return undefined; }
+}
+
+function runtimeSource(): NextTuiSelfHealthSnapshot['source'] {
+  const path = import.meta.dir.replaceAll('\\', '/');
+  if (path.includes('/.local/share/elanous/versions/') || path.includes('/.local/share/elanous/current/')) return 'installed';
+  return codeRevision() ? 'checkout' : 'unknown';
+}
+
+function classifyError(record: Pick<LogRecord, 'category' | 'event' | 'data' | 'level'>): string | null {
+  const data = object(record.data);
+  if (record.category === 'llm.call' && record.event === 'outcome-trace') {
+    const status = typeof data.status === 'number' ? data.status : null;
+    if (status === null || (status < 400 && status !== 0)) return null;
+    const provider = typeof data.provider === 'string' ? data.provider : 'LLM';
+    return status === 0 ? `${provider} 연결 오류` : `${provider} HTTP ${status}`;
+  }
+  if (record.category === 'llm.response.status' && /^codex (response\.failed|error)$/.test(record.event)) return `Codex ${record.event}`;
+  if (record.category === 'llm.router' && record.event === 'tool-loop.max-turns.no-final-synthesis') return '도구 예산 소진';
+  if (record.category === 'llm.router' && record.event === 'tool-loop.synthesis-ignored.hard-stop') return '최종 합성 중단';
+  if ((record.category === 'tools.search' && record.event === 'broad-search-blocked')
+    || (record.category === 'session-runtime.search' && /blocked$/.test(record.event))) return '탐색 가드 거부';
+  if (record.category === 'tui.event-loop' && record.event === 'stall' && typeof data.lagMs === 'number' && data.lagMs > 1_000) return `이벤트 루프 정지 ${Math.round(data.lagMs)}ms`;
+  if (record.level === 'error' || record.level === 'critical') return `기록된 오류 (${record.category})`;
+  return null;
+}
+
+function creditSource(record: Pick<LogRecord, 'category' | 'event' | 'data' | 'level'>): string | null {
+  if (record.category !== 'llm.usage' || record.event !== 'llm-usage') return null;
+  const data = object(record.data);
+  const cost = object(data.cost);
+  if (data.billing !== 'credit' && cost.kind !== 'credit') return null;
+  const provider = typeof data.billingProvider === 'string' ? data.billingProvider
+    : typeof data.provider === 'string' ? data.provider : '제공자 모름';
+  const site = typeof data.site === 'string' ? data.site : '경로 모름';
+  const model = typeof data.model === 'string' ? data.model : '모델 모름';
+  return `${provider}/${model} · ${site} · llm.usage billing=credit`;
+}
+
+function immutableSnapshot(input: Omit<NextTuiSelfHealthSnapshot, 'line'>): NextTuiSelfHealthSnapshot {
+  const build = input.runningSha
+    ? input.source === 'installed'
+      ? input.installedSha ? input.runningSha === input.installedSha
+        ? `실행 설치본 ${shortSha(input.runningSha)} · 최신`
+        : `실행 설치본 ${shortSha(input.runningSha)} · 설치본 ${shortSha(input.installedSha)} · 재기동 필요`
+        : `실행 설치본 ${shortSha(input.runningSha)} · 현재 설치본 모름`
+      : input.source === 'checkout'
+        ? `실행 체크아웃 ${shortSha(input.runningSha)} · 설치본 ${shortSha(input.installedSha) ?? '대조 모름'}`
+        : `실행 판 ${shortSha(input.runningSha)} · 출처 모름`
+    : '실행 판 모름';
+  const errors = input.errorCount === null
+    ? '최근 30분 오류 모름(로그 비활성)'
+    : input.errorCount === 0 ? '최근 30분 오류 없음'
+      : `최근 30분 오류 ${input.errorCount}회 · 대표 ${input.representativeError ?? '문면 모름'}`;
+  const credit = input.creditKnown ? `크레딧 ${input.creditSource ?? '최근 30분 사용 없음'}` : '크레딧 출처 모름(로그 비활성)';
+  const line = `[자기 건강 · Next · ${input.sessionId.slice(0, 8)}] ${build} · ${errors} · ${credit}`;
+  return Object.freeze({ ...input, line });
+}
+
+export function isNextTuiSelfHealthSnapshot(value: unknown): value is NextTuiSelfHealthSnapshot {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const snapshot = value as Record<string, unknown>;
+  return typeof snapshot.sessionId === 'string' && snapshot.sessionId.length > 0
+    && typeof snapshot.capturedAt === 'number' && typeof snapshot.line === 'string'
+    && (snapshot.source === 'installed' || snapshot.source === 'checkout' || snapshot.source === 'unknown')
+    && (typeof snapshot.runningSha === 'string' || snapshot.runningSha === null)
+    && (typeof snapshot.installedSha === 'string' || snapshot.installedSha === null)
+    && (typeof snapshot.errorCount === 'number' || snapshot.errorCount === null)
+    && (typeof snapshot.representativeError === 'string' || snapshot.representativeError === null)
+    && (typeof snapshot.creditSource === 'string' || snapshot.creditSource === null)
+    && typeof snapshot.creditKnown === 'boolean';
+}
+
+export class NextTuiSelfHealthTracker {
+  readonly sink = { name: 'next-tui-self-health', emit: (record: LogRecord) => this.observe(record) };
+  private readonly observations: Observation[] = [];
+  private readonly parents = new Map<string, string>();
+  private readonly now: () => number;
+  private readonly runningRevision: () => string | undefined;
+  private readonly installedRevision: () => string | undefined;
+  private readonly loggingLive: () => boolean;
+  private readonly source = runtimeSource();
+  private readonly bootRevision: string | undefined;
+  private credit: CreditObservation | null = null;
+  private activeSessionId = '';
+  private uninstall: (() => void) | null = null;
+
+  constructor(deps: NextTuiSelfHealthDeps = {}) {
+    this.now = deps.now ?? Date.now;
+    this.runningRevision = deps.runningRevision ?? codeRevision;
+    this.installedRevision = deps.installedRevision ?? currentInstalledRevision;
+    this.loggingLive = deps.loggingLive ?? (() => debug.isAnySinkEnabled());
+    this.bootRevision = this.runningRevision();
+  }
+
+  setSessionId(sessionId: string): void { this.activeSessionId = sessionId; }
+
+  install(): void {
+    this.uninstall ??= debug.registerSink(this.sink);
+  }
+
+  dispose(): void {
+    this.uninstall?.();
+    this.uninstall = null;
+    this.observations.length = 0;
+    this.parents.clear();
+    this.credit = null;
+    this.activeSessionId = '';
+  }
+
+  observe(record: Pick<LogRecord, 'category' | 'event' | 'data' | 'level'> & { readonly ts?: string; readonly session_id?: string }): void {
+    const at = record.ts ? Date.parse(record.ts) : this.now();
+    const sessionId = typeof record.session_id === 'string' ? record.session_id : null;
+    if (record.category === 'session.link' && record.event === 'child-scope') {
+      const data = object(record.data);
+      if (typeof data.parentSessionId === 'string' && typeof data.childSessionId === 'string') {
+        if (this.parents.size >= MAX_SESSION_LINKS) this.parents.delete(this.parents.keys().next().value as string);
+        this.parents.set(data.childSessionId, data.parentSessionId);
+      }
+      return;
+    }
+    const error = classifyError(record);
+    if (error) this.push({ at, sessionId, summary: error });
+    const credit = creditSource(record);
+    if (credit) this.credit = { at, sessionId, source: credit };
+  }
+
+  private push(observation: Observation): void {
+    this.observations.push(observation);
+    if (this.observations.length > MAX_OBSERVATIONS) this.observations.splice(0, this.observations.length - MAX_OBSERVATIONS);
+  }
+
+  private belongsToActiveSession(sessionId: string | null, own: ReadonlySet<string>): boolean {
+    if (!sessionId) return false;
+    let current: string | undefined = sessionId;
+    for (let hop = 0; current && hop < 8; hop++) {
+      if (own.has(current)) return true;
+      current = this.parents.get(current);
+    }
+    return false;
+  }
+
+  snapshot(sessionId = this.activeSessionId): NextTuiSelfHealthSnapshot {
+    this.activeSessionId = sessionId;
+    const capturedAt = this.now();
+    const live = (() => { try { return this.loggingLive(); } catch { return false; } })();
+    const own = new Set([sessionId]);
+    const since = capturedAt - NEXT_TUI_SELF_HEALTH_WINDOW_MS;
+    const recent = live ? this.observations.filter((item) => item.at >= since && item.at <= capturedAt && this.belongsToActiveSession(item.sessionId, own)) : [];
+    const latest = recent.at(-1);
+    const credit = this.credit && this.credit.at >= since && this.credit.at <= capturedAt && this.belongsToActiveSession(this.credit.sessionId, own)
+      ? this.credit.source : null;
+    const running = (() => { try { return this.bootRevision; } catch { return undefined; } })();
+    const installed = (() => { try { return this.installedRevision(); } catch { return undefined; } })();
+    return immutableSnapshot({
+      sessionId,
+      capturedAt,
+      source: this.source,
+      runningSha: shortSha(running),
+      installedSha: shortSha(installed),
+      errorCount: live ? recent.length : null,
+      representativeError: latest?.summary ?? null,
+      creditSource: live ? credit : null,
+      creditKnown: live,
+    });
+  }
+}
+
+export function installNextTuiSelfHealthTracker(): NextTuiSelfHealthTracker | null {
+  if (process.env.ELANOUS_NEXT_TUI_SELF_HEALTH !== '1') return null;
+  const tracker = new NextTuiSelfHealthTracker();
+  tracker.install();
+  return tracker;
+}
+