elanous 0.2.27 → 0.2.29

package/src/dashboard/seat-local-instructions.ts

@@ -0,0 +1,305 @@
+// 🪪 L2-lite — TUI 가 자기 자리 로컬 지시(`AGENTS.local.md`)를 «만들고 이어 쓴다» (TUI-SEAT-CONTINUITY · 2026-10-14).
+//
+// S: 자리(`~/elanous-hq/seats/<자리>`)에서 TUI 를 다시 띄우면 지난 세션에 무엇을 하다 나갔는지 모른다.
+//    TUI 는 파일 기억(`buildMemoryInjection`)을 받지 않고 턴·세션 끝 기억 쓰기도 없다 — 연속성 장치가 0 이다.
+// A: 둘을 한다.
+//    ① 생성 — 자리 디렉터리에서 뜰 때 로컬 지시 파일이 «하나도» 없으면 템플릿으로 `AGENTS.local.md` 를 만든다.
+//       재료: seat-state/<자리>/README.md 머리 ⊕ 자리 이름 ⊕ 저장소 AGENTS.md §제1원칙 요지(출처 줄) ⊕ «## 시작하면» 기본 절차.
+//       ⛔ 사람이 쓴 파일은 절대 덮어쓰지 않는다 — `AGENTS.local.md` 든 `CLAUDE.local.md` 든 있으면 생성 0
+//       (`CLAUDE.local.md` 만 있는데 `AGENTS.local.md` 를 만들면 앵커 로더가 사람 파일을 shadowed 로 가린다).
+//    ② 이어쓰기 — «지난 세션»은 TUI 가 «통째로 소유하는» 별도 파일(자리 루트 `.AGENTS.local.last-session.md` · git 제외)에
+//       대화가 끝날 때(`/quit`·Ctrl+C·SIGINT/SIGTERM = process 'exit' · `/session new`·`clear`) 5줄 이내로 쓴다(tmp ⊕ rename).
+//       ⛔ 사람 지시 파일은 «고치지 않는다» — 사람 파일 안의 블록을 갈아 쓰면 잠금 없이는 경쟁 창을 0 으로 못 만든다(#27505 r1~r4).
+//       재료는 대화 기록(마지막 요청·마지막 답 요지·열린 일 후보·다음 점검 시각 후보) — LLM 호출 없이 동기로(종료 경로).
+//       실패해도 종료를 막지 않는다.
+//    ③ 다음 기동 때 L0 앵커 로더(`universal-preamble.ts`)가 그 파일을 층 ④(로컬 지시) 뒤 조각으로 싣는다.
+// 관측: `tui.local-instructions` created / create-skipped / last-session-written / last-session-skipped.
+// ⛔ 생성은 cwd 가 `/seats/<자리>` 일 때만 — `COORD_ID` 만으로는 아무 저장소 디렉터리에 파일을 만들지 않는다.
+
+import { existsSync, lstatSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { randomBytes } from 'node:crypto';
+import { dirname, join } from 'node:path';
+import { debug } from '../debug/log.js';
+
+export const LOCAL_INSTRUCTIONS_FILE = 'AGENTS.local.md';
+const COMPAT_LOCAL_FILE = 'CLAUDE.local.md';
+/** TUI 가 통째로 소유하는 «지난 세션» 파일 — 자리 루트에 둔다. L0 앵커 로더가 같은 이름을 읽는다. */
+export const LAST_SESSION_FILE = '.AGENTS.local.last-session.md';
+const SEAT_DIR_IN_PATH = /^(.*?\/seats\/([A-Za-z][A-Za-z0-9_-]{0,63}))(?:\/|$)/;
+const README_HEAD_MAX = 1200;
+const PRINCIPLE_MAX = 1500;
+const MAX_LAST_SESSION_LINES = 5;
+const LINE_MAX = 200;
+
+/** cwd 가 `/seats/<자리>` 아래면 자리 루트 디렉터리와 자리 이름. */
+export function seatDirFromCwd(cwd: string): { seat: string; dir: string } | null {
+  const m = SEAT_DIR_IN_PATH.exec(cwd);
+  if (!m) return null;
+  return { seat: m[2]!.toUpperCase(), dir: m[1]! };
+}
+
+function readHead(path: string, maxChars: number): string | null {
+  try {
+    if (!statSync(path).isFile()) return null;
+    const raw = readFileSync(path, 'utf8');
+    if (raw.length <= maxChars) return raw.trim();
+    const cut = raw.slice(0, maxChars);
+    return `${cut.slice(0, Math.max(0, cut.lastIndexOf('\n'))).trim()}\n…(이하 생략 — 원문을 읽어라)`;
+  } catch {
+    return null;
+  }
+}
+
+function findAncestorFile(startDir: string, filename: string): string | null {
+  let dir = startDir;
+  for (;;) {
+    const candidate = join(dir, filename);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+/** 저장소 AGENTS.md 의 «제1원칙» 절에서 요지(북극성·넘버원 룰·SCQA 문법)를 뽑는다. 원문 복제가 아니라 발췌 ⊕ 출처. */
+export function extractFirstPrinciple(agentsMd: string): string | null {
+  const lines = agentsMd.split(/\r?\n/);
+  const start = lines.findIndex(line => /^##\s.*제1원칙/.test(line));
+  if (start < 0) return null;
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i++) {
+    if (/^##\s/.test(lines[i]!)) { end = i; break; }
+  }
+  const section = lines.slice(start + 1, end);
+  const picked: string[] = [];
+  for (let i = 0; i < section.length; i++) {
+    const line = section[i]!;
+    if (/\*\*북극성\*\*/.test(line)) {
+      picked.push(line);
+      const next = section[i + 1];
+      if (next && next.trim() && !/^\*\*/.test(next.trim())) picked.push(next);
+    } else if (/\*\*넘버원 룰\*\*/.test(line) || /\*\*문법 = `SCQA`\*\*/.test(line)) {
+      picked.push(line);
+    }
+  }
+  const body = (picked.length ? picked : section.filter(l => l.trim() && !l.startsWith('>'))).join('\n').trim();
+  if (!body) return null;
+  return body.length > PRINCIPLE_MAX ? `${body.slice(0, PRINCIPLE_MAX)}…` : body;
+}
+
+export function renderLocalInstructionsTemplate(input: { seat: string; readmeHead: string | null; principle: string | null; at: string }): string {
+  const out = [
+    `# ${input.seat} 자리 — 로컬 지시 (TUI 가 ${input.at} 에 만들었다 · 사람이 고쳐도 된다)`,
+    '',
+    `너는 **${input.seat}** 자리의 엘라누스 TUI 다. 이 파일은 git 에 안 올라가는 «이 자리만의» 지시이고, 저장소 공용 지시(AGENTS.md)와 다르면 이 파일이 우선한다.`,
+    '',
+    '## 자리 정본 (seat-state README 머리)',
+    input.readmeHead ?? `- 미관측: ~/elanous-hq/seat-state/${input.seat}/README.md 없음 — 역할은 사람에게 묻고 이 절을 채워라.`,
+    '',
+  ];
+  if (input.principle) {
+    out.push('## 제1원칙 (요지)', '> 정본 = 저장소 AGENTS.md §제1원칙 — 아래는 발췌다. 어긋나면 정본이 이긴다.', '', input.principle, '');
+  }
+  out.push(
+    '## 시작하면',
+    `- 우편함을 읽는다: \`eln msg list --to ${input.seat}\` — 안 읽은 우편 수와 처리할 것을 먼저 말한다.`,
+    `- 자리 인계를 읽는다: ~/elanous-hq/seat-state/${input.seat}/HANDOFF.md (있으면).`,
+    '- 앵커의 «지난 세션» 조각(TUI 가 `.AGENTS.local.last-session.md` 에 남긴다)의 열린 일을 이어받고, 다음 점검 시각을 정해 말한다.',
+    '',
+  );
+  return out.join('\n');
+}
+
+export interface SeatLocalDeps {
+  home?: string;
+  now?: () => Date;
+  /** 시험 심 — 생성(wx) 직후, 경쟁 확인 «전»에 불린다(사람이 그 틈에 파일을 만들거나 고치는 경우 재현). */
+  afterCreateForTest?: (path: string) => void;
+}
+
+/** 자리 디렉터리에서 로컬 지시 파일이 하나도 없으면 템플릿으로 만든다. 결과를 첫 화면 한 줄에 쓴다. */
+/** 경로에 «무엇이든» 있나 — 링크는 대상이 없어도 있다(lstat). */
+function entryPresent(path: string): boolean {
+  try { lstatSync(path); return true; } catch { return false; }
+}
+
+export function ensureSeatLocalInstructions(cwd: string, deps: SeatLocalDeps = {}): { status: 'created' | 'exists' | 'not-seat' | 'error'; path?: string; missingPrinciple?: boolean } {
+  const seatDir = seatDirFromCwd(cwd);
+  if (!seatDir) return { status: 'not-seat' };
+  const path = join(seatDir.dir, LOCAL_INSTRUCTIONS_FILE);
+  try {
+    for (const name of [LOCAL_INSTRUCTIONS_FILE, COMPAT_LOCAL_FILE]) {
+      const existing = join(seatDir.dir, name);
+      // ⛔ «링크 자체»의 존재로 판정한다(lstat) — 대상이 없는 링크도 «있음»이다(existsSync 는 그것을 «없음»으로 본다).
+      if (entryPresent(existing)) {
+        // ⛔ 덮어쓰기 0 — 제1원칙 절이 없으면 «제안»만 한다(읽을 수 없는 링크면 제안도 안 한다).
+        let body = '';
+        try { body = readFileSync(existing, 'utf8'); } catch { body = '제1원칙'; }
+        const missingPrinciple = !/제1원칙/.test(body);
+        debug.log('tui.local-instructions', 'create-skipped', { seat: seatDir.seat, path: existing, reason: 'exists', missingPrinciple });
+        return { status: 'exists', path: existing, missingPrinciple };
+      }
+    }
+    const home = deps.home ?? homedir();
+    const readmeHead = readHead(join(home, 'elanous-hq', 'seat-state', seatDir.seat, 'README.md'), README_HEAD_MAX);
+    const agentsPath = findAncestorFile(seatDir.dir, 'AGENTS.md');
+    const principle = agentsPath ? extractFirstPrinciple(readFileSync(agentsPath, 'utf8')) : null;
+    const text = renderLocalInstructionsTemplate({ seat: seatDir.seat, readmeHead, principle, at: (deps.now?.() ?? new Date()).toISOString() });
+    // `wx` = 없을 때만 만든다 — 확인과 쓰기 사이에 사람이 만든 파일도 덮지 않는다.
+    writeFileSync(path, text, { flag: 'wx' });
+    deps.afterCreateForTest?.(path);
+    // 경쟁: 확인과 생성 사이에 사람이 호환 파일을 만들었으면 우리 파일이 그것을 가린다 — 방금 만든 것을 거둔다.
+    if (entryPresent(join(seatDir.dir, COMPAT_LOCAL_FILE))) {
+      // ⛔ «방금 쓴 내용과 같을 때만» 지운다 — 그 사이 사람이 고쳤으면 사람 문면을 지우지 않고 둘 다 남긴다(관측).
+      let unchanged = false;
+      try { unchanged = readFileSync(path, 'utf8') === text; } catch { unchanged = false; }
+      if (unchanged) rmSync(path, { force: true });
+      debug.log('tui.local-instructions', 'create-skipped', { seat: seatDir.seat, path, reason: 'compat-appeared', removedOwn: unchanged });
+      return { status: 'exists', path: join(seatDir.dir, COMPAT_LOCAL_FILE), missingPrinciple: false };
+    }
+    debug.log('tui.local-instructions', 'created', { seat: seatDir.seat, path, chars: text.length, hasReadme: readmeHead !== null, hasPrinciple: principle !== null });
+    return { status: 'created', path };
+  } catch (err) {
+    debug.log('tui.local-instructions', 'create-skipped', { seat: seatDir.seat, path, reason: 'error', error: err instanceof Error ? err.message : String(err) });
+    return { status: 'error', path };
+  }
+}
+
+// ── «지난 세션» 이어쓰기 ────────────────────────────────────────────────
+
+export interface SessionMessage {
+  role: string;
+  content: unknown;
+}
+
+function messageText(content: unknown): string {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .map(block => (block && typeof block === 'object' && (block as { type?: unknown }).type === 'text' ? String((block as { text?: unknown }).text ?? '') : ''))
+      .filter(Boolean)
+      .join('\n');
+  }
+  return '';
+}
+
+/** 대시보드는 사람 턴을 `Context:\n…\n\nQuestion: <질문>` 으로 감싸 history 에 넣는다(turn-message-runtime.ts) — 질문만 꺼낸다. */
+function userQuestion(text: string): string {
+  const marker = '\n\nQuestion: ';
+  if (!text.startsWith('Context:') || !text.includes(marker)) return text;
+  return text.slice(text.lastIndexOf(marker) + marker.length);
+}
+
+function oneLine(text: string): string {
+  const flat = text.replace(/\s+/g, ' ').trim();
+  return flat.length > LINE_MAX ? `${flat.slice(0, LINE_MAX - 1)}…` : flat;
+}
+
+/** 대화 기록에서 «지난 세션» 5줄 이내. 사람 턴이 없으면 null(쓸 것이 없다). */
+export function summarizeSession(history: readonly SessionMessage[], meta: { endedAt: string; reason: string }): string[] | null {
+  const turns = history
+    .filter(m => m.role === 'user' || m.role === 'assistant')
+    .map(m => ({ role: m.role, text: (m.role === 'user' ? userQuestion(messageText(m.content)) : messageText(m.content)).trim() }))
+    .filter(t => t.text);
+  const userTurns = turns.filter(t => t.role === 'user');
+  if (userTurns.length === 0) return null;
+  const lastUserIdx = turns.map(t => t.role).lastIndexOf('user');
+  const lastAssistantIdx = turns.map(t => t.role).lastIndexOf('assistant');
+  // 마지막 요청에 답하기 «전»에 끝났으면 그 앞 답을 이 요청의 답처럼 적지 않는다.
+  const unanswered = lastAssistantIdx < lastUserIdx;
+  const lastAnswer = lastAssistantIdx >= 0 ? turns[lastAssistantIdx]!.text : '';
+  const answerLines = lastAnswer.split(/\r?\n/).map(l => l.trim()).filter(Boolean);
+  const open = answerLines.filter(l => /(다음|남은|열린|후속|미완|대기|TODO|할 일|이어서)/i.test(l)).slice(0, 2);
+  const nextCheck = /(\d{1,2}:\d{2})/.exec(open.join(' ') || lastAnswer)?.[1];
+  const lines = [
+    `- 끝: ${meta.endedAt} · ${meta.reason} · 사람 턴 ${userTurns.length}`,
+    unanswered
+      ? `- 마지막 요청(답 없이 끝남 — 이어서 처리할 일): ${oneLine(userTurns.at(-1)!.text)}`
+      : `- 마지막 요청: ${oneLine(userTurns.at(-1)!.text)}`,
+  ];
+  if (answerLines.length) lines.push(`- ${unanswered ? '그 전 답 요지' : '마지막 답 요지'}: ${oneLine(answerLines[0]!)}`);
+  const fromPrev = unanswered ? '(그 전 답에서 — 마지막 요청의 후속이 아니다) ' : '';
+  lines.push(`- 열린 일: ${open.length ? `${fromPrev}${open.map(oneLine).join(' / ')}` : '미관측(답에 «다음·남은·열린» 줄 없음) — 자리 우편·HANDOFF 로 확인'}`);
+  if (nextCheck) lines.push(`- 다음 점검 시각(${unanswered ? '그 전 답에서' : '답에서'}): ${nextCheck}`);
+  return lines.slice(0, MAX_LAST_SESSION_LINES);
+}
+
+/** «지난 세션» 파일 본문 — 머리 한 줄 ⊕ 요약 줄. */
+export function renderLastSessionFile(lines: readonly string[]): string {
+  return `## 지난 세션 (TUI 가 대화 끝마다 갈아 쓴다 · 사람이 고치지 않는 파일)\n${lines.join('\n')}\n`;
+}
+
+/** 대화 끝에 «지난 세션»을 TUI 소유 파일에 쓴다(동기 · 종료 경로 · tmp ⊕ rename). 사람 지시 파일은 건드리지 않는다. 실패는 관측만. */
+export function writeLastSession(cwd: string, history: readonly SessionMessage[], reason: string, deps: SeatLocalDeps = {}): 'written' | 'skipped' {
+  const seatDir = seatDirFromCwd(cwd);
+  if (!seatDir) return 'skipped';
+  const path = join(seatDir.dir, LAST_SESSION_FILE);
+  let tmp: string | null = null;
+  try {
+    const lines = summarizeSession(history, { endedAt: (deps.now?.() ?? new Date()).toISOString(), reason });
+    if (!lines) {
+      debug.log('tui.local-instructions', 'last-session-skipped', { seat: seatDir.seat, reason: 'no-user-turn' });
+      return 'skipped';
+    }
+    // 이 이름이 링크면(누가 심었으면) 따라가 쓰지 않는다.
+    if (existsSync(path) && lstatSync(path).isSymbolicLink()) {
+      debug.log('tui.local-instructions', 'last-session-skipped', { seat: seatDir.seat, path, reason: 'symlink' });
+      return 'skipped';
+    }
+    const text = renderLastSessionFile(lines);
+    tmp = `${path}.tmp-${process.pid}-${randomBytes(6).toString('hex')}`;
+    writeFileSync(tmp, text, { flag: 'wx', mode: 0o600 });
+    renameSync(tmp, path);
+    tmp = null;
+    debug.log('tui.local-instructions', 'last-session-written', { seat: seatDir.seat, path, reason, lines: lines.length, chars: text.length });
+    return 'written';
+  } catch (err) {
+    debug.log('tui.local-instructions', 'last-session-skipped', { seat: seatDir.seat, reason: 'error', error: err instanceof Error ? err.message : String(err) });
+    return 'skipped';
+  } finally {
+    if (tmp) { try { if (!lstatSync(tmp).isSymbolicLink()) rmSync(tmp, { force: true }); } catch { /* 없으면 그만 */ } }
+  }
+}
+
+export interface SessionRecorderDeps {
+  getCwd: () => string;
+  getHistory: () => readonly SessionMessage[];
+  onExit?: (fn: () => void) => void;
+}
+
+let recorder: SessionRecorderDeps | null = null;
+let recordedThisConversation = false;
+// 대화의 기록 대상 디렉터리 — 대화가 «시작될 때» 고정한다(도중 cwd 를 옮겨도 다른 자리 파일에 쓰지 않게).
+let conversationCwd: string | null = null;
+
+export function resetSessionRecorderForTest(): void {
+  recorder = null;
+  recordedThisConversation = false;
+  conversationCwd = null;
+}
+
+/** 대화 끝 기록 — 같은 대화에서 두 번 쓰지 않는다(`/session new` 뒤 `exit` 등). */
+export function recordSeatSessionEnd(reason: string): void {
+  if (!recorder || recordedThisConversation) return;
+  const cwd = conversationCwd ?? recorder.getCwd();
+  if (writeLastSession(cwd, recorder.getHistory(), reason) === 'written') recordedThisConversation = true;
+}
+
+/** 새 대화가 시작됐다 — 기록 대상을 지금 cwd 로 다시 고정하고, 다음 끝에서 다시 쓴다. */
+export function markSeatConversationStarted(): void {
+  recordedThisConversation = false;
+  conversationCwd = recorder?.getCwd() ?? null;
+}
+
+/** 대시보드가 부팅 때 한 번 건다. `/quit`·Ctrl+C·SIGINT/SIGTERM 은 모두 process 'exit' 로 끝난다(tui.ts 핸들러가 process.exit). */
+export function installSeatSessionRecorder(deps: SessionRecorderDeps): void {
+  const first = recorder === null;
+  recorder = deps;
+  conversationCwd = deps.getCwd();
+  if (!first) return;
+  const onExit = deps.onExit ?? ((fn: () => void) => { process.on('exit', fn); });
+  onExit(() => {
+    try { recordSeatSessionEnd('exit'); } catch { /* 종료는 언제나 끝까지 간다 */ }
+  });
+}

package/src/dashboard/skill-detection-runtime.ts

@@ -7,16 +7,26 @@ import {
 } from '../skills/router.js';
 import type { SkillIndexEntry } from '../skills/index.js';
 import type { SkillTier } from '../skills/runner.js';
-import type { LLMMessage } from '../llm.js';
+import * as llm from '../llm.js';
+import { resolveRoleLlm } from '../user-config.js';
+import { debug } from '../debug/log.js';
 
 export interface DashboardSkillDetectionRuntimeDeps {
   llmFallback: boolean;
   keywordScoreThreshold: number;
   llmConfidenceThreshold: number;
   streamLLM: (
-    messages: LLMMessage[],
+    messages: llm.LLMMessage[],
     onDelta: (chunk: string, full: string) => void,
-    opts: { signal?: AbortSignal; maxTokens?: number; temperature?: number },
+    opts: {
+      signal?: AbortSignal;
+      maxTokens?: number;
+      temperature?: number;
+      /** classify role pin — resolveRoleLlm('classify')가 고른 모델·프로바이더. */
+      model?: string;
+      provider?: (typeof llm.PROVIDERS)[string];
+      usageRole?: 'classify';
+    },
   ) => Promise<string>;
   /** Active model tier — enables tier-aware full-menu LLM routing in
    *  detectLLM (T1 frontier models route the whole menu when keyword is
@@ -69,10 +79,20 @@ export async function detectDashboardSkillRoute(
   if (!deps.llmFallback) return keywordDetection;
 
   const classify = async (prompt: string, signal?: AbortSignal): Promise<LLMClassifyResult> => {
+    const resolved = resolveRoleLlm('classify');
+    const provider = llm.PROVIDERS[resolved.provider];
+    if (!provider) throw new Error(`Unknown classify provider: ${resolved.provider}`);
+    debug.log('llm.role-pin', 'resolved', {
+      site: 'skill-detection-runtime',
+      role: 'classify',
+      model: resolved.model,
+      provider: resolved.provider,
+      source: resolved.source,
+    });
     const raw = await deps.streamLLM(
       [{ role: 'user', content: prompt }],
       () => {},
-      { signal, maxTokens: 120, temperature: 0 },
+      { signal, maxTokens: 120, temperature: 0, model: resolved.model, provider, usageRole: 'classify' },
     );
     return parseClassifier(raw);
   };

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

@@ -272,7 +272,8 @@
 // `../index.ts`) instead of importing the type — keeps this module free
 // of circular dependency on dashboard/index.ts.
 
-import { tuiNowSlash } from '../../context-bus/context-now-surfaces.js';
+import { renderTuiNow, tuiNowSlash } from '../../context-bus/context-now-surfaces.js';
+import { contextNowInWorker } from '../../context-bus/context-now.js';
 import { handleTuiChatPersona, type TuiChatPersonaSelection } from './chat-persona.js';
 import { createWishCard } from '../../intake-plane/wish-card.js';
 import { CardStore } from '../../task-cards/card-store.js';
@@ -284,6 +285,8 @@ import { resolveRepositoryDesignCheck } from '../../cli/repo-cli.js';
 import { renderDesignCheckLines, type DesignCheckTone } from '../../design/design-check-render.js';
 import { handleDesignPick } from './design-pick.js';
 import { createDecideSlashHandler } from './decide-slash.js';
+import { startSeatBootConversation } from '../seat-boot-preamble.js';
+import { markSeatConversationStarted, recordSeatSessionEnd } from '../seat-local-instructions.js';
 import type { DecisionLedger } from '../../decisions/decision-ledger.js';
 import { listDesignDirections, parseDeclaredDirection } from '../../design/design-directions.js';
 import {
@@ -343,7 +346,7 @@ import { terminalModalRouter } from '../input/terminal-modal-router.js';
 import { termSize, stripAnsi } from '../../tui.js';
 import { SLASH_COMMANDS } from '../../chat/index.js';
 import { buildEssentialHelpLines } from './help-from-registry.js';
-import { HUMAN_MODEL_WORDS, MODEL_CODE_NAMES, humanWordForModel, modelChangeLine, modelOverviewLines, resolveModelChoice } from './model-choices.js';
+import { HUMAN_MODEL_WORDS, MODEL_CODE_NAMES, humanWordForModel, modelChangeLine, modelOverviewLines, modelScopeLine, modelSwitchScope, parseModelSlashArgs, resolveModelChoice } from './model-choices.js';
 import type { FoldMode } from '../../log-entry.js';
 import { resolveDashboardChatMainLogCommand } from '../input/chat-main-log-command.js';
 import {
@@ -358,7 +361,7 @@ import { debug } from '../../debug/log.js';
 import { resolveDebugCompanionTargets } from '../../window/debug-window-consumers.js';
 import { getPromptBankStore, buildPromptInjection } from '../../prompt-bank/index.js';
 import { inspectActiveProvider } from '../../provider-summary.js';
-import { currentRouteDecision, formatRouteDecisionSummary, resolveRouteDecision, type RouteDecision } from '../../llm/route-decision.js';
+import { currentRouteDecision, formatRouteDecisionSummary, resolveRouteDecision, sessionModelPin, setSessionModelPin, type RouteDecision } from '../../llm/route-decision.js';
 import {
   listSessions as sessionListSessions,
   resolveSessionId as sessionResolveId,
@@ -954,6 +957,8 @@ export interface DashboardSlashContext {
     // Fold mode
     getLogFoldMode(): FoldMode;
     setLogFoldMode(mode: FoldMode): void;
+    /** #19 — put every static fold in one state; returns how many changed. */
+    setAllFolds?(expanded: boolean): number;
     // Solo (chat-only) toggle — flips chatOnlyMode + manages HUD mode segment.
     /** Returns the new chatOnlyMode value after toggle. */
     toggleSolo(): boolean;
@@ -1071,6 +1076,7 @@ export interface DashboardSlashContext {
   termSlash: {
     /** Line formatters (existing factory output type re-used). */
     slashRuntime: DashboardTermSlashRuntime;
+    openNewTerminal(command?: string): void;
 
     /** Terminal session registry (the modal-pty side). */
     sessionRegistry: {
@@ -1413,8 +1419,10 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
     ctx.setChatScrollOffset(-1);
   });
 
-  registry.register(['now'], (args, ctx) => {
-    for (const line of tuiNowSlash(args, nowDeps)) ctx.pushChatLine(line);
+  registry.register(['now'], async (args, ctx) => {
+    const lines = nowDeps ? tuiNowSlash(args, nowDeps)
+      : renderTuiNow(await contextNowInWorker({ topic: args.join(' ').trim() }));
+    for (const line of lines) ctx.pushChatLine(line);
   });
 
   registry.register('loops', async (args, ctx) => {
@@ -2977,6 +2985,10 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
       ctx.setChatScrollOffset(-1);
       return;
     }
+    if (sub === 'new') {
+      ctx.termSlash.openNewTerminal(args.slice(1).join(' ').trim() || undefined);
+      return;
+    }
     if (sub === 'list') {
       const alive = sessionRegistry.list();
       if (alive.length === 0) {
@@ -4019,6 +4031,10 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
     }
 
     if (seSub === 'new' || seSub === 'clear') {
+      // 🪪 L2-lite — 비우기 «전»에 이 대화의 «지난 세션»을 자리 로컬 지시에 남긴다(실패해도 진행).
+      try {
+        recordSeatSessionEnd(seSub === 'new' ? 'session-new' : 'session-clear');
+      } catch { /* 기록이 새 대화를 막지 않는다 */ }
       if (seSub === 'new') {
         try {
           const { suggestProjectForFolder } = await import('../../project/project-store.js');
@@ -4044,6 +4060,12 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
       ctx.chatLines.push(ctx.success(prev
         ? `  ✓ cleared history + detached ${prev.slice(0, 8)}`
         : `  ✓ cleared history`));
+      // 🪪 L1 — 새 대화 = 새 자리 부트 카드.
+      //   ⛔ 정적 import · 동기 호출 — history 를 비운 «같은 틱»에 카드 캐시를 비운다(비동기 대기 틈에 새 턴이 옛 카드를 읽지 않게).
+      try {
+        startSeatBootConversation({ reason: seSub === 'new' ? 'session-new' : 'session-clear' });
+        markSeatConversationStarted();
+      } catch { /* 부트 카드가 새 대화를 막지 않는다 */ }
       ctx.setChatScrollOffset(-1);
       return;
     }
@@ -4474,6 +4496,22 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
       ctx.setChatScrollOffset(-1);
       return;
     }
+    if (logCommand.kind === 'fold-all') {
+      if (!ctx.logSlash.setAllFolds) {
+        // A host without a fold controller cannot know whether anything is folded — say so, not «nothing».
+        debug.log('log.fold', 'slash-set-all', { expanded: logCommand.expanded, changed: null, reason: 'no-fold-controller' });
+        emitReplyToChat(ctx, ctx.warning('  fold controls are not available in this view'));
+        ctx.setChatScrollOffset(-1);
+        return;
+      }
+      const changed = ctx.logSlash.setAllFolds(logCommand.expanded);
+      debug.log('log.fold', 'slash-set-all', { expanded: logCommand.expanded, changed });
+      emitReplyToChat(ctx, ctx.muted(changed > 0
+        ? `  ${logCommand.expanded ? 'unfolded' : 'folded'} ${changed} block${changed === 1 ? '' : 's'}`
+        : `  (nothing to ${logCommand.expanded ? 'unfold' : 'fold'})`));
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
     if (logCommand.kind === 'fold') {
       const action = resolveDashboardLogFoldAction(logCommand.mode, ctx.logSlash.getLogFoldMode());
       if (action.kind === 'set-mode') {
@@ -5302,9 +5340,10 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
     // previews an unpinned request without changing provider/model state.
     if (sub === 'route') {
       const cfg = getUserConfig();
+      const previewPin = sessionModelPin('dashboard', cfg.llm.provider);
       const text = args.slice(1).join(' ').trim();
       const decision = text
-        ? resolveRouteDecision({ provider: cfg.llm.provider, configuredModel: inspectActiveProvider().model, text, routePolicy: cfg.llm.routePolicy })
+        ? resolveRouteDecision({ provider: cfg.llm.provider, configuredModel: inspectActiveProvider().model, text, routePolicy: cfg.llm.routePolicy, ...(previewPin ? { explicitModel: previewPin.model } : {}) })
         : currentRouteDecision('dashboard');
       ctx.chatLines.push(ctx.accent(`❯ /provider route${text ? '' : ' (current)'}`));
       if (!decision) ctx.chatLines.push(ctx.muted('  아직 이 세션에서 실행된 route가 없습니다. `/provider route <요청>`으로 미리보기 합니다.'));
@@ -6062,24 +6101,35 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
     // /model            — 지금 모델(사람 낱말) + 고르기
     // /model 빠름|보통|깊음 — 지금 provider 의 budget·better·best 티어 (model-choices.ts)
     // /model <코드명>    — codex·terra·sol·luna·opus·sonnet·grok (그대로 동작)
+    // /model <x> --global — 설정 파일(전역)에 저장 · /model reset — 세션 핀 해제
+    // ⭐ 기본은 «이 세션» 핀이다(TUI-MODEL-SESSION-SCOPE · 10-14): config 의 llm.model 만 바꾸면 codex 티어 정책이
+    //   그것을 무시해 실제 턴은 그대로 sol 이었다(OPT 21:33). 핀은 다음 턴 explicitModel 로 들어가 정책을 이긴다.
     // effort(low/med/high)는 /reasoning. NL 미지원(대표 OK·slash-only).
-    const arg = (args[0] ?? '').toLowerCase().trim();
+    const { arg, global } = parseModelSlashArgs(args);
     const curCfg = getUserConfig();
     const curProvider = curCfg.llm.provider;
-    const curModel = curCfg.llm.model;
+    const pin = sessionModelPin('dashboard', curProvider);
+    const curModel = pin?.model ?? curCfg.llm.model;
     const curReasoning = effectiveReasoningLevel(curCfg.llm, curProvider, curModel);
     if (!arg) {
       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}) · 고르기: /model ${HUMAN_MODEL_WORDS.join(' | ')}`);
+      ctx.chatLines.push(`지금: ${curModel?.trim() || '기본 모델'} (${tierName} · 생각 ${curReasoning}${pin ? ' · 이 세션 핀' : ''}) · 고르기: /model ${HUMAN_MODEL_WORDS.join(' | ')}`);
       ctx.chatLines.push(ctx.muted(codes));
       ctx.setChatScrollOffset(-1);
       return;
     }
+    if (arg === 'reset') {
+      setSessionModelPin('dashboard', null);
+      debug.log('llm.model-choice', 'session-pin-cleared', { hadPin: pin !== null, configModel: curCfg.llm.model ?? null }, { level: 'info' });
+      ctx.chatLines.push(ctx.muted(`/model reset: 세션 핀 ${pin ? `해제 (${pin.model})` : '없음'} — 다음 턴은 설정·정책대로`));
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
     const resolution = resolveModelChoice(arg, curProvider);
     if (resolution.kind === 'needs-provider') {
-      debug.log('dashboard.model', 'human-word-needs-provider', { word: resolution.word, provider: curProvider });
+      debug.log('llm.model-choice', 'human-word-needs-provider', { word: resolution.word, provider: curProvider });
       ctx.chatLines.push(ctx.muted(`/model ${resolution.word}: provider 가 auto 라 고를 사다리가 없다 — /provider 로 먼저 하나를 고르거나 코드명(${MODEL_CODE_NAMES.join('/')})을 쓴다.`));
       ctx.setChatScrollOffset(-1);
       return;
@@ -6090,29 +6140,51 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
       return;
     }
     const { target } = resolution;
+    const scope = modelSwitchScope(target.provider, curProvider, global);
+    if (scope === 'needs-global') {
+      ctx.chatLines.push(ctx.muted(`/model ${arg}: provider 가 ${curProvider} → ${target.provider} 로 바뀌는 선택은 세션 핀이 안 된다 — /model ${arg} --global 로 설정에 저장한다.`));
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
     // A human word picks a whole tier (model ⊕ reasoning, like /reasoning it clears the codex override);
-    // a code name changes the model only.
+    // a code name changes the model only. Reasoning has no per-turn override, so only --global sets it.
     const tierReasoning = resolution.kind === 'human' ? resolution.reasoningLevel : undefined;
-    saveUserConfig({
-      ...curCfg,
-      llm: {
-        ...curCfg.llm,
-        provider: target.provider,
-        model: target.model,
-        ...(tierReasoning ? { reasoningLevel: tierReasoning, codexReasoning: undefined } : {}),
-      },
-    });
-    reloadUserConfig();
-    if (tierReasoning) ctx.refreshReasoningHudSegment();
-    debug.log('dashboard.model', 'switch', {
+    if (scope === 'global') {
+      saveUserConfig({
+        ...curCfg,
+        llm: {
+          ...curCfg.llm,
+          provider: target.provider,
+          model: target.model,
+          ...(tierReasoning ? { reasoningLevel: tierReasoning, codexReasoning: undefined } : {}),
+        },
+      });
+      reloadUserConfig();
+      if (tierReasoning) ctx.refreshReasoningHudSegment();
+    }
+    // --global 도 이 세션은 핀으로 «즉시» 반영한다 — config 만 쓰면 codex 티어 정책이 configuredModel 을
+    //   무시해 다음 턴에 안 먹는다(1R 리뷰 mf). 다른 세션은 그 세션의 routePolicy 를 따른다.
+    setSessionModelPin('dashboard', { provider: target.provider, model: target.model });
+    // 감사 한 줄 — 종전 범주 `dashboard.model` 은 렌더 접두(`dashboard`)라 기본 음소거돼 로그 스토어에 0회였다
+    //   (src/mss/logging/render-categories.ts). 판정 이벤트는 렌더 밖 범주에 둔다.
+    debug.log('llm.model-choice', 'switch', {
+      scope,
       via: resolution.kind,
       choice: resolution.kind === 'human' ? resolution.tier : resolution.name,
-      from: { provider: curProvider, model: curModel ?? null },
+      from: { provider: curProvider, model: curModel ?? null, pinned: pin !== null },
       to: target,
-      reasoning: tierReasoning ?? null,
-    });
-    ctx.chatLines.push(modelChangeLine({ provider: curProvider, model: curModel, reasoning: curReasoning }, resolution));
-    ctx.chatLines.push(ctx.muted('  └─ 다음 턴부터 반영 · 실행 뱃지(#4442)로 확인'));
+      reasoning: scope === 'global' ? (tierReasoning ?? null) : null,
+      configWritten: scope === 'global',
+    }, { level: 'info' });
+    // 세션 범위는 생각 깊이를 안 바꾼다 — 모델 줄에 티어의 깊이를 «바뀐 값»처럼 쓰지 않고, 남는 깊이를 말한다
+    //   (2R 리뷰 — 한 응답 안의 «생각 medium» 과 «생각 깊이는 그대로 high» 모순).
+    if (scope === 'session' && resolution.kind === 'human') {
+      const { reasoningLevel: _tierReasoning, ...modelOnly } = resolution;
+      ctx.chatLines.push(`${modelChangeLine({ provider: curProvider, model: curModel, reasoning: curReasoning }, modelOnly)} · 생각 ${curReasoning} 그대로`);
+    } else {
+      ctx.chatLines.push(modelChangeLine({ provider: curProvider, model: curModel, reasoning: curReasoning }, resolution));
+    }
+    ctx.chatLines.push(ctx.muted(modelScopeLine(scope, scope === 'session' && tierReasoning ? { tier: tierReasoning, current: curReasoning } : undefined)));
     ctx.setChatScrollOffset(-1);
   });
 

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

@@ -123,3 +123,38 @@ export function modelChangeLine(
   const providerNote = resolution.target.provider === before.provider ? '' : `  · provider ${resolution.target.provider}`;
   return `모델: ${currentLabel(before.provider, before.model, before.reasoning)} → ${after} (${resolution.target.model}${reasoningNote})${providerNote}`;
 }
+
+/** `/model` arguments: the choice word plus the `--global` flag (TUI-MODEL-SESSION-SCOPE · 10-14). */
+export function parseModelSlashArgs(args: readonly string[]): { arg: string; global: boolean } {
+  const global = args.some((a) => a.trim().toLowerCase() === '--global');
+  const arg = args.find((a) => !a.trim().startsWith('--'))?.trim().toLowerCase() ?? '';
+  return { arg, global };
+}
+
+/**
+ * Where a `/model` choice lands. The default is this TUI session only (a pin that the next turn sends as an
+ * explicit model, so it beats the Codex tier policy); `--global` writes config. A choice on another provider
+ * can't be a session pin — the turn carries a model, not a provider — so it needs `--global`.
+ */
+export function modelSwitchScope(
+  targetProvider: LLMProviderName,
+  currentProvider: LLMProviderName,
+  global: boolean,
+): 'session' | 'global' | 'needs-global' {
+  if (global) return 'global';
+  return targetProvider === currentProvider ? 'session' : 'needs-global';
+}
+
+/** The muted line under a switch: what scope it took and when it applies — no promise the code doesn't keep. */
+export function modelScopeLine(
+  scope: 'session' | 'global',
+  reasoning?: { tier: ReasoningLevel; current: ReasoningLevel },
+): string {
+  const where = scope === 'session'
+    ? '  └─ 이 세션만 · 다음 턴부터 · 설정 파일은 그대로 (전역은 /model <이름> --global · 해제 /model reset)'
+    : '  └─ 설정 파일(전역)에 저장 · 이 세션은 다음 턴부터 · 다른 세션은 그 세션의 routePolicy 를 따른다 (codex 기본 정책이면 단계 모델이 이긴다)';
+  const think = reasoning && reasoning.tier !== reasoning.current
+    ? ` · 생각 깊이는 그대로 ${reasoning.current} (이 단계는 ${reasoning.tier} — /reasoning ${reasoning.tier})`
+    : '';
+  return where + think;
+}