elanous 0.2.35 → 0.2.37

package/src/dashboard/input/turn-autoheal.ts

@@ -0,0 +1,52 @@
+// TUI-400-AUTOHEAL-FALLBACK — classic TUI(대시보드)의 자동 회복 배선 한 곳.
+//
+// plain-turn 런타임(`chat-main-plain-turn-runtime`)이 «언제·몇 번» 을 정하고, 여기는 «무엇으로» 만 준다:
+//   ① 새 백엔드 세션 = `DashboardSession.renew`(= `/session new` 의 ACP 갱신과 같은 호출)
+//   ① 직전 요약 = 이미 있는 압축 요약 `compactConversation` ⊕ 실패 시 `buildCompactTranscript` 꼬리
+//   ② 다음 공급자 = 턴 안 폴백과 같은 `llm.fallbackChain` 해석(`nextTurnFallbackProvider`)
+// ⛔ 원격 데몬 세션은 ② 를 못 한다(공급자 결정이 데몬 쪽 · 서버 다리는 in-process 만 표지를 읽는다) — ① 만.
+// ⭐ 대시보드와 결함 주입 장치(`ux-sim/fault-tui-400-autoheal`)가 «같은» 이 함수를 쓴다(재구현 0).
+
+import { nextTurnFallbackProvider, resolveDefaultProvider, type LLMMessage } from '../../llm.js';
+import type { DashboardTurnAutoheal } from './chat-main-plain-turn-runtime.js';
+import { summarizeForAutoheal } from '../../self-health/autoheal.js';
+
+export interface DashboardTurnAutohealDeps {
+  /** ACP 세션 — `renew(cwd)` 가 새 백엔드 세션 id 를 돌려준다. */
+  session: { renew(cwd: string): Promise<string> };
+  getCwd(): string;
+  /** 새 세션 id 를 대시보드 상태(acpSessionIdRef 등)에 반영. */
+  onRenewed?(sessionId: string): void;
+  /** 원격 데몬에 붙은 세션이면 true — ② 를 건너뛴다. */
+  remote: boolean;
+  /** 이 턴 모델(공급자 해석의 힌트) — 다리의 `resolveModel` 과 같은 값. */
+  activeModel(): string | undefined;
+  /** 시험 seam — 요약 시간 상한(ms). */
+  summaryTimeoutMs?: number;
+}
+
+export function createDashboardTurnAutoheal(deps: DashboardTurnAutohealDeps): DashboardTurnAutoheal {
+  return {
+    async renewBackendSession() {
+      const renewed = await deps.session.renew(deps.getCwd());
+      deps.onRenewed?.(renewed);
+      return renewed;
+    },
+    async summarizeHistory(prior) {
+      const { compactConversation, buildCompactTranscript } = await import('../../compact/index.js');
+      const history = prior as readonly LLMMessage[];
+      const { summary } = await summarizeForAutoheal(history, {
+        compact: (h) => compactConversation(h),
+        transcript: (h) => buildCompactTranscript(h),
+        ...(deps.summaryTimeoutMs !== undefined ? { timeoutMs: deps.summaryTimeoutMs } : {}),
+      });
+      return summary;
+    },
+    peekFallbackProvider() {
+      if (deps.remote) return null;
+      // 다리(core-turn-bridge)가 ② 에서 고를 것과 «같은» 해석 — 화면 한 줄의 이름과 실제 공급자가 어긋나지 않게.
+      const failed = resolveDefaultProvider(deps.activeModel()).name;
+      return nextTurnFallbackProvider([failed])?.name ?? null;
+    },
+  };
+}

package/src/dashboard/replay-preview.ts

@@ -105,3 +105,28 @@ export function renderReplayPreviewLines(
   }
   return lines;
 }
+
+/** Restored transcripts longer than this show their tail plus one «earlier N messages» line. */
+export const RESTORED_TRANSCRIPT_MAX_MESSAGES = 200;
+
+/**
+ * The restored conversation in full (TUI-RESUME-PICKER ③): every user/assistant message, every line —
+ * not the 5-message, 2-line preview. Resuming used to leave the chat log blank but for that preview,
+ * so the user could not see what they were continuing. Very long sessions keep the last
+ * `maxMessages` and say how many were left out.
+ */
+export function renderRestoredTranscriptLines(
+  messages: readonly ReplayPreviewMessage[],
+  opts: Omit<ReplayPreviewOpts, 'tail' | 'perMessageLines'> & { maxMessages?: number },
+): string[] {
+  const visible = messages.filter((m) => m.role !== 'system' && extractReplayText(m.content).length > 0);
+  const max = opts.maxMessages ?? RESTORED_TRANSCRIPT_MAX_MESSAGES;
+  const hidden = Math.max(0, visible.length - max);
+  const lines = hidden > 0 ? [C.muted(`        … 앞 ${hidden}개 메시지 생략 (최근 ${max}개 표시)`)] : [];
+  return lines.concat(renderReplayPreviewLines(visible.slice(-max), {
+    maxWidth: opts.maxWidth,
+    ...(opts.wrapOpts ? { wrapOpts: opts.wrapOpts } : {}),
+    tail: max,
+    perMessageLines: Number.MAX_SAFE_INTEGER,
+  }));
+}

