elanous 0.2.18 → 0.2.19

package/src/core-turn/short-question.ts

@@ -0,0 +1,100 @@
+// B1(UX · 0.2.7) — 짧은 «물음»은 도구 없이 빠른 경로로(첫 글자 ≤2초 · 내부 문서 `EVAL-bot-chat-vs-grok-2026-09-30`).
+// 허용 방식(골 ASK-bot-short-question-fast-path-b1b): 아래가 «모두» 참일 때만 fast — 하나라도 거짓이면 fast 아님(보수 쪽).
+//   ⓐ 한 줄 · 80자 이하 · 첨부 없음 ⓑ 인사이거나 «물음 꼴» ⓒ 요청·작업 표지 · 경로·URL·코드 꼴 · 실시간 낱말이 없다.
+// 거부 목록으로 변형을 다 막을 수는 없다 — 오분류 비용은 «확인해 볼까요?» 한 줄로 막힌다(도구가 안 실릴 뿐 대화는 이어진다).
+// 판정 표본 = src/chat/short-question.test.ts 의 고정 표 20개(⊕ 리뷰가 든 변형).
+
+export interface ShortQuestionContext {
+  hasAttachments?: boolean;
+}
+export interface ShortQuestionVerdict {
+  fast: boolean;
+  reason: string;
+}
+
+const GREETING = /^(?:안녕(?:하세요|하십니까)?|반가워(?:요)?|고마워(?:요)?|감사합니다|하이|hi|hello|hey|thanks|thank you)[!?.~\s]*$/i;
+// «한 줄로» 같은 짧은 꼬리를 떼고 본다.
+const TAIL = /\s*(?:한\s*줄로|짧게|간단히|briefly|in one line)[.!]?\s*$/i;
+const KO_QUESTION_END = /(?:\?|까|니|나요|냐|야|어때|뭐|몇|언제|어디|누구|왜|인가|일까)[?.!~]*$/;
+const EN_QUESTION = /^(?:what|why|how|who|where|when|which|is|are|does|do)\b.*\?$/i;
+const REQUEST_KO = /(?:해\s*줘|해\s*주세요|줘(?:요)?(?=[?.!\s]|$)|주세요|줄래|할래|볼래|줄\s*수\s*있|돌려|실행|고쳐|만들어\s*줘|찾아|검색|확인해|열어|보내|올려|지워|써\s*줘|작성해|요약해|정리해|분석해)/;
+const REQUEST_EN = /\b(?:please|can you|could you|would you|run|test|tests|fix|build|open|search|check|send|create|write|deploy|install|summarize)\b/i;
+const TASK = /(?:작업|파일|폴더|디렉터리|레포|저장소|커밋|브랜치|\bPR\b|코드|스크립트|테스트|빌드|배포|설치|설정|명령어|로그|버그|이슈)/i;
+const PATH_OR_CODE = /(?:https?:\/\/|www\.|[\w.-]+\/[\w./-]+|\.(?:ts|tsx|js|py|md|json|yaml|swift|kt)\b|[`{};=<>])/i;
+const LIVE = /(?:오늘\s*(?:날짜|며칠|무슨\s*요일)|지금\s*몇\s*시|최신|뉴스|속보|주가|시세|환율|날씨|today'?s|latest|news|stock|weather|right now)/i;
+
+export type TuiChatRoute = '조회' | '설정 변경' | '조사' | '상시 일' | '코딩·구현';
+
+export interface TuiChatVerdict {
+  route: TuiChatRoute;
+  reason: string;
+  goalLoop: boolean;
+}
+
+/** Request verbs a quick lookup/settings/research/scheduling turn can carry out without the repository. */
+const QUICK_REQUEST_VERBS = /^(?:보여|알려|확인해|찾아|찾아봐|조사해|검색해|정리해|요약해|바꿔|변경해|전환해|설정해|맞춰|수정해|고쳐|만들어|등록해|예약해|추가해|보내)$/;
+
+/** True when the verb never appears, or each occurrence directly follows an allowed object. */
+function everyVerbTakes(text: string, verb: RegExp, object: RegExp): boolean {
+  for (const match of text.matchAll(verb)) {
+    if (!object.test(text.slice(0, match.index))) return false;
+  }
+  return true;
+}
+
+/** Uncertain or mixed requests retain the full coding goal-loop and tool surface. */
+export function classifyTuiChatIntent(text: string, ctx: ShortQuestionContext = {}): TuiChatVerdict {
+  const q = text.trim();
+  const coding = (reason: string): TuiChatVerdict => ({ route: '코딩·구현', reason, goalLoop: true });
+  if (!q || ctx.hasAttachments) return coding(ctx.hasAttachments ? 'attachment' : 'empty');
+  if (/(?:하니스|구현|코딩|코드|스크립트|버그|소스|리팩터|커밋|패치|테스트|시험\s*돌|빌드|배포|브랜치|서버|파일|레포|저장소|\bPR\b|\b(?:implement|coding|code|script|refactor|commit|patch|tests?|build|deploy|branch|server|file|repo)\b)/i.test(q)) return coding('coding');
+  // Destructive or executing verbs in any form (not only «…줘») are never a quick turn.
+  if (/(?:지워|지우|삭제|제거|옮겨|옮기|돌려|실행|설치|되돌려|롤백|재시작|죽여|\b(?:delete|remove|rm|rename|move|run|install|revert|rollback|drop|kill|restart)\b)/i.test(q)) return coding('write-verb');
+  // A file path or code shape means the request touches the repository, whatever else it asks.
+  if (PATH_OR_CODE.test(q)) return coding('path-or-code');
+  // Allowlist, not denylist: every «…줘» request verb must be one a quick turn can do; anything else
+  // (지워줘 · 돌려줘 · 옮겨줘 …) keeps the coding goal loop.
+  for (const match of q.matchAll(/([가-힣]+?)\s*(?:줘|주세요|줄래|주라)/g)) {
+    if (!QUICK_REQUEST_VERBS.test(match[1]!)) return coding('request-verb');
+  }
+  // Edit and create verbs are coding requests unless every one of them takes a quick object directly
+  // («모델 설정 수정해줘» · «알림 만들어줘» stay quick; «… 그리고 화면 고쳐줘» does not).
+  if (!everyVerbTakes(q, /(?:수정|고쳐|바꿔|변경|전환|교체|\b(?:edit|fix|modify|change|switch|replace)\b)/gi, /(?:모델|설정|config|provider|예약|일정|알림|리마인더|스케줄|reminder|schedule)\s*(?:을|를|로|으로)?\s*$/i)) return coding('edit');
+  if (!everyVerbTakes(q, /(?:만들어|작성|추가해|생성|등록해|\b(?:create|write|make|add)\b)/gi, /(?:알림|일정|예약|리마인더|스케줄|reminder|schedule)\s*(?:을|를)?\s*$/i)) return coding('create');
+
+  const routes: Array<{ route: Exclude<TuiChatRoute, '코딩·구현'>; reason: string; pattern: RegExp }> = [
+    { route: '조회', reason: 'lookup', pattern: /(?:결정\s*카드|결정\s*대기|상태|현황|로그|알림\s*(?:왔|있|보여)|\b(?:status|logs?|pending decisions?)\b)/i },
+    { route: '설정 변경', reason: 'settings', pattern: /(?:(?:모델|설정|config|provider).*(?:바꿔|변경|전환|설정해|맞춰|수정|고쳐|써\s*줘|set|change|switch|edit|fix|modify)|(?:바꿔|변경|전환).*(?:모델|설정|config|provider)|답변.*빠른\s*모델)/i },
+    { route: '조사', reason: 'research', pattern: /(?:조사|검색|찾아\s*봐|뉴스|업계\s*소식|\b(?:research|search|news)\b)/i },
+    { route: '상시 일', reason: 'recurring', pattern: /(?:매일|매주|매달|매\s*아침|[가-힣]+마다|정기적|반복\s*일정|예약|리마인더|\b(?:daily|weekly|every|schedule|remind)\b)/i },
+  ];
+  const matches = routes.filter(({ pattern }) => pattern.test(q));
+  // A recurring job that looks something up or researches it is still a scheduling request.
+  if (matches.some(({ route }) => route === '상시 일')
+    && matches.every(({ route }) => route === '상시 일' || route === '조사' || route === '조회')) {
+    return { route: '상시 일', reason: matches.length > 1 ? 'recurring-research' : 'recurring', goalLoop: false };
+  }
+  if (matches.length !== 1) {
+    if (matches.length) return coding('mixed');
+    const shortQuestion = classifyShortQuestion(q, ctx);
+    return coding(shortQuestion.fast ? `short-${shortQuestion.reason}` : 'ambiguous');
+  }
+  const { route, reason } = matches[0]!;
+  return { route, reason, goalLoop: false };
+}
+
+export function classifyShortQuestion(text: string, ctx: ShortQuestionContext = {}): ShortQuestionVerdict {
+  const q = text.trim();
+  if (!q) return { fast: false, reason: 'empty' };
+  if (ctx.hasAttachments) return { fast: false, reason: 'attachment' };
+  if (/[\r\n\u2028\u2029]/.test(q)) return { fast: false, reason: 'multiline' };
+  if ([...q].length > 80) return { fast: false, reason: 'long' };
+  if (PATH_OR_CODE.test(q)) return { fast: false, reason: 'path-or-code' };
+  if (LIVE.test(q)) return { fast: false, reason: 'live' };
+  if (REQUEST_KO.test(q) || REQUEST_EN.test(q)) return { fast: false, reason: 'request' };
+  if (TASK.test(q)) return { fast: false, reason: 'task' };
+  if (GREETING.test(q)) return { fast: true, reason: 'greeting' };
+  const core = q.replace(TAIL, '').trim();
+  if (KO_QUESTION_END.test(core) || EN_QUESTION.test(core)) return { fast: true, reason: 'question' };
+  return { fast: false, reason: 'not-a-question' };
+}

package/src/dashboard/dashboard-status-lines.ts

@@ -16,25 +16,45 @@ export interface DashboardStatusLinesInput {
   readonly acp: string;
 }
 
+/** Detail block marker — everything from the blank line before it on is shown only with `/status --debug`. */
+export const DASHBOARD_STATUS_DETAIL_HEADING = '자세히';
+
+// F5 (TUI-COMFORT) — «연결: 데몬 모름 안 붙음» read as broken. Say what is true in plain words.
+function connectionLine(address: string | null, connected: boolean): string {
+  if (address) return `연결: 데몬 ${address} ${connected ? '붙음' : '안 붙음'}`;
+  return connected ? '연결: 데몬 붙음' : '연결: 혼자 돎(데몬 없음)';
+}
+
+/**
+ * `/status` default view: the three human lines (⊕ the seats line) only. Internal fields
+ * (`surface`·`acp`·`chatOnly`…) stay behind `/status --debug`. Lines without a detail block pass through.
+ */
+export function dashboardStatusSummaryLines(lines: readonly string[]): string[] {
+  const detail = lines.indexOf(DASHBOARD_STATUS_DETAIL_HEADING);
+  if (detail < 0) return [...lines];
+  const end = detail > 0 && lines[detail - 1] === '' ? detail - 1 : detail;
+  return [...lines.slice(0, end), '  자세히: /status --debug'];
+}
+
 export function buildDashboardStatusLines(input: DashboardStatusLinesInput): string[] {
   const known = (value?: string | null): string => value?.trim() || '모름';
   // A remote URL can contain credentials or query parameters. Neither belongs in /status.
-  let address = '모름';
+  let address: string | null = null;
   if (input.daemonAddress?.trim()) {
     try {
       const url = new URL(input.daemonAddress);
       address = `${url.protocol}//${url.host}`;
     } catch {
-      address = '모름';
+      address = null;
     }
   }
   return [
     `모델: ${known(input.provider)}/${known(input.model)} (${known(input.reasoning)})`,
-    `연결: 데몬 ${address} ${input.daemonConnected ? '붙음' : '안 붙음'}`,
+    connectionLine(address, input.daemonConnected),
     `계정: ${input.accountName?.trim() === 'default' ? '기본' : known(input.accountName)}`,
     ...(input.seatsNow ? [input.seatsNow] : []),
     '',
-    '자세히',
+    DASHBOARD_STATUS_DETAIL_HEADING,
     ...input.sessionSurfaceLines.map(line => `  ${line}`),
     `  view: ${input.view}`,
     `  focus: ${input.focus}`,

package/src/dashboard/index.ts

@@ -1323,7 +1323,7 @@ import {
   AGENT_ACTIVITY_SEGMENT_KEY,
   PULSE_HALF_PERIOD_MS,
 } from '../agent-activity-hud.js';
-import { createEscAbortGate, routeStreamingEscapeKey } from '../esc-abort-gate.js';
+import { DASHBOARD_CLARIFICATION_REQUEST, consumeStreamingTopModalEscape, createEscAbortGate, createHarnessEscHint, routeStreamingEscapeKey } from '../esc-abort-gate.js';
 import { createViEditor, type ViEditorHandle } from '../vi-editor.js';
 import { launchEditor, canLaunchEditor } from '../editor-launcher.js';
 import { createSshPickerModal } from '../ssh/ssh-picker-modal.js';
@@ -6700,6 +6700,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
    * this function is invoked.
    */
   const escAbortToolState = createEscAbortToolState();
+  let clarificationModalId: string | null = null;
 
   const attachChatStreamingKeys = (abortCtrl: AbortController): () => void => {
     const chatLinesStartIndex = chatLines.length;
@@ -6710,24 +6711,31 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     // work is running, pop a confirmation modal before tearing down
     // the stream — the running count is visible in the HUD (T3-B1)
     // so the user can make an informed call.
+    let abortGateModalId: string | null = null;
+    const showHarnessEscHint = createHarnessEscHint((line) => pushChatLine(line));
     const escGate = createEscAbortGate({
       abortCtrl,
       getRunningCount: () => getEscAbortRunningCount(escAbortToolState),
       mountModal: (surface) => {
         attachSurfaceToWorkspace(surface, currentWorkspaceOwnerId());
+        abortGateModalId = surface.id;
         const h = display.pushModal(surface);
-        return () => { try { h.dispose(); } catch { /* ignore */ } };
+        return () => { abortGateModalId = null; try { h.dispose(); } catch { /* ignore */ } };
       },
       getViewport: () => termSize(),
       requestRedraw: () => draw(),
       getTheme: () => currentThemeTokens(),
       getWaitingTargetNames: () => getEscAbortWaitingToolNames(escAbortToolState),
       onAbortPending: ({ targets }) => {
-        pushChatLine(`  ⏳ 중단 요청됨 — ${formatEscAbortWaitingTargets(targets)} 종료를 기다리는 중입니다.`);
+        if (!showHarnessEscHint(targets)) {
+          pushChatLine(`  ⏳ 중단 요청됨 — ${formatEscAbortWaitingTargets(targets)} 종료를 기다리는 중입니다.`);
+        }
         chatScrollOffset = -1;
       },
       onAbortRepeat: ({ repeat, targets }) => {
-        pushChatLine(`  ⏳ ESC 재시도 ${repeat}회 — ${formatEscAbortWaitingTargets(targets)} 종료를 기다리는 중입니다.`);
+        if (!showHarnessEscHint(targets)) {
+          pushChatLine(`  ⏳ ESC 재시도 ${repeat}회 — ${formatEscAbortWaitingTargets(targets)} 종료를 기다리는 중입니다.`);
+        }
         chatScrollOffset = -1;
       },
       // ⭐⭐⭐ 턴을 멈추기 «전»에 살아남을 자식을 백그라운드 라우팅으로 넘긴다(`R4a` · 2026-08-19).
@@ -7183,6 +7191,28 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
           };
           return (await inputCoreRouteInputEventAsync(ev, ctx)) === 'consumed';
         },
+        () => {
+          const modal = topModalSurface({ focusStack: display.modalStack(), surfaceAt: id => display.surface(id) });
+          if (modal?.windowRole === 'companion') return false;
+          const askHandle = approvalModalRouter.currentKind() === 'askUser' ? approvalModalRouter.current() : null;
+          const topModalId = () => topModalSurface({ focusStack: display.modalStack(), surfaceAt: id => display.surface(id) })?.id ?? null;
+          return consumeStreamingTopModalEscape({
+            modal,
+            abortGateModalId,
+            event: toDashboardKeyEvent(key),
+            question: askHandle ? {
+              id: askHandle.surface.id,
+              dispose: (cancelled) => askHandle.dispose(cancelled),
+              isClarification: askHandle.surface.id === clarificationModalId,
+            } : undefined,
+            onClarificationClosed: () => {
+              pushChatLine('되묻기 창을 닫았다 — 답 없이 진행한다');
+              chatScrollOffset = -1;
+            },
+            topModalId,
+            redraw: draw,
+          });
+        },
       );
       if (streamingEscapeConsumed) return;
       if (routeStreamingApprovalModalKey(key)) return;
@@ -17649,11 +17679,26 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             // it via setExitInputLoop, or exit showDashboard via
             // { return: DashboardAction }.
             const dashboardSlashSurfaceUx = resolveDashboardSlashSurfaceUx();
+            const clarificationSurfaceUx = dashboardSlashSurfaceUx ? {
+              question: (request: Parameters<typeof dashboardSlashSurfaceUx.question>[0]) => {
+                const pending = dashboardSlashSurfaceUx.question(request);
+                if ((request as typeof request & { [DASHBOARD_CLARIFICATION_REQUEST]?: boolean })[DASHBOARD_CLARIFICATION_REQUEST]) {
+                  const handle = approvalModalRouter.current();
+                  if (approvalModalRouter.currentKind() === 'askUser' && handle) {
+                    clarificationModalId = handle.surface.id;
+                    void handle.promise.finally(() => {
+                      if (clarificationModalId === handle.surface.id) clarificationModalId = null;
+                    });
+                  }
+                }
+                return pending;
+              },
+            } : undefined;
             const slashCtx: DashboardSlashContext = {
               ad: { run: (args) => dispatchDashboardAdSlash(adSlashRuntime, [...args], () => { draw(); }) },
               chatLines,
               getStatusLines: getDashboardStatusLines,
-              ...(dashboardSlashSurfaceUx ? { surfaceUx: dashboardSlashSurfaceUx } : {}),
+              ...(clarificationSurfaceUx ? { surfaceUx: clarificationSurfaceUx } : {}),
               attachmentRowMap,
               pushDebugLine,
               pushChatLine: (line) => { chatLines.push(line); },

package/src/dashboard/input/slash-executor.ts

@@ -1,5 +1,6 @@
 import type { SlashExecuteRequest, SlashExecuteResult } from '../../skills/tools/dashboard-slash.js';
 import type { PaneFocus } from '../../workspace-types.js';
+import { dashboardStatusSummaryLines } from '../dashboard-status-lines.js';
 
 export interface ImmediateDashboardSlashDeps {
   getStatusLines: () => string[];
@@ -17,12 +18,15 @@ export function executeImmediateDashboardSlash(
   req: SlashExecuteRequest,
   deps: ImmediateDashboardSlashDeps,
 ): SlashExecuteResult | null {
-  if ((req.name === 'status' || req.name === 'st') && req.args.length === 0) {
+  // `/status` = human lines only · `/status --debug` = with the internal detail block (TUI-SLASH-DECIDE-NOW C).
+  if ((req.name === 'status' || req.name === 'st')
+    && (req.args.length === 0 || (req.args.length === 1 && req.args[0] === '--debug'))) {
+    const lines = deps.getStatusLines();
     return {
       ok: true,
       name: req.name,
       args: req.args,
-      logLines: deps.getStatusLines(),
+      logLines: req.args.length === 0 ? dashboardStatusSummaryLines(lines) : lines,
     };
   }
   if ((req.name === 'surface' || req.name === 'surf') && req.args.length >= 1) {

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

@@ -283,6 +283,8 @@ import { runRebindCommand } from '../../input-core/index.js';
 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 type { DecisionLedger } from '../../decisions/decision-ledger.js';
 import { listDesignDirections, parseDeclaredDirection } from '../../design/design-directions.js';
 import {
   dashboardDeltaHelpLines,
@@ -303,8 +305,6 @@ import {
   rotateNextProvider, jumpToRotationEntry, rotationEntryLabel,
   currentRotationIndex,
 } from '../../user-config.js';
-import type { LLMProviderName } from '../../user-config.js';
-import { lookupLlmTierSpec } from '../../model-tier/index.js';
 import { listProviders } from '../../llm.js';
 import { enabledModels, loadCatalog } from '../../intelligence-map/model-catalog.js';
 import { selfOrchestrateRuntime } from '../../self-dev/self-orchestrate-runtime.js';
@@ -343,6 +343,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, modelChangeLine, modelOverviewLines, resolveModelChoice } from './model-choices.js';
 import type { FoldMode } from '../../log-entry.js';
 import { resolveDashboardChatMainLogCommand } from '../input/chat-main-log-command.js';
 import {
@@ -375,6 +376,7 @@ import { dirname as pathDirname, relative } from 'node:path';
 import { readFileSync, writeFileSync } from 'node:fs';
 import type { SurfaceUx } from '../../agent/surface-ux/types.js';
 import type { AskUserQuestionRequest } from '../../ask-user-question/types.js';
+import { DASHBOARD_CLARIFICATION_REQUEST } from '../../esc-abort-gate.js';
 import type { GoalDocumentClarification } from '../../self-implement/goal-author-clarification.js';
 import { renderReplayPreviewLines } from '../replay-preview.js';
 import {
@@ -1295,6 +1297,7 @@ let selfOrchestrateSlashRuntime: SelfOrchestrateSlashRuntime = selfOrchestrateRu
 export async function readDashboardAskClarification(
   clarification: GoalDocumentClarification,
   surfaceUx: Pick<SurfaceUx, 'question'> | undefined,
+  notify?: (line: string) => void,
 ): Promise<string> {
   if (!surfaceUx) return '';
   const request: AskUserQuestionRequest = {
@@ -1309,10 +1312,13 @@ export async function readDashboardAskClarification(
       includeOther: clarification.includeOther,
     }],
   };
+  Object.defineProperty(request, DASHBOARD_CLARIFICATION_REQUEST, { value: true });
   try {
-    const result = await surfaceUx.question(request);
-    if (!result || result.cancelled) return '';
+    const pending = surfaceUx.question(request);
     const id = clarification.questionId;
+    notify?.('하니스가 묻는다 — 창에서 고르거나 Esc 로 답 없이 진행');
+    const result = await pending;
+    if (!result || result.cancelled) return '';
     const answer = result.answers[id];
     const selectedLabel = Array.isArray(answer) ? answer[0] : answer;
     const optionIndex = clarification.options.findIndex((option) => option.label === selectedLabel);
@@ -1393,8 +1399,14 @@ async function fetchLoopsDaemonJson<T>(url: string, headers: Record<string, stri
   }
 }
 
-export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps): SlashCommandRegistry<DashboardSlashContext, DashboardSlashReturn> {
+export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedger?: DecisionLedger): SlashCommandRegistry<DashboardSlashContext, DashboardSlashReturn> {
   const registry = new SlashCommandRegistry<DashboardSlashContext, DashboardSlashReturn>();
+  const decide = createDecideSlashHandler(decideLedger);
+  registry.register(['decide', 'dec'], (args, ctx) => {
+    // showDashboard in src/dashboard/index.ts dispatches into this registry.
+    for (const line of decide(args).split('\n')) ctx.pushChatLine(line);
+    ctx.setChatScrollOffset(-1);
+  });
 
   registry.register(['now'], (args, ctx) => {
     for (const line of tuiNowSlash(args, nowDeps)) ctx.pushChatLine(line);
@@ -2436,7 +2448,11 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps): SlashComm
         print: (line) => { for (const part of line.split('\n')) ctx.chatLines.push(`  ${part}`); },
         log: (event, data, level) => debug.log('dev-pipeline', event, { ...data, surface: 'tui-slash' }, { level }),
         readLine: async () => '',
-        readClarification: (clarification) => readDashboardAskClarification(clarification, ctx.surfaceUx),
+        readClarification: (clarification) => readDashboardAskClarification(clarification, ctx.surfaceUx, (line) => {
+          ctx.pushChatLine(line);
+          ctx.setChatScrollOffset(-1);
+          ctx.draw();
+        }),
         readFile: (file) => readFileSync(file, 'utf8'),
         writeFile: (file, data) => writeFileSync(file, data, 'utf8'),
         cwd: () => process.cwd(),
@@ -6161,46 +6177,57 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps): SlashComm
   });
 
   registry.register(['model', 'm'], (args, ctx) => {
-    // /model            — 현재 모델 + 스위치 가능 목록
-    // /model <alias>    — 아래 curated 목록의 alias
+    // /model            — 지금 모델(사람 낱말) + 고르기
+    // /model 빠름|보통|깊음 — 지금 provider 의 budget·better·best 티어 (model-choices.ts)
+    // /model <코드명>    — codex·terra·sol·luna·opus·sonnet·grok (그대로 동작)
     // effort(low/med/high)는 /reasoning. NL 미지원(대표 OK·slash-only).
-    //
-    // 명시 target 맵(id + provider) — catalog/prefix 추론 대신 확정값. 핵심:
-    // Codex 계열(gpt-5.5/5.6-sol/terra/luna)은 gpt- prefix 라 자동 추론은
-    // 'openai'(Chat Completions)로 오분류하나, 실제론 Responses API 필수라
-    // provider=openai-codex 여야 한다(omni-crawl 2026-07-17 확인). GPT(openai·
-    // Chat Completions)는 노출하지 않는다(대표 지시 — 혼란 방지·codex만).
-    // 비-OpenAI fallback 은 claude(anthropic)·grok.
-    const MODEL_TARGETS: Record<string, { model: string; provider: LLMProviderName }> = {
-      codex:  { model: 'gpt-5.5',        provider: 'openai-codex' },
-      // 🩸 2026-09-23 — GPT-6 에는 terra 가 없다(결정). 별칭은 남기되 codex 사다리 better 칸(sol 한 칸 아래 자리)을 가리킨다.
-      terra:  { model: lookupLlmTierSpec('openai-codex', 'better').model, provider: 'openai-codex' },
-      sol:    { model: lookupLlmTierSpec('openai-codex', 'best').model, provider: 'openai-codex' },
-      luna:   { model: lookupLlmTierSpec('openai-codex', 'budget').model, provider: 'openai-codex' },
-      opus:   { model: 'claude-opus-4-8',   provider: 'anthropic' },
-      sonnet: { model: 'claude-sonnet-5', provider: 'anthropic' },
-      // ⭐ 티어 표를 따른다(옆 luna 와 같은 형태) — 하드코딩이면 표를 바꿔도 «안 따라온다»(2026-08-18 대표 4.6 재편)
-      grok:   { model: lookupLlmTierSpec('grok', 'best').model, provider: 'grok' },
-    };
     const arg = (args[0] ?? '').toLowerCase().trim();
     const curCfg = getUserConfig();
-    const curModel = curCfg.llm.model ?? '(provider default)';
-    const aliases = Object.keys(MODEL_TARGETS);
+    const curProvider = curCfg.llm.provider;
+    const curModel = curCfg.llm.model;
+    const curReasoning = effectiveReasoningLevel(curCfg.llm, curProvider, curModel);
     if (!arg) {
-      ctx.chatLines.push(`model: ${curModel}  ·  provider ${curCfg.llm.provider}`);
-      ctx.chatLines.push(ctx.muted(`  switch: /model <${aliases.join('|')}>  ·  effort: /reasoning`));
+      const [now, codes] = modelOverviewLines(curProvider, curModel, curReasoning);
+      ctx.chatLines.push(now);
+      ctx.chatLines.push(ctx.muted(codes));
       ctx.setChatScrollOffset(-1);
       return;
     }
-    const target = MODEL_TARGETS[arg];
-    if (!target) {
-      ctx.chatLines.push(ctx.muted(`/model: unknown "${arg}". try ${aliases.join('/')}.`));
+    const resolution = resolveModelChoice(arg, curProvider);
+    if (resolution.kind === 'needs-provider') {
+      debug.log('dashboard.model', '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;
     }
-    saveUserConfig({ ...curCfg, llm: { ...curCfg.llm, provider: target.provider, model: target.model } });
+    if (resolution.kind === 'unknown') {
+      ctx.chatLines.push(ctx.muted(`/model: "${arg}" 를 모른다. ${HUMAN_MODEL_WORDS.join(' | ')} 또는 ${MODEL_CODE_NAMES.join('/')}.`));
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    const { target } = resolution;
+    // A human word picks a whole tier (model ⊕ reasoning, like /reasoning it clears the codex override);
+    // a code name changes the model only.
+    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();
-    ctx.chatLines.push(`model: ${curModel} → ${target.model}  (provider ${target.provider})`);
+    if (tierReasoning) ctx.refreshReasoningHudSegment();
+    debug.log('dashboard.model', 'switch', {
+      via: resolution.kind,
+      choice: resolution.kind === 'human' ? resolution.tier : resolution.name,
+      from: { provider: curProvider, model: curModel ?? null },
+      to: target,
+      reasoning: tierReasoning ?? null,
+    });
+    ctx.chatLines.push(modelChangeLine({ provider: curProvider, model: curModel, reasoning: curReasoning }, resolution));
     ctx.chatLines.push(ctx.muted('  └─ 다음 턴부터 반영 · 실행 뱃지(#4442)로 확인'));
     ctx.setChatScrollOffset(-1);
   });
@@ -6453,7 +6480,7 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps): SlashComm
       { getStatusLines: ctx.getStatusLines ?? (() => []) },
     );
     if (!result) {
-      ctx.chatLines.push(ctx.warning('  /status takes no arguments'));
+      ctx.chatLines.push(ctx.warning('  /status 는 인자 없이 · 자세히는 /status --debug'));
       ctx.setChatScrollOffset(-1);
       return;
     }

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

@@ -0,0 +1,60 @@
+import { isIrreversible, renderCardText } from '../../decisions/decision-cards.js';
+import { DecisionLedger, type DecisionEntry } from '../../decisions/decision-ledger.js';
+
+function ageOf(entry: DecisionEntry, now: Date): string {
+  const raised = Date.parse(entry.raisedAt ?? entry.importedAt ?? '');
+  if (!Number.isFinite(raised)) return '나이 미상';
+  const minutes = Math.max(0, Math.floor((now.getTime() - raised) / 60_000));
+  if (minutes < 60) return `${minutes}분 전`;
+  if (minutes < 1440) return `${Math.floor(minutes / 60)}시간 전`;
+  return `${Math.floor(minutes / 1440)}일 전`;
+}
+
+/** One handler per dashboard registry: number-to-id mapping refreshes on list open or a successful answer. */
+export function createDecideSlashHandler(ledger: DecisionLedger = new DecisionLedger(), now: () => Date = () => new Date()) {
+  let snapshot: DecisionEntry[] | undefined;
+  let pendingConfirm: { id: string; key: string } | undefined;
+  const openList = (): string => {
+    pendingConfirm = undefined;
+    snapshot = ledger.list({ status: 'open' });
+    if (!snapshot.length) return '열린 결정 없음';
+    return [...snapshot.map((entry, index) =>
+      `${index + 1}. ${entry.title} [${entry.options.map((option) => option.key).join('/')}] · ${entry.raisedBy.track ?? entry.raisedBy.agent} · ${ageOf(entry, now())}`),
+      '답하기: /decide <번호> <선택지 키>'].join('\n');
+  };
+  return (args: readonly string[]): string => {
+    if (!args.length) return openList();
+
+    const numbers = snapshot?.length ? `1~${snapshot.length}` : '없음 (/decide 로 목록 열기)';
+    const invalidNumber = `쓸 수 있는 번호: ${numbers}`;
+    const index = /^(?:[1-9]\d*)$/.test(args[0] ?? '') ? Number(args[0]) - 1 : -1;
+    const selected = snapshot?.[index];
+    if (!selected || !Number.isSafeInteger(index)) return invalidNumber;
+    const entry = ledger.list({ status: 'open' }).find((card) => card.id === selected.id);
+    if (!entry) return `이미 닫힌 결정입니다 (${args[0]}) — /decide 로 목록을 다시 여세요`;
+    if (args.length === 1) {
+      pendingConfirm = undefined;
+      return renderCardText(entry);
+    }
+
+    const key = args[1];
+    const option = entry.options.find((item) => item.key === key);
+    const keys = entry.options.length ? entry.options.map((item) => item.key).join(', ') : '없음';
+    if (!option || args.length > 3 || (args.length === 3 && args[2] !== '확인')) return `쓸 수 있는 선택지 키: ${keys}`;
+    if (isIrreversible(entry)) {
+      if (args[2] !== '확인' || pendingConfirm?.id !== entry.id || pendingConfirm.key !== key) {
+        pendingConfirm = { id: entry.id, key: option.key };
+        return `${renderCardText(entry, { confirm: option.key })}\n/decide ${args[0]} ${option.key} 확인`;
+      }
+      pendingConfirm = undefined;
+    }
+    let acknowledgement: string;
+    try {
+      const { delivery } = ledger.decideWithDelivery(entry.id, option.key, { kind: 'human' });
+      acknowledgement = `✓ ${entry.title} → ${option.label}${delivery && !delivery.ok ? ` · 런 답 전달 실패: decisions retry-answer ${entry.id}` : ''}`;
+    } catch {
+      return `결정을 기록하지 못했습니다 (${args[0]}) — /decide 로 목록을 다시 여세요`;
+    }
+    return `${acknowledgement}\n${openList()}`;
+  };
+}

package/src/dashboard/slash-runtime/help-from-registry.ts

@@ -2,6 +2,7 @@ import type { SlashCommand } from '../../chat/index.js';
 import { readTuiSlashAudience, slashMaturity, slashVisibleFor } from '../../maturity/tui-slash-maturity.js';
 import type { Role } from '../../maturity/feature-maturity.js';
 import { visibleWidth } from '../../tui.js';
+import { HELP_GROUP_ORDER, helpGroupFor } from './help-groups.js';
 
 const ESSENTIAL_KEYS = [
   ['Enter', 'Send message'],
@@ -31,6 +32,11 @@ function fitLine(text: string, width: number): string {
   return fitted + '…';
 }
 
+/** Head line for one help group (never starts with `/`, so it can't read as a command). */
+export function helpGroupHeading(group: string): string {
+  return `▸ ${group}`;
+}
+
 /** Plain content for the dashboard modal; registration, not the picker, decides which slash names exist. */
 export function buildEssentialHelpLines({
   names,
@@ -65,15 +71,22 @@ export function buildEssentialHelpLines({
     ? Math.max(1, Math.floor(width / (readableCellWidth + 1)))
     : 1;
   const columnWidth = Math.floor(width / columns);
+  // Task order (TUI-SLASH-DECIDE-NOW C): group head line, then that group's commands by name.
+  // Empty groups print no head; unmapped commands land in «그 밖», so none disappears.
   const commandLines: string[] = [];
-  for (let start = 0; start < entries.length; start += columns) {
-    const cells = entries.slice(start, start + columns).map(({ label, description }) => {
-      const cellWidth = columnWidth - (columns > 1 ? 1 : 0);
-      return visibleWidth(`${label}  `) > cellWidth ? '' : fitLine(`${label}  ${description}`, cellWidth);
-    });
-    commandLines.push(cells.map((cell, index) =>
-      index === cells.length - 1 ? cell : cell + ' '.repeat(columnWidth - visibleWidth(cell)),
-    ).join('').trimEnd());
+  for (const group of HELP_GROUP_ORDER) {
+    const members = entries.filter(({ name }) => helpGroupFor(name) === group);
+    if (members.length === 0) continue;
+    commandLines.push(fitLine(helpGroupHeading(group), width));
+    for (let start = 0; start < members.length; start += columns) {
+      const cells = members.slice(start, start + columns).map(({ label, description }) => {
+        const cellWidth = columnWidth - (columns > 1 ? 1 : 0);
+        return visibleWidth(`${label}  `) > cellWidth ? '' : fitLine(`${label}  ${description}`, cellWidth);
+      });
+      commandLines.push(cells.map((cell, index) =>
+        index === cells.length - 1 ? cell : cell + ' '.repeat(columnWidth - visibleWidth(cell)),
+      ).join('').trimEnd());
+    }
   }
   const keyItems = ESSENTIAL_KEYS.map(([key, description]) => `${key}  ${description}`);
   const keyLines: string[] = [];

package/src/dashboard/slash-runtime/help-groups.ts

@@ -0,0 +1,44 @@
+// TUI-SLASH-DECIDE-NOW C · 2026-10-07 — `/help` was one alphabetical block of ~70 commands (F3 · F14:
+// `/model` sat three PgUps deep). Commands are now shown in task order: «시작», then the seven public
+// verbs (내부 문서 `MAP-value-props-to-features` — same words), then «그 밖».
+//
+// The table maps a canonical slash name to its group. A registered command that is not in the table
+// falls into «그 밖» automatically — grouping never hides a command (registration and maturity decide that).
+
+export const HELP_START_GROUP = '시작';
+export const HELP_OTHER_GROUP = '그 밖';
+
+/** The seven public verbs, in the order the public map uses them. */
+export const HELP_VERB_GROUPS = [
+  '지켜보기',
+  '조사하기',
+  '판단하기',
+  '만들기',
+  '실행하기',
+  '확인하기',
+  '기억하기',
+] as const;
+
+/** Render order: start, the seven verbs, then everything else. */
+export const HELP_GROUP_ORDER: readonly string[] = [HELP_START_GROUP, ...HELP_VERB_GROUPS, HELP_OTHER_GROUP];
+
+const GROUP_MEMBERS: Readonly<Record<string, readonly string[]>> = {
+  [HELP_START_GROUP]: ['help', 'status', 'model', 'clear', 'new', 'resume'],
+  지켜보기: ['now', 'loops', 'mission', 'log', 'term', 'surface', 'conv', 'capture', 'telegram', 'remaining', 'debug'],
+  조사하기: ['research', 'prompt', 'context'],
+  판단하기: ['decide', 'plan', 'wish', 'directive'],
+  만들기: ['harness', 'ad', 'export'],
+  실행하기: ['run-skill', 'claude', 'codex', 'gemini', 'acp', 'agent-room', 'showroom', 'relay', 'lane', 'reply', 'handoff', 'inject', 'control', 'qc', 'default'],
+  확인하기: ['delta', 'design', 'rewind'],
+  기억하기: ['memory', 'session', 'fork', 'resume-turn', 'history', 'persona'],
+};
+
+/** Canonical slash name → group. */
+export const HELP_GROUP_BY_NAME: ReadonlyMap<string, string> = new Map(
+  Object.entries(GROUP_MEMBERS).flatMap(([group, names]) => names.map((name) => [name, group] as const)),
+);
+
+/** Group for a canonical slash name; anything unmapped is «그 밖». */
+export function helpGroupFor(name: string): string {
+  return HELP_GROUP_BY_NAME.get(name) ?? HELP_OTHER_GROUP;
+}