elanous 0.2.18 → 0.2.20

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);
@@ -1493,15 +1505,16 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps): SlashComm
 
   registry.register(['help', '?'], (_args, ctx) => {
     const { cols, rows } = termSize();
+    // The transient modal paints only height - 2 content rows and does not scroll.
+    // The builder adds columns to fit that budget; only when it still overflows, use the scrollable chat log.
+    const minHeight = Math.min(6, Math.max(3, rows - 2));
+    const modalContentRows = Math.max(minHeight, Math.min(rows - 4, Math.floor(rows * 0.7))) - 2;
     const lines = buildEssentialHelpLines({
       names: registry.names(),
       descriptions: SLASH_COMMANDS,
       width: Math.max(1, Math.floor(cols * 0.7) - 2),
+      maxRows: modalContentRows,
     });
-    // The transient modal paints only height - 2 content rows and does not scroll.
-    // When the catalog outgrows it, use the scrollable chat log instead of hiding keys.
-    const minHeight = Math.min(6, Math.max(3, rows - 2));
-    const modalContentRows = Math.max(minHeight, Math.min(rows - 4, Math.floor(rows * 0.7))) - 2;
     if (ctx.showHelpModal && lines.length <= modalContentRows) {
       ctx.showHelpModal({ title: 'Dashboard help', lines });
     } else {
@@ -2436,7 +2449,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 +6178,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 +6481,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,17 +32,26 @@ 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,
   descriptions,
   width,
   audience = readTuiSlashAudience(),
+  maxRows,
 }: {
   names: readonly string[];
   descriptions: readonly Pick<SlashCommand, 'name' | 'aliases' | 'description'>[];
   width: number;
   audience?: { role: Role; showBeta: boolean };
+  /** The modal's row budget. When the readable layout overflows it, add columns (shorter descriptions)
+   *  before the caller has to fall back to the chat log — TUI-HELP-OVERLAY (0.2.19 tui node «help-closes»). */
+  maxRows?: number;
 }): string[] {
   const registered = new Set(names);
   const entries = descriptions
@@ -61,34 +71,63 @@ export function buildEssentialHelpLines({
   // in each cell. Never trade a missing label for a shorter modal.
   const widestLabel = Math.max(0, ...entries.map(({ label }) => visibleWidth(label)));
   const readableCellWidth = widestLabel + 2 + 28 + 1;
-  const columns = entries.length >= 40 && width >= 100
+  const baseColumns = entries.length >= 40 && width >= 100
     ? Math.max(1, Math.floor(width / (readableCellWidth + 1)))
     : 1;
-  const columnWidth = Math.floor(width / columns);
-  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) =>
+  // Narrowest cell that still shows the whole label and a few description characters.
+  const minCellWidth = widestLabel + 2 + 10 + 1;
+  let lines = layout(baseColumns);
+  for (let columns = baseColumns + 1; maxRows !== undefined && lines.length > maxRows
+    && Math.floor(width / columns) - 1 >= minCellWidth; columns++) {
+    lines = layout(columns);
+  }
+  return lines;
+
+  function layout(columns: number): string[] {
+    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[] = [];
+    const cellWidth = columnWidth - (columns > 1 ? 1 : 0);
+    const cellOf = ({ label, description }: { label: string; description: string }) =>
+      visibleWidth(`${label}  `) > cellWidth ? '' : fitLine(`${label}  ${description}`, cellWidth);
+    const pushRow = (cells: string[]) => 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[] = [];
-  if (entries.length >= 40 && width >= 100) {
-    let keyRow = '';
-    for (const item of keyItems) {
-      if (keyRow && visibleWidth(keyRow) + 2 + visibleWidth(item) > width) {
-        keyLines.push(keyRow);
-        keyRow = '';
+    if (columns > 1) {
+      // TUI-HELP-OVERLAY · 2026-10-07 — in columns the group head is a cell and groups flow on: a head line plus a
+      // half-empty last row per group pushed the catalog past the modal's rows, so /help fell back to the chat log
+      // and Esc no longer closed it (0.2.19 release tui node «help-closes»).
+      const cells: string[] = [];
+      for (const group of HELP_GROUP_ORDER) {
+        const members = entries.filter(({ name }) => helpGroupFor(name) === group);
+        if (members.length === 0) continue;
+        cells.push(fitLine(helpGroupHeading(group), cellWidth), ...members.map(cellOf));
+      }
+      for (let start = 0; start < cells.length; start += columns) pushRow(cells.slice(start, start + columns));
+    } else {
+      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 (const member of members) pushRow([cellOf(member)]);
+      }
+    }
+    const keyItems = ESSENTIAL_KEYS.map(([key, description]) => `${key}  ${description}`);
+    const keyLines: string[] = [];
+    if (entries.length >= 40 && width >= 100) {
+      let keyRow = '';
+      for (const item of keyItems) {
+        if (keyRow && visibleWidth(keyRow) + 2 + visibleWidth(item) > width) {
+          keyLines.push(keyRow);
+          keyRow = '';
+        }
+        keyRow += (keyRow ? '  ' : '') + fitLine(item, width);
       }
-      keyRow += (keyRow ? '  ' : '') + fitLine(item, width);
+      if (keyRow) keyLines.push(keyRow);
+    } else {
+      keyLines.push(...keyItems.map((item) => fitLine(item, width)));
     }
-    if (keyRow) keyLines.push(keyRow);
-  } else {
-    keyLines.push(...keyItems.map((item) => fitLine(item, width)));
+    return [fitLine('Commands', width), ...commandLines, '', fitLine('Keys', width), ...keyLines];
   }
-  return [fitLine('Commands', width), ...commandLines, '', fitLine('Keys', width), ...keyLines];
 }

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;
+}