package/src/dashboard/seat-boot-preamble.ts

@@ -8,13 +8,13 @@
 //      턴 경로에서 컨텍스트 버스를 읽지 않는다).
 //    - 대시보드의 ACP sessionId 는 TUI 수명 내내 같다 ⇒ `/session new`·`/session clear` 는
 //      `startSeatBootConversation` 으로 카드 캐시를 비워 «새 대화 = 새 카드»를 만든다.
-// 관측: `dashboard.seat-boot` card-injected / card-skipped / conversation-start.
+// 관측: `dashboard.seat-boot` card-injected / card-skipped / conversation-start / memory-recall(직전 인계 회상 한 줄).
 
-import { statSync } from 'node:fs';
+import { closeSync, lstatSync, openSync, readdirSync, readSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { basename, join } from 'node:path';
 import type { LLMMessage } from '../llm.js';
-import { debug } from '../debug/log.js';
+import { debug, redactSecretText } from '../debug/log.js';
 import { collectSeatBootSections, renderSeatBootCard } from '../cli/seat-cli.js';
 import { defaultMsgStorePath } from '../msg/msg-store.js';
 
@@ -70,6 +70,120 @@ export function resetSeatBootCacheForTest(): void {
   cardCache.clear();
 }
 
+/** 🧭 의도 승격 흐름(TUI-SELFIMPLEMENT-UNDERUSE-MEASURE · 대표 10-22 «확인도 결국 하다 보면 원인이 나오고 자연스럽게
+ *  구현이 나오게끔») — 10-22 prod 자리 세션 셋(UX GLM i57ey0 · UX Luna 7x2rxn · OPT Luna 7d3o49)은 노출된 SelfImplement·
+ *  tasks hand 를 한 번도 안 불렀다. 끊긴 자리 = 처방까지 세우고 «다음 턴에 SelfImplement 로 발사»·«TA 발사 보류 · 재점검
+ *  예약» 으로 턴을 닫거나, 구현을 자리에서 Edit 로 직접 했다(격리 실물 전: SelfImplement 0 · Edit/Write 직접).
+ *  자리 카드에 실어 «자리 대화의 매 턴» 이 같은 흐름을 본다(사람 대화 TUI 에는 안 실린다). */
+export const SEAT_INTENT_ESCALATION_FLOW =
+  '## 일의 흐름 — 확인에서 구현 골까지 한 흐름\n' +
+  '확인 → 원인 발견 → 조사 → 처방 확정 → 구현 골 넘기기 를 «이 턴 안에서» 잇는다. 확인·조사 지시도 원인을 찾으면 여기서 멈추지 않는다.\n' +
+  '- 원인과 처방이 섰으면 «다음 턴에»·«보고 뒤에»·«재점검 예약» 으로 미루지 말고 바로 구현 골로 넘긴다 — TUI 에서는 SelfImplement 도구(자리 규칙이 손 발사를 정했으면 `eln tasks hand`). 넘긴 뒤 보고는 한 줄.\n' +
+  '- 자리에서 기능·수정·여러 파일 구현을 Edit/Write 로 직접 하지 않는다 — 한 줄 설정·문서·오타만 예외.\n' +
+  '- 원인이 없으면 «원인 없음 · 근거(무엇을 봤나)» 한 줄로 끝낸다. 넘기지 못하면(권한·선행 조건) 막힌 이유와 필요한 판단 하나를 적는다.';
+
+/** 🧠 직전 인계 회상 한 줄(TUI-SEAT-MEMORY-RECALL · COMPARE ④ · 대표 «메모리»).
+ *  S: 10-22 prod 자리 세션 셋(UX GLM · UX Luna · OPT Luna)이 memory_recall·self_recall 을 한 번도 안 불렀다 — 기억 도구가
+ *     «있는데 안 씀». codex 는 AGENTS.md 를, Claude Code 는 자동 메모리를 턴 머리에 스스로 싣는다.
+ *  A: 소스를 «하나»로 잰다 — `seat-state/<자리>/HANDOFF-*.md` 중 mtime 이 가장 최근인 손 인계. 없으면 줄 없음
+ *     (`HANDOFF.md` 는 자동 갱신 카드이고 카드 «HANDOFF» 절이 이미 제목을 싣는다 — 본문은 싣지 않는 그 계약을 지킨다).
+ *     memory_recall·self_recall 은 자리 구분 없는 전역 원장(surface_events·knowledge.db)이라 «이 자리의 직전 인계»를
+ *     못 고르고, 우편 결정은 원장 질의가 필요하다 — 자리마다 이미 있는 HANDOFF 가 가장 작은 1급 소스다.
+ *     손 인계(HANDOFF-*.md)는 카드 어디에도 안 실렸다 — 그 제목·첫 줄이 여기 실린다.
+ *  줄 = 머리말 · 파일 · 갱신 시각 · 제목 · 첫 본문 줄 · 전문 경로 · 더 넓은 회상 도구. 상한 `SEAT_MEMORY_RECALL_MAX_CHARS`.
+ *  실패는 줄 없음(fail-soft) — 카드·턴을 막지 않는다. */
+export const SEAT_MEMORY_RECALL_PREFIX = '🧠 직전 인계 회상:';
+export const SEAT_MEMORY_RECALL_MAX_CHARS = 360;
+const RECALL_READ_BYTES = 16_384;
+/** 발췌(제목 — 첫 줄)에 남길 최소 글자 — 이보다 모자라면 전문 경로를 짧은 꼴로 바꾼다. */
+const RECALL_MIN_EXCERPT = 60;
+/** 줄에 싣는 파일명 최대 글자. */
+const RECALL_MAX_NAME = 80;
+
+interface SeatMemoryRecall { line: string | null; source: string | null }
+
+/** 제어 문자·줄 구분자 — 하나라도 섞이면 «한 줄» 계약이 깨진다(파일명·경로·본문 모두). */
+const LINE_BREAKING = /[\u0000-\u001f\u007f\u0085\u2028\u2029]/;
+/** 셸 문자 — 카드 HANDOFF 절과 같은 안전 규칙. 본문 줄뿐 아니라 파일명·경로에도 적용한다(r4). */
+const SHELL_CHARS = /[`$;|<>]/;
+const oneLine = (text: string): string => redactSecretText(text.replace(new RegExp(LINE_BREAKING.source, 'g'), ' ').replace(/\s+/g, ' ').trim());
+
+/** 앞 `RECALL_READ_BYTES` 만 읽는다 — 큰 인계 파일도 턴 시작을 막지 않는다. */
+function readHead(path: string): string {
+  const fd = openSync(path, 'r');
+  try {
+    const buf = Buffer.alloc(RECALL_READ_BYTES);
+    const n = readSync(fd, buf, 0, RECALL_READ_BYTES, 0);
+    return buf.subarray(0, n).toString('utf8');
+  } finally { closeSync(fd); }
+}
+
+function newestHandoff(seatDir: string): { path: string; mtime: Date } | null {
+  if (LINE_BREAKING.test(seatDir)) return null;
+  const pick = (names: string[]): { path: string; mtime: Date } | null => {
+    let best: { path: string; mtime: Date } | null = null;
+    for (const name of names) {
+      const path = join(seatDir, name);
+      try {
+        const st = lstatSync(path);
+        if (!st.isFile()) continue; // 디렉터리·링크는 건너뛴다
+        if (!best || st.mtimeMs > best.mtime.getTime()) best = { path, mtime: st.mtime };
+      } catch { /* 사라진 후보 — 건너뛴다 */ }
+    }
+    return best;
+  };
+  // 제어 문자가 든 파일명은 후보에서 뺀다 — 이름·경로를 줄에 그대로 싣기 때문이다.
+  // 파일명은 안전 문자만(영숫자 · . _ -) — 셸 문자·제어 문자가 든 이름은 후보에서 뺀다(이름을 줄에 그대로 싣는다).
+  return pick(readdirSync(seatDir).filter((name) => /^HANDOFF-[A-Za-z0-9._-]+\.md$/.test(name)));
+}
+
+/** 자리의 직전 인계 회상 한 줄. 소스가 없거나 읽을 수 없으면 `line: null`.
+ *  카드 HANDOFF 절과 같은 안전 규칙 — 셸 문자(`` ` `` `$` `;` `|` `<` `>`)가 든 줄은 싣지 않는다 · 비밀은 가린다. */
+function buildSeatMemoryRecall(seatDir: string): SeatMemoryRecall {
+  const found = newestHandoff(seatDir);
+  if (!found) return { line: null, source: null };
+  const raw = readHead(found.path).split(/\r\n|[\n\r\u0085\u2028\u2029]/)
+    .map((line) => line.trim()).filter((line) => line && !/[`$;|<>]/.test(line));
+  const title = raw.find((line) => /^#{1,6}\s/.test(line))?.replace(/^#{1,6}\s*/, '') ?? '';
+  const first = raw.find((line) => !/^#{1,6}\s/.test(line))?.replace(/^[-*]\s*/, '') ?? '';
+  const excerpt = oneLine([title, first].filter(Boolean).join(' — '));
+  if (!excerpt) return { line: null, source: found.path };
+  const fullName = found.path.slice(seatDir.length + 1);
+  // 파일명은 머리에 한 번만, 길면 앞 RECALL_MAX_NAME 자로 자른다 — 이름 길이가 발췌를 밀어내지 않는다.
+  const name = fullName.length > RECALL_MAX_NAME ? `${fullName.slice(0, RECALL_MAX_NAME - 1)}…` : fullName;
+  const head = `${SEAT_MEMORY_RECALL_PREFIX} ${name}(갱신 ${found.mtime.toISOString()}) `;
+  // 경로가 길어 발췌 자리가 모자라면 전문 경로 대신 «자리 폴더(seat-state/<자리>/)»만 가리킨다 — 줄을 버리지 않는다.
+  const tools = ' · 더 넓게는 self_recall·memory_recall';
+  // 경로·자리 폴더 이름에 셸 문자가 있으면 싣지 않는다(본문 줄과 같은 규칙) · 비밀은 가린다.
+  const pathSafe = !SHELL_CHARS.test(found.path);
+  const seatName = basename(seatDir);
+  const seatSafe = !SHELL_CHARS.test(seatName);
+  const fullTail = pathSafe ? ` · 전문 ${redactSecretText(found.path)}${tools}` : '';
+  const shortTail = seatSafe
+    ? ` · 전문은 seat-state/${redactSecretText(seatName).slice(0, 64)}/ 의 같은 파일${tools}`
+    : ` · 전문은 이 자리 seat-state 폴더의 같은 파일${tools}`;
+  const tail = fullTail && SEAT_MEMORY_RECALL_MAX_CHARS - head.length - fullTail.length >= RECALL_MIN_EXCERPT ? fullTail : shortTail;
+  // 머리(≤ ~130)·짧은 꼬리(≤ ~120)의 상한 덕에 발췌 자리는 늘 남는다 — 아래는 상수가 바뀔 때의 안전망.
+  const room = SEAT_MEMORY_RECALL_MAX_CHARS - head.length - tail.length;
+  if (room < 8) return { line: null, source: found.path };
+  const body = excerpt.length > room ? `${excerpt.slice(0, room - 1)}…` : excerpt;
+  return { line: `${head}${body}${tail}`, source: found.path };
+}
+
+function seatMemoryRecallLine(seatDir: string): string | null {
+  let recall: SeatMemoryRecall = { line: null, source: null };
+  let failed = false;
+  try { recall = buildSeatMemoryRecall(seatDir); }
+  catch { failed = true; }
+  debug.log('dashboard.seat-boot', 'memory-recall', {
+    source: recall.source,
+    chars: recall.line?.length ?? 0,
+    hit: recall.line !== null,
+    ...(failed ? { reason: 'error' } : {}),
+  });
+  return recall.line;
+}
+
 function buildCardMessages(cwd: string, deps: SeatBootDeps): { messages: LLMMessage[]; observed: Record<string, unknown> } {
   const detection = detectSeat(cwd, deps.env ?? process.env);
   if (!detection) return { messages: [], observed: { reason: 'no-seat' } };
@@ -81,10 +195,14 @@ function buildCardMessages(cwd: string, deps: SeatBootDeps): { messages: LLMMess
   const { sections, unread } = collectSeatBootSections(detection.seat, { home, msgPath: deps.msgPath ?? defaultMsgStorePath() });
   const card = renderSeatBootCard(detection.seat, sections, null);
   const at = (deps.now?.() ?? new Date()).toISOString();
+  const recall = seatMemoryRecallLine(seatDir);
   const content =
     `## 자리 부트 카드 — 너는 이 작업 디렉터리의 ${detection.seat} 자리에서 일한다\n` +
     `(판정: ${detection.source === 'cwd' ? `cwd 의 /seats/${detection.seat}` : 'COORD_ID'} · 세션 시작 스냅샷 ${at} · 이후 바뀐 값은 다시 조회하라)\n` +
-    `사람이 다른 일을 먼저 시키지 않았다면, 첫 답에서 자리 이름·'자리 역할' 절의 역할·안 읽은 우편 수를 각각 명시하고 처리할 일을 제안하라. 역할이 미관측이면 추측하지 말고 미관측이라고 말하라.\n\n` +
+    `사람이 다른 일을 먼저 시키지 않았다면, 첫 답에서 자리 이름·'자리 역할' 절의 역할·안 읽은 우편 수를 각각 명시하고 처리할 일을 제안하라. 역할이 미관측이면 추측하지 말고 미관측이라고 말하라.\n` +
+    (recall ? `${recall}\n` : '') +
+    '\n' +
+    `${SEAT_INTENT_ESCALATION_FLOW}\n\n` +
     card;
   return {
     messages: [{ role: 'system', content }],
@@ -103,6 +221,15 @@ function conversationCard(cwd: string, deps: SeatBootDeps, sessionId?: string):
       sessionId: sessionId ?? null,
       ...entry.observed,
     });
+    // 🧭 이 대화에 «확인 → … → 구현 골 넘기기» 흐름을 실었다 — 단계·근거·다음 행동(넘김 도구). 대화마다 한 번.
+    if (entry.messages.length) {
+      debug.log('dashboard.seat-boot', 'intent.escalate', {
+        stage: 'guidance',
+        evidence: { seat: entry.observed.seat, source: entry.observed.source },
+        next: ['SelfImplement', 'eln tasks hand'],
+        sessionId: sessionId ?? null,
+      });
+    }
   } catch (err) {
     // 부트 카드가 턴을 막지 않는다 — 실패는 관측만.
     debug.log('dashboard.seat-boot', 'card-skipped', { cwd, reason: 'error', error: err instanceof Error ? err.message : String(err) });

package/src/dashboard/slash-runtime/chat-persona.ts

@@ -2,16 +2,24 @@ import { awaitGlobalPersonaLoad, getGlobalPersonaRegistry } from '../../persona/
 import { resolvePersonaAddress } from '../../intake-plane/persona-answer.js';
 import { loadSession, updateSessionMeta } from '../../session/index.js';
 import { assemblePersonaPrompt } from '../../persona/prompt-assembler.js';
+import type { PromptSource } from '../../persona/prompt-assembler.js';
 import type { LLMMessage } from '../../llm.js';
 
 /** Unattached conversations use a dashboard-local id; attached sessions use persisted metadata. */
 export class TuiChatPersonaSelection {
   private readonly selected = new Map<string, string>();
+  /** 적용 시점 캡처 스냅샷 — registry와 별개 저장소, 조회는 이 값을 반환한다. */
+  private readonly applied = new Map<string, TuiChatPersonaAppliedSource>();
 
   get(sessionId: string): string | undefined {
     return loadSession(sessionId)?.meta.chatPersonaId ?? this.selected.get(sessionId);
   }
 
+  /** Application-time source snapshot; survives later registry replacement. */
+  appliedSource(sessionId: string): TuiChatPersonaAppliedSource | undefined {
+    return this.applied.get(sessionId);
+  }
+
   set(sessionId: string, personaId: string | undefined): void {
     const meta = updateSessionMeta(sessionId, (m) => {
       if (personaId) m.chatPersonaId = personaId;
@@ -23,6 +31,22 @@ export class TuiChatPersonaSelection {
     } else {
       this.selected.delete(sessionId);
     }
+    if (!personaId) {
+      this.applied.delete(sessionId);
+      return;
+    }
+    const persona = getGlobalPersonaRegistry().get(personaId);
+    if (!persona) {
+      this.applied.delete(sessionId);
+      return;
+    }
+    const { systemPrompt, sources } = assemblePersonaPrompt(persona, '');
+    this.applied.set(sessionId, {
+      personaId: persona.personaId,
+      displayName: persona.displayName,
+      sources,
+      systemPrompt,
+    });
   }
 }
 
@@ -41,8 +65,10 @@ export async function handleTuiChatPersona(
     if (!args.length) {
       const selected = selection.get(sessionId);
       const personas = registry.list().sort((a, b) => a.displayName.localeCompare(b.displayName));
-      const current = personas.find(p => p.personaId === selected);
-      return `이 대화의 페르소나: ${current ? `${current.displayName} (${current.personaId})` : '없음'}\n고를 수 있는 페르소나: ${personas.map(p => `${p.displayName} (${p.personaId})${p.personaId === selected ? ' (지금)' : ''}`).join(' · ') || '없음'}\n고르기: /persona <이름> · 빼기: /persona -`;
+      // 조각 7/9 출처 보존 — 지금 적용된 출처는 적용 시점 스냅샷으로 보여준다.
+      // registry 가 이후 교체·오염돼도 이 대화에 적용된 출처는 그대로다.
+      const applied = tuiChatPersonaSources(sessionId, selection);
+      return `이 대화의 페르소나: ${applied ? `${applied.displayName} (${applied.personaId})` : '없음'}\n고를 수 있는 페르소나: ${personas.map(p => `${p.displayName} (${p.personaId})${p.personaId === selected ? ' (지금)' : ''}`).join(' · ') || '없음'}\n고르기: /persona <이름> · 빼기: /persona -`;
     }
     const name = args.join(' ');
     const persona = resolvePersonaAddress(name, registry);
@@ -54,13 +80,44 @@ export async function handleTuiChatPersona(
   }
 }
 
-export function tuiChatPersonaMessages(
+/** Applied persona source captured at application time (조각 7/9 출처 보존).
+ *  The snapshot lives in a store separate from the registry — the session
+ *  meta `chatPersonaId` holds the applied id durably, and this
+ *  application-time snapshot holds displayName, sources and systemPrompt —
+ *  so replacing or contaminating the registry after the apply cannot
+ *  rewrite what this conversation applied. */
+export interface TuiChatPersonaAppliedSource {
+  /** Source identifier — string-identical to the loader personaId. */
+  readonly personaId: string;
+  /** Display name as loaded when the persona was applied. */
+  readonly displayName: string;
+  /** Source breakdown from prompt assembly, captured at apply time. */
+  readonly sources: readonly PromptSource[];
+  /** System prompt assembled when the persona was applied. */
+  readonly systemPrompt: string;
+}
+
+/** Resolve the applied persona source (조각 7/9 출처 보존). Serves the
+ *  application-time snapshot captured in the selection — per-call registry
+ *  re-derivation is not preservation. Falls back to the persisted session
+ *  meta `chatPersonaId` plus a registry lookup only when no snapshot exists
+ *  yet, e.g. a fresh process restoring a persisted session. */
+export function tuiChatPersonaSources(
   sessionId: string, selection: TuiChatPersonaSelection,
-): LLMMessage[] {
+): TuiChatPersonaAppliedSource | undefined {
+  const captured = selection.appliedSource(sessionId);
+  if (captured) return captured;
   const id = selection.get(sessionId);
-  if (!id) return [];
+  if (!id) return undefined;
   const persona = getGlobalPersonaRegistry().get(id);
-  if (!persona) return [];
-  const prompt = assemblePersonaPrompt(persona, '').systemPrompt;
-  return prompt ? [{ role: 'system', content: prompt }] : [];
+  if (!persona) return undefined;
+  const { systemPrompt, sources } = assemblePersonaPrompt(persona, '');
+  return { personaId: id, displayName: persona.displayName, sources, systemPrompt };
+}
+
+export function tuiChatPersonaMessages(
+  sessionId: string, selection: TuiChatPersonaSelection,
+): LLMMessage[] {
+  const applied = tuiChatPersonaSources(sessionId, selection);
+  return applied?.systemPrompt ? [{ role: 'system', content: applied.systemPrompt }] : [];
 }

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

@@ -344,7 +344,8 @@ import { termSize, stripAnsi } from '../../tui.js';
 import { SLASH_COMMANDS } from '../../chat/index.js';
 import { buildEssentialHelpLines } from './help-from-registry.js';
 import { registerDashboardLogSlash } from './dashboard-log-slash.js';
-import { HUMAN_MODEL_WORDS, MODEL_CODE_NAMES, humanWordForModel, modelChangeLine, modelOverviewLines, modelScopeLine, modelSwitchScope, parseModelSlashArgs, resolveModelChoice } from './model-choices.js';
+import { HUMAN_MODEL_WORDS, MODEL_CODE_NAMES, humanWordForModel, modelActualNote, modelChangeLine, modelOverviewLines, modelScopeLine, modelSwitchScope, parseModelSlashArgs, resolveModelChoice } from './model-choices.js';
+import { statusModelActual } from '../../status/status-provider-info.js';
 import type { FoldMode } from '../../log-entry.js';
 import { debug } from '../../debug/log.js';
 import { observeSessionStart } from '../../session/session-start.js';
@@ -363,13 +364,15 @@ import {
   attachTelegramBinding as sessionAttachTelegram,
   listBoundSessions as sessionListBound,
 } from '../../session/index.js';
+import { idPrefixCell, sessionIdPrefixes, sessionListTime } from '../../session/id-prefix.js';
 import { safeReadLock as telegramSafeReadLock, defaultLockPath as telegramDefaultLockPath } from '../../telegram-lock.js';
 import { userConfigPath as userConfigPathFn } from '../../user-config.js';
 import { dirname as pathDirname, relative, resolve as resolvePath } from 'node:path';
 import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { installPlugin, listInstalledPlugins, type InstalledPlugin } from '../../plugins/install/plugin-install.js';
 import type { SurfaceUx } from '../../agent/surface-ux/types.js';
-import { renderReplayPreviewLines } from '../replay-preview.js';
+import { renderRestoredTranscriptLines } from '../replay-preview.js';
+import { noteRestoredContext } from '../../status/metrics.js';
 import {
   deriveDaemonHttpBase,
   fetchDaemonSessionList,
@@ -2394,6 +2397,8 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
         }
       } else if (result.kind === 'stopped-before-authoring') {
         ctx.chatLines.push(ctx.error('  ⛔ 저작 «전» 예비 검사에서 막혔다 — 위 이름을 확인하라'));
+      } else if (result.kind === 'stopped-by-timebox') {
+        ctx.chatLines.push(ctx.error(`  ⛔ AUTHOR-TIMEBOX 초과로 접지 없이 끝났다 — 골은 남아 있다: ${result.goalFile}`));
       } else {
         ctx.chatLines.push(ctx.error(`  ⛔ 전제 검사에서 막혔다 — 골은 남아 있다: ${result.goalFile}`));
       }
@@ -2601,6 +2606,8 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
     if (seSub === 'list' || seSub === 'ls') {
       const limit = args[1] ? Math.max(1, Math.min(50, Number(args[1]) || 10)) : 10;
       const rows = sessionListSessions({ limit });
+      // Unique prefixes, not a fixed 8 — `/session load <shown prefix>` must resolve (TUI-RESUME-PICKER).
+      const idPrefixes = sessionIdPrefixes(rows.map((m) => m.id));
       // Tier 1 daemon merge — when attached to a remote daemon w/ a
       // derivable HTTP base, fetch the daemon's session list too so
       // the user sees web/PWA/other-client sessions alongside their
@@ -2627,9 +2634,9 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
           if (m.bindings?.telegram) binds.push(`tg:${m.bindings.telegram.chatId}`);
           if (m.bindings?.discord) binds.push(`dc:${m.bindings.discord.channelId}`);
           const bindStr = binds.length > 0 ? ctx.subtext(`[${binds.join(' ')}]`) : '';
-          const ts = m.updatedAt.slice(5, 16).replace('T', ' ');
+          const ts = sessionListTime(m.updatedAt);
           const title = (m.title || '(no title)').slice(0, 48);
-          ctx.chatLines.push(`  ${marker} ${ctx.text(m.id.slice(0, 8))}  ${ctx.muted(ts)}  ${ctx.muted(`${m.messageCount}t`.padStart(4))}  ${bindStr.padEnd(10)}  ${title}`);
+          ctx.chatLines.push(`  ${marker} ${ctx.text(idPrefixCell(idPrefixes, m.id))}  ${ctx.muted(ts)}  ${ctx.muted(`${m.messageCount}t`.padStart(4))}  ${bindStr.padEnd(10)}  ${title}`);
         }
       }
       if (daemonRows.length > 0) {
@@ -2733,13 +2740,14 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
               }
               ctx.setAttachedSessionId(match.id);
               try { sessionSetActiveId(match.id); } catch { /* best-effort */ }
+              noteRestoredContext(chatHistory);
               ctx.chatLines.push('');
               ctx.chatLines.push(ctx.success(`  ✓ swapped to daemon session ${match.id}`));
               if (past && past.length > 0) {
-                ctx.chatLines.push(ctx.muted(`    ${past.length} turn${past.length === 1 ? '' : 's'} restored. Preview of last 5:`));
+                ctx.chatLines.push(ctx.muted(`    ${past.length} turn${past.length === 1 ? '' : 's'} restored:`));
                 const swapPreviewWidth = Math.max(40, termSize().cols - 8);
                 const swapPreviewWrap = getUserConfig().chat.rendering.wrap;
-                const swapPreviewLines = renderReplayPreviewLines(past, {
+                const swapPreviewLines = renderRestoredTranscriptLines(past, {
                   maxWidth: swapPreviewWidth,
                   wrapOpts: swapPreviewWrap,
                 });
@@ -2791,11 +2799,13 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
       // side /attach (no-arg) picks up the same session automatically.
       try { sessionSetActiveId(resolvedId); } catch { /* best-effort */ }
       ctx.chatLines.push('');
-      ctx.chatLines.push(ctx.success(`  ✓ loaded session ${resolvedId.slice(0, 8)}  (${loaded.meta.title || '(no title)'})`));
-      ctx.chatLines.push(ctx.muted(`    ${loaded.history.length} turns restored. Preview of last 5:`));
+      ctx.chatLines.push(ctx.success(`  ✓ loaded session ${sessionIdPrefixes([resolvedId]).get(resolvedId) ?? resolvedId}  (${loaded.meta.title || '(no title)'})`));
+      ctx.chatLines.push(ctx.muted(`    ${loaded.history.length} turns restored:`));
+      const restoredTokens = noteRestoredContext(chatHistory);
+      debug.log('chat.session.load', 'restored', { sessionId: resolvedId, turns: loaded.history.length, estimatedContextTokens: restoredTokens });
       const loadPreviewWidth = Math.max(40, termSize().cols - 8);
       const loadPreviewWrap = getUserConfig().chat.rendering.wrap;
-      const loadPreviewLines = renderReplayPreviewLines(loaded.history, {
+      const loadPreviewLines = renderRestoredTranscriptLines(loaded.history, {
         maxWidth: loadPreviewWidth,
         wrapOpts: loadPreviewWrap,
       });
@@ -4800,7 +4810,7 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
       const [, codes] = modelOverviewLines(curProvider, curModel, curReasoning);
       // A model outside the 빠름/보통/깊음 map (codename or custom) says so explicitly instead of dropping the tier slot.
       const tierName = humanWordForModel(curProvider, curModel, curReasoning) ?? '단계 밖';
-      ctx.chatLines.push(`지금: ${curModel?.trim() || '기본 모델'} (${tierName} · 생각 ${curReasoning}${pin ? ' · 이 세션 핀' : ''}) · 고르기: /model ${HUMAN_MODEL_WORDS.join(' | ')}`);
+      ctx.chatLines.push(`지금: ${curModel?.trim() || '기본 모델'} (${tierName} · 생각 ${curReasoning}${pin ? ' · 이 세션 핀' : ''})${modelActualNote(curModel, statusModelActual('dashboard'))} · 고르기: /model ${HUMAN_MODEL_WORDS.join(' | ')}`);
       ctx.chatLines.push(ctx.muted(codes));
       ctx.setChatScrollOffset(-1);
       return;

package/src/dashboard/slash-runtime/model-choices.ts

@@ -8,6 +8,7 @@
 import type { LLMProviderName, ReasoningLevel } from '../../user-config.js';
 import { lookupLlmTierSpec } from '../../model-tier/index.js';
 import type { ModelTier } from '../../model-tier/types.js';
+import type { ModelExecutionActual } from '../../status/bar.js';
 
 export interface ModelTarget {
   readonly model: string;
@@ -72,6 +73,20 @@ export function resolveModelChoice(rawArg: string, currentProvider: LLMProviderN
   return { kind: 'unknown', arg };
 }
 
+/** `/model` «지금:» 에 덧붙는 «이번 턴 실제» (TUI-MODEL-BADGE-ACTUAL · 10-16 · #24·#66).
+ *  상태줄 배지와 «같은» 원천(`statusModelActual`)을 쓰므로 두 화면이 다른 말을 하지 않는다.
+ *  이번 턴 실행이 없거나 이미 보이는 모델과 같으면 '' — 꾸미지 않는다(기본 출력 보존). */
+export function modelActualNote(
+  shownModel: string | null | undefined,
+  actual: ModelExecutionActual | null | undefined,
+): string {
+  const model = actual?.model?.trim();
+  if (!model) return '';
+  const from = actual?.fallbackFrom?.trim();
+  if (!from && model === shownModel?.trim()) return '';
+  return ` · 이번 턴 실제: ${from ? `${from} → ${model}` : model}`;
+}
+
 /**
  * The human word for (`model`, `reasoning`) on `provider`: an exact tier match first; without a reasoning
  * level (or no exact match) only a model that names a single tier counts — an ambiguous model gets no word.

package/src/dashboard/stale-install-check.ts

@@ -1,99 +1,3 @@
-import { realpathSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { basename, dirname, join, resolve } from 'node:path';
-
-import { readInstallMetadataCommit } from '../version/code-revision.js';
-
-export type StaleInstallResult = {
-  state: 'same' | 'changed' | 'unknown' | 'not-installed';
-  bootCommit: string | undefined;
-  installedCommit: string | undefined;
-};
-
-export const STALE_INSTALL_CHECK_INTERVAL_MS = 60_000;
-
-/**
- * Builds the command that relaunches the TUI on the same daemon session: `elanous --resume <id>` boots the dashboard,
- * loads that session (ACP session/load) and replays its turns (src/index.ts resumeSessionId · dashboard acp-boot).
- * The user-facing hint and its key binding land with the dashboard wiring slice (`r` is the render toggle today).
- * Intentional wiring boundary: the dashboard owns the key binding and executes this command;
- * this scoped helper only constructs it and does not spawn a child process.
- */
-export function buildStaleInstallRelaunchCommand(sessionId: string): string {
-  return `elanous --resume ${JSON.stringify(sessionId)}`;
-}
-
-export function formatStaleInstallNotice(result: StaleInstallResult, notifiedCount: number): string {
-  const message = `새 판이 깔렸습니다 (부팅 판 ${result.bootCommit!.slice(0, 7)} → 지금 ${result.installedCommit!.slice(0, 7)}) · TUI 를 다시 띄우면 새 판으로 돕니다`;
-  return notifiedCount >= 2 ? `${message} · 이 TUI 가 뜬 뒤 ${notifiedCount}번째 새 판` : message;
-}
-
-/** Identify the immutable installed version containing this module, never the session cwd. */
-export function versionedDashboardInstallDir(
-  codeRoot: string,
-  installRoot = join(homedir(), '.local', 'share', 'elanous'),
-): string | undefined {
-  try {
-    const packageRoot = realpathSync(codeRoot);
-    if (basename(packageRoot) !== 'elanous' || basename(dirname(packageRoot)) !== 'node_modules') return undefined;
-    const versionDir = dirname(dirname(packageRoot));
-    let canonicalInstallRoot: string;
-    try { canonicalInstallRoot = realpathSync(installRoot); }
-    catch { canonicalInstallRoot = resolve(installRoot); }
-    if (dirname(versionDir) !== join(canonicalInstallRoot, 'versions')) return undefined;
-    const requestedVersionDir = dirname(dirname(resolve(codeRoot)));
-    return dirname(requestedVersionDir) === resolve(installRoot, 'versions')
-      && realpathSync(requestedVersionDir) === versionDir
-      ? requestedVersionDir : versionDir;
-  } catch {
-    return undefined;
-  }
-}
-
-export function createStaleInstallCheck(input: {
-  bootCommit: string | undefined;
-  readInstalledCommit: () => string | undefined;
-  now: () => number;
-  codeRoot?: string;
-  installRoot?: string;
-}) {
-  const installed = input.codeRoot === undefined
-    || versionedDashboardInstallDir(input.codeRoot, input.installRoot) !== undefined;
-  const notifiedCommits = new Set<string>();
-  let lastReadAt = -Infinity;
-  let lastResult: StaleInstallResult | undefined;
-  const check = (): StaleInstallResult => {
-    if (!installed) return { state: 'not-installed', bootCommit: input.bootCommit, installedCommit: undefined };
-    const time = input.now();
-    if (lastResult && time - lastReadAt < STALE_INSTALL_CHECK_INTERVAL_MS) return lastResult;
-    lastReadAt = time;
-    let installedCommit: string | undefined;
-    try { installedCommit = input.readInstalledCommit(); } catch { /* unreadable metadata */ }
-    const result: StaleInstallResult = {
-      state: !input.bootCommit || !installedCommit
-        ? 'unknown'
-        : input.bootCommit === installedCommit ? 'same' : 'changed',
-      bootCommit: input.bootCommit,
-      installedCommit,
-    };
-    lastResult = result;
-    return result;
-  };
-  return {
-    check,
-    shouldNotify(result: StaleInstallResult): boolean {
-      if (result.state !== 'changed' || !result.installedCommit || notifiedCommits.has(result.installedCommit)) return false;
-      notifiedCommits.add(result.installedCommit);
-      return true;
-    },
-  };
-}
-
-/** Only the current pointer is polled; boot metadata is read once from the immutable version. */
-export function readDashboardBootCommit(versionDir: string): string | undefined {
-  return readInstallMetadataCommit(join(versionDir, 'install.json'));
-}
-
-export function readCurrentInstalledCommit(installRoot = join(homedir(), '.local', 'share', 'elanous')): string | undefined {
-  return readInstallMetadataCommit(join(installRoot, 'current', 'install.json'));
-}
+// Dashboard compatibility entry. The implementation is kept in pty-shell so
+// non-dashboard observers can read install state without loading dashboard code.
+export * from '../pty-shell/stale-install-check.js';