elanous 0.2.35 → 0.2.36

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';
@@ -4800,7 +4801,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';

package/src/debug/batch-queue.ts

@@ -0,0 +1,119 @@
+// TUI-TYPING-LAG — bounded-chunk drain queue for the log plane.
+//
+// A worker that floods the log (streaming chunks, subagent output) used to hand
+// the main thread one synchronous drain of the whole burst (e.g. StoreSink's
+// detached flush inserting thousands of sqlite rows in one macrotask), so a key
+// typed meanwhile waited for the entire drain (0.25–2.4s stalls). This queue
+// drains at most `batchSize` items per scheduled tick and schedules the remainder
+// as a NEW tick, so the event loop gets back to I/O (stdin) between chunks.
+//
+// Zero imports on purpose: the log sinks under
+// src/mss/logging import it without creating a cycle.
+
+/** Scheduler seam — production uses setImmediate / setTimeout(unref); stages inject a fake clock. */
+export interface DebugBatchScheduler {
+  schedule(run: () => void, delayMs: number): unknown;
+  cancel(handle: unknown): void;
+}
+
+export const defaultDebugBatchScheduler: DebugBatchScheduler = {
+  schedule(run, delayMs) {
+    if (delayMs <= 0) return { immediate: setImmediate(run) };
+    const timer = setTimeout(run, delayMs);
+    (timer as unknown as { unref?: () => void }).unref?.();
+    return { timeout: timer };
+  },
+  cancel(handle) {
+    const h = handle as { immediate?: ReturnType<typeof setImmediate>; timeout?: ReturnType<typeof setTimeout> } | null;
+    if (!h) return;
+    if (h.immediate !== undefined) clearImmediate(h.immediate);
+    if (h.timeout !== undefined) clearTimeout(h.timeout);
+  },
+};
+
+export interface DebugLogBatchQueueOptions<T> {
+  /** Max items handed to `drain` per scheduled tick. `Infinity` = whole queue in one tick. */
+  batchSize: number;
+  /** Delay before each scheduled tick (0 = next loop iteration). */
+  flushDelayMs?: number;
+  scheduler?: DebugBatchScheduler;
+  /** Return `false` to stop chunking (e.g. the store is contended) — the remainder stays queued, unscheduled. */
+  drain: (items: T[]) => void | boolean;
+}
+
+export class DebugLogBatchQueue<T> {
+  private items: T[] = [];
+  private handle: unknown = null;
+  private hasHandle = false;
+  private flushCount = 0;
+  private readonly batchSize: number;
+  private readonly flushDelayMs: number;
+  private readonly scheduler: DebugBatchScheduler;
+  private readonly drainFn: (items: T[]) => void | boolean;
+
+  constructor(opts: DebugLogBatchQueueOptions<T>) {
+    this.batchSize = opts.batchSize > 0 ? opts.batchSize : 1;
+    this.flushDelayMs = Math.max(0, opts.flushDelayMs ?? 0);
+    this.scheduler = opts.scheduler ?? defaultDebugBatchScheduler;
+    this.drainFn = opts.drain;
+  }
+
+  get pending(): number { return this.items.length; }
+  get flushes(): number { return this.flushCount; }
+  get scheduled(): boolean { return this.hasHandle; }
+
+  /** Enqueue without draining — the caller decides when to `schedule()`. */
+  push(item: T): void { this.items.push(item); }
+
+  /** Arm one drain tick (idempotent while a tick is in flight). */
+  schedule(): void {
+    if (this.hasHandle || this.items.length === 0) return;
+    this.hasHandle = true;
+    this.handle = this.scheduler.schedule(() => this.tick(), this.flushDelayMs);
+  }
+
+  /** Drop up to `count` oldest items; returns how many were dropped. */
+  dropOldest(count: number): number {
+    if (count <= 0) return 0;
+    const dropped = Math.min(count, this.items.length);
+    this.items.splice(0, dropped);
+    return dropped;
+  }
+
+  /** Synchronous full drain (exit / explicit flush) — one `drain` call, pending tick cancelled. */
+  flushAll(): void {
+    this.cancelTick();
+    if (this.items.length === 0) return;
+    const all = this.items;
+    this.items = [];
+    this.flushCount += 1;
+    this.drainFn(all);
+  }
+
+  /** Disarm the pending tick (items stay queued) — e.g. the store is contended. */
+  cancelScheduled(): void { this.cancelTick(); }
+
+  private cancelTick(): void {
+    if (!this.hasHandle) return;
+    this.scheduler.cancel(this.handle);
+    this.handle = null;
+    this.hasHandle = false;
+  }
+
+  private tick(): void {
+    this.handle = null;
+    this.hasHandle = false;
+    if (this.items.length === 0) return;
+    const chunk = Number.isFinite(this.batchSize)
+      ? this.items.splice(0, this.batchSize)
+      : this.items.splice(0, this.items.length);
+    this.flushCount += 1;
+    let keepGoing = true;
+    try {
+      keepGoing = this.drainFn(chunk) !== false;
+    } finally {
+      // The remainder is a separate tick so stdin can be served between chunks.
+      if (keepGoing) this.schedule();
+    }
+  }
+}

