elanous 0.2.36 → 0.2.37

package/src/context-bus/long-term-memory.ts

@@ -302,3 +302,128 @@ export async function condenseContextWindowWithReport(
   catch { /* Observation must not stop condensation. */ }
   return { cards, skipped, folded, droppedHarnessChild, funnel };
 }
+
+// ─── Claude 자동 기억 가져오기 (MEMORY-IMPORT-CLAUDE · 대표 10-12) ──────────────────────────────
+// `~/.claude/projects/<project>/memory/*.md` 의 frontmatter(name·description·type)를 엘라누스
+// 장기 기억 레코드로 옮긴다. 파일 읽기·저장은 호출자 몫 — 여기는 순수 변환만 둔다(에이전트 무관).
+
+/** Claude 기억 파일 frontmatter 의 type 값 — 큐레이션 기억 type 어휘와 같다. */
+export type ClaudeMemoryType = 'user' | 'feedback' | 'project' | 'reference';
+
+/** 가져온 기억이 앉는 신뢰 사다리 맨 아래 칸 — 승격된 카드·결정을 덮지 않는다. */
+export const CLAUDE_MEMORY_TRUST = 'memory';
+
+/** 가져온 기억의 seat 표식 — 어떤 에이전트(codex·elanous TUI)든 같은 자리에서 읽는다. */
+export const CLAUDE_MEMORY_SEAT = 'claude-memory';
+
+/** 디스크에서 읽은 Claude 기억 파일 하나(경로 ⊕ 원문). */
+export interface ClaudeMemoryFile { path: string; text: string }
+
+/** MemoryItem 계약에 파일 자신의 이름 3종(name·description·type)을 그대로 얹은 레코드. */
+export interface ClaudeMemoryItem extends MemoryItem {
+  name: string;
+  description: string;
+  type: ClaudeMemoryType;
+  body: string;
+  trust: typeof CLAUDE_MEMORY_TRUST;
+}
+
+export type ClaudeMemorySkipReason = 'no-frontmatter' | 'no-name' | 'no-description' | 'unknown-type';
+
+export interface ClaudeMemoryImport {
+  items: ClaudeMemoryItem[];
+  /** 같은 name 이 두 번 나오면 뒤 파일이 이긴다(덮어쓰기). */
+  overwritten: number;
+  skipped: Partial<Record<ClaudeMemorySkipReason, number>>;
+}
+
+const CLAUDE_MEMORY_TYPES: readonly ClaudeMemoryType[] = ['user', 'feedback', 'project', 'reference'];
+
+/** 출처 표시 — 원장의 `^(https?://|elanous://)` 링크 계약을 넓히지 않고 그대로 만족한다. */
+export function claudeMemorySource(name: string): string {
+  return `elanous://claude-memory/${encodeURIComponent(name.trim())}`;
+}
+
+/** 낡음 표시 — «10-14 기준» 처럼 기준일의 월-일을 남긴다. */
+export function claudeMemoryStalenessNote(asOf: string): string {
+  return `«${claudeMemoryInstant(asOf).slice(5, 10)} 기준»`;
+}
+
+function claudeMemoryInstant(asOf: string): string {
+  const ms = Date.parse(asOf);
+  if (!Number.isFinite(ms)) throw new Error(`claude memory asOf is not a date: ${asOf}`);
+  return new Date(ms).toISOString();
+}
+
+function claudeFrontmatter(text: string): { fields: Record<string, string>; body: string } | undefined {
+  const normalized = text.replace(/^\uFEFF/, '').replace(/\r\n?/g, '\n');
+  if (!normalized.startsWith('---\n')) return undefined;
+  const close = normalized.indexOf('\n---', 3);
+  if (close < 0) return undefined;
+  const fields: Record<string, string> = {};
+  for (const line of normalized.slice(4, close).split('\n')) {
+    const match = /^([A-Za-z][\w-]*)\s*:\s*(.*)$/.exec(line);
+    if (match) fields[match[1]] = match[2].replace(/^(['"])([\s\S]*)\1$/, '$2').trim();
+  }
+  return { fields, body: normalized.slice(close + 4).replace(/^\n+/, '').trim() };
+}
+
+function claudeMemoryProject(path: string): string {
+  const parts = path.split(/[\\/]/).filter(Boolean);
+  const projectsAt = parts.indexOf('projects');
+  if (projectsAt >= 0 && parts[projectsAt + 2] === 'memory') return parts[projectsAt + 1];
+  const memoryAt = parts.lastIndexOf('memory');
+  return memoryAt > 0 ? parts[memoryAt - 1] : '(unknown)';
+}
+
+/**
+ * Claude 기억 파일 하나 → 장기 기억 레코드. 형식이 안 맞으면 이유와 함께 건너뛴다.
+ * claim 이 없는 레코드지만 source 가 `elanous://claude-memory/<name>` 링크라 원장 계약을 지킨다.
+ */
+export function importClaudeMemory(
+  file: ClaudeMemoryFile,
+  options: { asOf: string },
+): { ok: true; item: ClaudeMemoryItem } | { ok: false; reason: ClaudeMemorySkipReason } {
+  const parsed = claudeFrontmatter(file.text);
+  if (!parsed) return { ok: false, reason: 'no-frontmatter' };
+  const name = (parsed.fields.name ?? '').trim();
+  if (!name) return { ok: false, reason: 'no-name' };
+  const description = (parsed.fields.description ?? '').trim();
+  if (!description) return { ok: false, reason: 'no-description' };
+  const type = (parsed.fields.type ?? '').trim().toLowerCase();
+  if (!CLAUDE_MEMORY_TYPES.includes(type as ClaudeMemoryType)) return { ok: false, reason: 'unknown-type' };
+  return { ok: true, item: {
+    project: claudeMemoryProject(file.path),
+    seat: CLAUDE_MEMORY_SEAT,
+    topic: name,
+    summary: `${claudeMemoryStalenessNote(options.asOf)} ${description}`,
+    source: claudeMemorySource(name),
+    updatedAt: claudeMemoryInstant(options.asOf),
+    status: 'active',
+    name,
+    description,
+    type: type as ClaudeMemoryType,
+    body: parsed.body,
+    trust: CLAUDE_MEMORY_TRUST,
+  } };
+}
+
+/** 여러 파일을 한 번에 — name 이 겹치면 뒤 파일이 이긴다(덮어쓰기). */
+export function importClaudeMemories(
+  files: readonly ClaudeMemoryFile[],
+  options: { asOf: string },
+): ClaudeMemoryImport {
+  const byName = new Map<string, ClaudeMemoryItem>();
+  const skipped: Partial<Record<ClaudeMemorySkipReason, number>> = {};
+  let overwritten = 0;
+  for (const file of files) {
+    const outcome = importClaudeMemory(file, options);
+    if (!outcome.ok) {
+      skipped[outcome.reason] = (skipped[outcome.reason] ?? 0) + 1;
+      continue;
+    }
+    if (byName.has(outcome.item.name)) overwritten += 1;
+    byName.set(outcome.item.name, outcome.item);
+  }
+  return { items: [...byName.values()], overwritten, skipped };
+}

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

@@ -185,7 +185,7 @@ export const GOAL_FINAL_ITERATION_NOTE =
   '[last iteration] 이번이 이 목표의 마지막 반복이다. 이번에 끝내지 못하면 답 끝에 최종 보고를 한 번 써라: 한 것 · 남은 것 · 확인한 증거.';
 
 /** 중간 답이 «최종 보고형»(미완 목록)인가 — 관측 전용(행동을 바꾸지 않는다). */
-const INTERIM_REPORT_SHAPED = /(?:보고할 수 없|하지 못했습니다|못했습니다|완료되지 않았|검증되지 않았|확인하지 못했|not (?:yet )?(?:verified|completed)|cannot report)/i;
+const INTERIM_REPORT_SHAPED = /(?:보고할 수 없|하지\s?못했습니다|못\s?했습니다|완료되지 않았|검증되지 않았|확인하지 못했|not (?:yet )?(?:verified|completed)|cannot report)/i;
 export function isInterimReportShaped(text: string): boolean {
   return INTERIM_REPORT_SHAPED.test(text);
 }
@@ -631,12 +631,15 @@ export async function runGoalLoop(
   const reinject = (content: string): void => {
     if (iterations >= maxIterations) return;
     const lastIteration = iterations === maxIterations - 1;
+    const reportShaped = isInterimReportShaped(lastResult.finalText);
     try {
       debug.log('goal.loop', 'interim-reply', {
         sessionId: ctx.sessionId, ...runAttribution, iteration: iterations, lastIteration,
-        reportShaped: isInterimReportShaped(lastResult.finalText), finalChars: lastResult.finalText.length,
+        reportShaped, finalChars: lastResult.finalText.length,
       }, { level: 'debug' });
     } catch { /* 관측 실패가 루프를 막지 않는다 */ }
+    // Only a real continuation is interim; terminal and last-iteration answers stay visible.
+    if (lastResult.finalText.trim()) ctx.callbacks?.onGoalInterim?.(lastResult.finalText, iterations);
     const nextIteration = iterations + 1;
     const toolBudget = ctx.maxToolTurns ?? TOOL_LOOP_MAX_TURNS_DEFAULT;
     const shouldAttachDelegateHint = shouldHintDelegate({

package/src/core-turn/types.ts

@@ -103,6 +103,8 @@ export interface CoreTurnCallbacks {
    *  persist this into their history store so the next user turn
    *  sees real tool evidence rather than a string summary. */
   onTurnComplete?(newMessages: LLMMessage[]): void;
+  /** A goal iteration has finished but the goal remains open. Display-only signal; never replaces the turn history. */
+  onGoalInterim?(text: string, iteration: number): void;
   /** Codex Responses API reasoning summary stream (gpt-5 family).
    *  `summary_part_added` marks a paragraph break between successive
    *  parts; `summary_delta` carries the streamed text. Only fires when

package/src/dashboard/chat/acp-chat.ts

@@ -89,6 +89,8 @@ export interface AcpChatHandlers {
   /** Append streamed assistant text. Caller accumulates + redraws.
    *  Receives each chunk exactly as the ACP agent emits it. */
   appendChunk: (delta: string) => void;
+  /** A goal iteration ended; fold only that interim reply in the visible pane. */
+  foldGoalInterim?: (text: string) => void;
   /** Called once per tool_call event with a rendered label like
    *  "→ tool: read_file(/tmp/foo)". Dashboard writes these into the
    *  log pane with a subdued style. */
@@ -430,6 +432,13 @@ export class DashboardAcpChat {
   private dispatchUpdate(update: SessionUpdate, handlers: AcpChatHandlers, sess: AcpChatSession): void {
     switch (update.sessionUpdate) {
       case 'agent_message_chunk': {
+        const interim = (update as typeof update & { _meta?: { goalInterim?: unknown } })._meta?.goalInterim;
+        if (typeof interim === 'string') {
+          this.closeStreamBuffer(sess, 'flush');
+          handlers.foldGoalInterim?.(interim);
+          handlers.redraw?.();
+          return;
+        }
         const c = update.content;
         if (c.type === 'text') {
           this.routeText(sess, c.text, handlers);

package/src/dashboard/index.ts

@@ -255,6 +255,62 @@ import {
   getDashboardContextMenuRegistry,
 } from './context-menu/registry.js';
 import { createTransientOverlayHost } from '../display/transient-overlay-host.js';
+import { beginSynchronizedFrameOutput } from './synchronized-frame-output.js';
+import type { SynchronizedFrameOutputDeps } from './synchronized-frame-output.js';
+export {
+  beginSynchronizedFrameOutput,
+  SYNCHRONIZED_OUTPUT_BEGIN,
+  SYNCHRONIZED_OUTPUT_END,
+} from './synchronized-frame-output.js';
+export type {
+  SynchronizedFrameOutput,
+  SynchronizedFrameOutputDeps,
+} from './synchronized-frame-output.js';
+
+/**
+ * TUI-FLICKER-DRAW-INTEGRATION — the single synchronized-output owner that every
+ * dashboard draw entry goes through: BSU → draw body (frame + coordinator modal
+ * overlay + prompt repaint) → ESU. The finally keeps the region closed when the
+ * body throws, so a failed compose cannot leave a dangling BSU that swallows the
+ * next frame.
+ */
+export function runSynchronizedFrameDraw<T>(
+  drawBody: () => T,
+  deps: SynchronizedFrameOutputDeps,
+): T {
+  const frame = beginSynchronizedFrameOutput(deps);
+  try {
+    return drawBody();
+  } finally {
+    frame.close();
+  }
+}
+
+export interface SynchronizedFrameDrawSink {
+  write: (chunk: string) => void;
+  /** Production passes `process.stdout.isTTY`: only a tty receives DEC 2026. */
+  isTTY?: boolean;
+  /** Environment for the `ELANOUS_SYNC_OUTPUT` escape hatch. Defaults to `process.env`. */
+  env?: Record<string, string | undefined>;
+}
+
+/**
+ * TUI-FLICKER-DRAW-INTEGRATION — production entry for a synchronized dashboard
+ * frame. `drawNow` (the single draw function both the force path and the queued
+ * microtask path call) hands its compose body to this function, so the tty gate
+ * and the BSU/ESU ownership live in exactly one place.
+ */
+export function drawDashboardFrameSynchronized<T>(
+  drawBody: () => T,
+  sink: SynchronizedFrameDrawSink = process.stdout,
+): T {
+  return runSynchronizedFrameDraw(drawBody, {
+    write: (chunk) => { sink.write(chunk); },
+    supported: sink.isTTY === true,
+    env: sink.env,
+  });
+}
+
 import { configureThemeIconsGetter } from '../theme/icons.js';
 import { configureModalAdapterTheme } from '../ui/modal-adapter.js';
 import {
@@ -947,7 +1003,7 @@ import { runPtySnapshot, type PtyTakeoverCommandDeps } from '../cli/pty-takeover
 import { requestRemotePtyControl } from '../pty-shell/pty-control-ipc.js';
 import { getHarnessRunId } from '../harness/harness-space.js';
 import { formatPtyCallLine, formatPtyResultLine } from '../pty-activity-log.js';
-import { getSessionMetrics } from '../status/metrics.js';
+import { getSessionMetrics, noteRestoredContext } from '../status/metrics.js';
 import {
   createContextRegistry, tokenizeInput, pruneUnreferenced,
   addAttachmentEx as ctxAddEx,
@@ -1024,7 +1080,7 @@ import {
   deriveDaemonHttpBase,
   fetchDaemonSessionHistory,
 } from './acp-boot.js';
-import { renderReplayPreviewLines } from './replay-preview.js';
+import { renderRestoredTranscriptLines } from './replay-preview.js';
 import {
   buildDashboardTurnPreamble,
 } from './turn-preamble.js';
@@ -1062,6 +1118,7 @@ import { spawnCodingAgent, CodingAgentBinaryMissing } from '../terminal/coding-a
 import type { TerminalSession } from '../terminal/session-registry.js';
 import { createSessionPickerModal } from '../session/picker-modal.js';
 import { listSessions as listChatSessionsForResume, adoptSession as adoptChatSession, setActiveSessionId as markActiveChatSession } from '../session/index.js';
+import { idPrefixCell, sessionIdPrefixes, sessionListTime } from '../session/id-prefix.js';
 // TUI 부활 S-b — 타임트래블 포크 엔진 (codex ForkSnapshot 동형 · 2026-07-09
 // 이식 후 호출처 0 이던 방치 자산 회수). 순수 히스토리 절단 로직만 소비;
 // 영속은 세션 스토어(forkSessionFromHistory)가 담당한다.
@@ -1213,7 +1270,7 @@ import { type ExecutionSurfaceHandle } from '../display/index.js';
 import { AgentSurfaceStore, renderAgentDetail, renderAgentRoster, type AgentSurfaceState } from '../display/agent-surface.js';
 import { globalAgentFlash } from '../display/agent-flash.js';
 import { globalTaskNotificationQueue, type TaskNotificationQueue, type PendingTaskNotification } from '../agent/task-notification.js';
-import { createDashboardAgentWakeNotify, installAgentWake, wrapAgentWakePort } from './input/agent-wake.js';
+import { createDashboardAgentWakeNotify, installSeatedAgentWake, wrapAgentWakePort } from './input/agent-wake.js';
 import { renderDebugEventDetail, renderDebugEventRows, renderDebugStack, renderPromptInjectionDebug } from '../display/debug-surface.js';
 import { buildDebugCallStack } from '../debug/call-stack.js';
 import { buildAstGrepHostTool } from '../skills/tools/ast-grep.js';
@@ -2752,16 +2809,18 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     // Pickers share the composer bottom slot.
     const placement = resolveDecisionPickerPlacement({ height: 16 });
     const modalWidth = placement.width;
+    // Unique prefixes, not a fixed 8 — two sessions sharing 8 characters used to look identical (TUI-RESUME-PICKER).
+    const idPrefixes = sessionIdPrefixes(rows.map((m) => m.id));
     const fmtRow = (m: (typeof rows)[number]): string => {
       const marker = m.id === attachedSessionId ? '▸ ' : '  ';
-      const ts = m.updatedAt.slice(5, 16).replace('T', ' ');
+      const ts = sessionListTime(m.updatedAt);
       const binds: string[] = [];
       if (m.bindings?.cli) binds.push('cli');
       if (m.bindings?.telegram) binds.push('tg');
       if (m.bindings?.discord) binds.push('dc');
       const bindStr = binds.length > 0 ? `[${binds.join(',')}]` : '';
       const title = (m.title || '(no title)').slice(0, 42);
-      return `${marker}${m.id.slice(0, 8)}  ${ts}  ${String(m.messageCount).padStart(3)}t ${bindStr.padEnd(9)} ${title}`;
+      return `${marker}${idPrefixCell(idPrefixes, m.id)}  ${ts}  ${String(m.messageCount).padStart(3)}t ${bindStr.padEnd(9)} ${title}`;
     };
     const handle = createSearchModal({
       id: `session-resume:${Date.now().toString(36)}`,
@@ -2788,7 +2847,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
           promptCtl.submit(`/session load ${id}`);
         } else {
           // 입력 루프 비활성 등으로 합성 submit 불가 — 수동 안내 폴백.
-          chatLines.push(C.muted(`  /session load ${id.slice(0, 8)} 를 입력해 재개하세요`));
+          chatLines.push(C.muted(`  /session load ${idPrefixes.get(id) ?? id} 를 입력해 재개하세요`));
           chatScrollOffset = -1;
           draw();
         }
@@ -11337,7 +11396,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     try { mouseWiring.toasts().push({ text, kind, ttlMs: 1200 }); } catch { /* ignore */ }
   };
 
-  drawNow = ({ force: forceFromCoordinator = false } = {}) => {
+  const drawFrameNow = ({ force: forceFromCoordinator = false } = {}) => {
     const { rows: termRows, cols } = termSize();
     const totalW = cols - 1;
 
@@ -11781,6 +11840,15 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       if (overlay.length > 0) process.stdout.write(overlay);
     } catch { /* overlay must not crash main draw */ }
   };
+  // TUI-FLICKER-DRAW-INTEGRATION — one synchronized-output owner for the whole
+  // frame compose: BSU → frame (+ coordinator modal overlay) → prompt repaint →
+  // ESU. Both draw entry paths (force and queued microtask) call this same
+  // seam, and the finally keeps the region closed when a compose throws so the
+  // next frame is not swallowed by a dangling BSU. `supported` is the tty gate:
+  // piped/captured output keeps the bytes it had before this seam existed.
+  drawNow = (opts = {}) => {
+    drawDashboardFrameSynchronized(() => { drawFrameNow(opts); }, process.stdout);
+  };
   draw = (opts = {}) => {
     if (debug.enabled) {
       const now = Date.now();
@@ -12645,7 +12713,8 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   const disposeResizeListener = installResizeListener({
     draw: (opts) => draw(opts),
     promptCtl,
-    requestOverlayFrame: () => display.requestRender({ force: true }),
+    requestOverlayFrame: () => display.requestRenderNow({ force: true }),
+    withSynchronizedOutput: (paint) => display.withSynchronizedOutput(paint),
   });
   process.on('exit', disposeResizeListener);
   // 외부 주입(`pty text`)을 사용자 타이핑과 섞지 않고 별도 대기열로 — 결함 #6(10-14).
@@ -13267,14 +13336,16 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     // ⭐ TUI-AGENT-IDLE-WAKE — 배경 자식(⊕ RunShell bg) 완료 큐의 «유일한» 구독(onEnqueue 구독 0 → 1).
     //   채팅 한 줄 «✓ 위임 끝: <이름> — 다음 턴에 결과» · 결과는 다음 턴 preamble 이 싣는다.
     //   ⛔ 입력칸·injectKey·pty 주입 0(대표 비침투). dedupe·수명은 모듈, 여기선 배선만.
-    const agentWake = installAgentWake({
+    const agentWake = installSeatedAgentWake({
       subscribe: (listener) => subscribeDashboardAgentResults(
         globalTaskNotificationQueue, listener, (line) => { pushChatLine(C.muted(line)); draw(); },
       ),
       // 그리기 실패는 삼키지 않는다 — 모듈이 잡아 notified{shown:false} 로 남긴다.
       notify: createDashboardAgentWakeNotify((line) => { chatLines.push(C.muted(line)); }, () => draw()),
       // 조각 2 — 자리 TUI ∧ 유휴면 H2 문으로 다음 턴(origin child-complete) · 판정은 모듈.
-      openTurn: { startTurnIfIdle: (text, opts) => internalTurnGate.startTurnIfIdle(text, opts), getCwd: () => workingDir.cwd, isPending: (taskId) => globalTaskNotificationQueue.has(taskId) },
+      startTurnIfIdle: (text, opts) => internalTurnGate.startTurnIfIdle(text, opts),
+      getCwd: () => workingDir.cwd,
+      isPending: (taskId) => globalTaskNotificationQueue.has(taskId),
     });
     disposeDashboardAgentWake = () => agentWake.dispose();
 
@@ -15236,14 +15307,15 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
               chat.history.push(m as ChatMessage);
             }
             const turns = past.length;
-            chatLines.push(C.muted(`    ${turns} turn${turns === 1 ? '' : 's'} restored. Preview of last 5:`));
+            chatLines.push(C.muted(`    ${turns} turn${turns === 1 ? '' : 's'} restored:`));
+            noteRestoredContext(chat.history);
             // BACKLOG #1 — markdown-aware preview rendering. Replaces
             // the previous one-line `slice(0, 100)` snippet so tables
             // / bold / lists in replayed turns look the same as when
             // they were originally streamed (`formatResponse` path).
             const previewWidth = Math.max(40, termSize().cols - 8);
             const previewWrap = getUserConfig().chat.rendering.wrap;
-            const previewLines = renderReplayPreviewLines(past, {
+            const previewLines = renderRestoredTranscriptLines(past, {
               maxWidth: previewWidth,
               wrapOpts: previewWrap,
             });
@@ -15285,7 +15357,16 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         if (resume.repaired) {
           chatLines.push(C.muted(`    깨진 도구 호출·결과 짝을 잘라 이어받았다(호출 ${resume.repaired.removedCalls} · 결과 ${resume.repaired.removedResults})`));
         }
-        chatLines.push(C.muted(`    ${resume.turns} turns restored. Next turn continues this conversation.`));
+        // TUI-RESUME-PICKER ②③④ — `--resume` used to leave the chat log blank and ctx at 0, so the user could
+        // not see that 379 messages had come back. Show the restored conversation and its size now.
+        chatLines.push(C.muted(`    ${resume.turns} turns restored:`));
+        for (const line of renderRestoredTranscriptLines(chat.history, {
+          maxWidth: Math.max(40, termSize().cols - 8),
+          wrapOpts: getUserConfig().chat.rendering.wrap,
+        })) chatLines.push(line);
+        const restoredTokens = noteRestoredContext(chat.history);
+        debug.log('chat.session.resume', 'restored', { sessionId: resume.sessionId, turns: resume.turns, estimatedContextTokens: restoredTokens });
+        chatLines.push(C.muted('    Next turn continues this conversation.'));
       }
     }
     observeSessionStart({
@@ -17866,6 +17947,9 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
               },
             };
             const slashOutcome = await dashboardSlashRegistry.dispatch(cmdLower, args, slashCtx);
+            if (cmdLower === 'mission') {
+              debug.log('tui.legacy-slash-use', 'mission', { surface: 'classic', tuiSession: null });
+            }
             if (debug.enabled) {
               debug.log('dashboard.slash.dispatch', cmdLower, {
                 argsCount: args.length,

package/src/dashboard/input/agent-wake.ts

@@ -13,6 +13,8 @@
 //   턴 중(NotIdle)·입력 중(HumanTyping)에 온 완료는 «대기»: 입력칸이 다시 뜰 때(`wrapAgentWakePort`) 그 결과가
 //   아직 큐에 남아 있으면(=어느 턴도 안 실었으면) 한 번만 다시 청한다. 이미 실렸으면(drain) 아무것도 안 한다.
 // ⛔ 같은 알림(taskId)은 한 번만 — 큐 `seen` 이 `clear()` 로 비워져도, 대시보드가 재진입해도 막는다.
+// ⭐ 생산 조립은 `installSeatedAgentWake` «하나» — `src/dashboard/index.ts` 의 `showDashboard` 가 그 함수만
+//   부르고, 이 파일의 무대 시험이 «같은 함수»를 지난다(문자열 배선 확인이 아니라 생산 호출 경로 증거).
 //
 // 세 얼굴:
 //   관측 = debug.log('tui.agent-wake', 'notified' | 'opened' | 'rejected' | 'deferred', { taskId, agent, state, seat, shown, reason })
@@ -240,6 +242,47 @@ export function installAgentWake(deps: Omit<AgentWakeDeps, 'handled'>): AgentWak
   return own;
 }
 
+/** 대시보드가 넘기는 «생산 포트» — showDashboard 가 실제로 채우는 모양 그대로. */
+export interface DashboardAgentWakePorts {
+  /** 큐 구독 — `subscribeDashboardAgentResults(globalTaskNotificationQueue, …)` 가 여기로 들어온다. */
+  subscribe: AgentWakeDeps['subscribe'];
+  /** 채팅 한 줄 — `createDashboardAgentWakeNotify(pushLine, draw)`. */
+  notify: AgentWakeDeps['notify'];
+  /** H2 문 — `internalTurnGate.startTurnIfIdle`. 자리 TUI ∧ 유휴일 때만 실제로 열린다. */
+  startTurnIfIdle: AgentWakeOpenTurnDeps['startTurnIfIdle'];
+  /** 지금 화면의 cwd(자리 판정 입력) — `() => workingDir.cwd`. */
+  getCwd: () => string;
+  /** 그 완료가 아직 어느 턴에도 안 실렸나 — `globalTaskNotificationQueue.has`. «대기» 재시도의 근거. */
+  isPending: (taskId: string) => boolean;
+  /** 시험·주입 자리(생산은 안 넘긴다 — 기본 `homedir()`·`detectSeatTui`·`setTimeout 0`). */
+  home?: string;
+  detectSeat?: AgentWakeOpenTurnDeps['detectSeat'];
+  defer?: AgentWakeOpenTurnDeps['defer'];
+  log?: AgentWakeDeps['log'];
+}
+
+/**
+ * 대시보드 생산 조립 — `showDashboard` 는 이 함수 «하나»만 부른다.
+ * 알림(조각 1)과 «자리 TUI ∧ 유휴 → H2 한 턴(origin child-complete)»(조각 2)을 같은 큐 구독에서 낸다.
+ * 중복 거부(같은 taskId 한 번)·DEFERRABLE 대기→입력칸 재시도·수명은 `createAgentWake` 몫이다.
+ */
+export function installSeatedAgentWake(ports: DashboardAgentWakePorts): AgentWakeController {
+  const openTurn: AgentWakeOpenTurnDeps = {
+    startTurnIfIdle: ports.startTurnIfIdle,
+    getCwd: ports.getCwd,
+    isPending: ports.isPending,
+    ...(ports.home !== undefined ? { home: ports.home } : {}),
+    ...(ports.detectSeat !== undefined ? { detectSeat: ports.detectSeat } : {}),
+    ...(ports.defer !== undefined ? { defer: ports.defer } : {}),
+  };
+  return installAgentWake({
+    subscribe: ports.subscribe,
+    notify: ports.notify,
+    openTurn,
+    ...(ports.log !== undefined ? { log: ports.log } : {}),
+  });
+}
+
 /** 시험 격리용 — 설치·공유 dedupe 를 비운다. */
 export function resetAgentWakeForTest(): void {
   installed?.dispose();

package/src/dashboard/input/chat-main-acp-dispatch.ts

@@ -1,6 +1,7 @@
 import type { NormalizedAttachment } from '../../acp/content-blocks.js';
 import { debug } from '../../debug/log.js';
 import type { ControlSignalBus } from '../../input/control-signal.js';
+import { classifyInterimReply, formatInterimFoldLine } from '../../tui/chat/goal-interim.js';
 import {
   createTurnOutputBundle,
   runTurnOutputBundleSettle,
@@ -76,6 +77,8 @@ export function dispatchDashboardChatMainAcpSend(
   let firstChunk = true;
   let assistantTextActive = false;
   let assistantBodyStart = -1;
+  let assistantBodyEnd = -1;
+  const interimBodyRanges: Array<{ start: number; end: number }> = [];
   let assistantBodyText = '';
   let assistantRunUsesPrefix = false;
 
@@ -91,6 +94,7 @@ export function dispatchDashboardChatMainAcpSend(
         if (firstChunk) firstChunk = false;
         assistantBodyText = '';
         assistantBodyStart = -1;
+        assistantBodyEnd = -1;
         assistantTextActive = true;
       }
       assistantBodyText += delta;
@@ -110,7 +114,7 @@ export function dispatchDashboardChatMainAcpSend(
       deps.autoTtsHooks?.pushChunk(delta);
       const rendered = deps.formatAssistantLines(assistantBodyText);
       if (assistantBodyStart < 0) assistantBodyStart = deps.chatLines.length;
-      deps.chatLines.length = assistantBodyStart;
+      deps.chatLines.splice(assistantBodyStart, Math.max(0, assistantBodyEnd - assistantBodyStart));
       rendered.forEach((line, index) => {
         if (index === 0 && assistantRunUsesPrefix) {
           deps.chatLines.push(`${deps.formatAssistantPrefix(display)} ${line}`);
@@ -118,8 +122,24 @@ export function dispatchDashboardChatMainAcpSend(
           deps.chatLines.push(`  ${line}`);
         }
       });
+      assistantBodyEnd = assistantBodyStart + rendered.length;
+      if (interimBodyRanges.at(-1)?.start === assistantBodyStart) interimBodyRanges[interimBodyRanges.length - 1]!.end = assistantBodyEnd;
+      else interimBodyRanges.push({ start: assistantBodyStart, end: assistantBodyEnd });
       deps.setChatScrollToTail();
     },
+    foldGoalInterim: (text) => {
+      const verdict = classifyInterimReply(text.split('\n'));
+      if (verdict.interim && interimBodyRanges.length > 0) {
+        const first = interimBodyRanges[0]!.start;
+        for (const { start, end } of [...interimBodyRanges].reverse()) deps.chatLines.splice(start, end - start);
+        deps.chatLines.splice(first, 0, `  ${formatInterimFoldLine(verdict.summary)}`);
+        deps.setChatScrollToTail();
+      }
+      interimBodyRanges.length = 0;
+      assistantTextActive = false;
+      assistantBodyStart = -1;
+      assistantBodyEnd = -1;
+    },
     pushToolCall: (tool) => {
       deps.chatLines.push(deps.formatToolLine(tool));
       deps.setChatScrollToTail();

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/slash-runtime/dashboard-handlers.ts

@@ -364,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,
@@ -2395,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}`));
       }
@@ -2602,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
@@ -2628,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) {
@@ -2734,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,
                 });
@@ -2792,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,
       });