package/src/debug/tui-log-tag.ts

@@ -0,0 +1,67 @@
+// TUI-LOG-SESSION-TAG (0.2.36 · 10-23) — tell TUIs apart in one logs.db.
+//
+// Several TUIs (classic `elanous` / `--legacy` and `--tui next`) on one host write to the same logs.db
+// with surface `tui`. Their rows had no pid and usually no session_id (the dashboard does not set the
+// ambient session), so the 10-23 n8n SIGTTIN incident could not tell which TUI's `tui.event-loop stall`
+// was which. This wraps the TUI's logs.db sink and stamps every plain-object payload with:
+//   tuiPid      — the TUI process id
+//   tuiName     — the `--name` launch alias (when given)
+//   tuiSession  — the chat session the TUI currently owns (getTuiOwnedSession, when known)
+// Caller-supplied fields win; primitive / non-plain payloads are left untouched; an absent payload becomes
+// the tag object. No schema change — the tag rides in the existing `data` column.
+//
+// Query: `elanous logs --surface tui --grep '"tuiName":"n8n"'` · `--grep '"tuiPid":20960'`
+//        or `--json | jq 'select((.data|fromjson? // {}).tuiName == "n8n")'`.
+
+import type { LogSink } from '../mss/logging/sink.js';
+import type { LogRecord } from '../mss/logging/record.js';
+
+export interface TuiLogTag {
+  pid: number;
+  name?: string;
+  /** Current owned chat session id, or null. Called per record — keep it cheap. */
+  session?: () => string | null | undefined;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  if (value === null || typeof value !== 'object') return false;
+  const p = Object.getPrototypeOf(value);
+  return p === Object.prototype || p === null;
+}
+
+/** Pure — returns the record with the tag applied (a new object when changed). */
+export function tagTuiRecord(rec: LogRecord, tag: TuiLogTag): LogRecord {
+  let session: string | null | undefined;
+  try { session = tag.session?.(); } catch { session = undefined; }
+  const add: Record<string, unknown> = { tuiPid: tag.pid };
+  const name = tag.name?.trim();
+  if (name) add.tuiName = name;
+  if (session) add.tuiSession = session;
+  if (rec.data === undefined) return { ...rec, data: add };
+  if (!isPlainObject(rec.data)) return rec;
+  const data = rec.data;
+  const missing = Object.entries(add).filter(([k]) => !Object.hasOwn(data, k));
+  if (missing.length === 0) return rec;
+  return { ...rec, data: { ...data, ...Object.fromEntries(missing) } };
+}
+
+// Process-wide tag state — the TUI's self-report fills it (`--name` at launch, the owned session on every
+// claim) so the sink wrapper needs no import of the TUI modules (no cycle · no hub edit).
+let processName: string | undefined;
+let processSession: string | null = null;
+export function setTuiLogName(name: string | undefined): void { processName = name?.trim() || undefined; }
+export function setTuiLogSession(id: string | null): void { processSession = id || null; }
+/** The tag for this process: pid ⊕ the state above. */
+export function processTuiLogTag(): TuiLogTag {
+  return { pid: process.pid, get name() { return processName; }, session: () => processSession };
+}
+
+/** Wraps a sink so every record it receives is tagged. */
+export function withTuiLogTag(inner: LogSink, tag: TuiLogTag): LogSink {
+  return {
+    name: inner.name,
+    emit(rec: LogRecord): void { inner.emit(tagTuiRecord(rec, tag)); },
+    ...(inner.flush ? { flush: () => inner.flush?.() } : {}),
+    ...(inner.clear ? { clear: () => inner.clear?.() } : {}),
+  };
+}

package/src/display/agent-surface.ts

@@ -447,7 +447,14 @@ function recentToolTrail(task: AgentTask, limit: number, cache: ScanCache): Agen
   return trail;
 }
 
+/** Tool calls the child made: the live counter (bumped as each call starts) or the
+ *  tool_use blocks in its history, whichever is larger — history lags until a tool
+ *  loop completes and stays short when the run is aborted or errors. */
 function countToolUses(task: AgentTask, cache: ScanCache): number {
+  return Math.max(task.toolCallCount ?? 0, countHistoryToolUses(task, cache));
+}
+
+function countHistoryToolUses(task: AgentTask, cache: ScanCache): number {
   const len = task.messages?.length ?? 0;
   if (len === 0) return 0;
   const cached = cache.count.get(task.id);