elanous 0.2.17 → 0.2.19

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

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

@@ -0,0 +1,125 @@
+// TUI-SLASH-DECIDE-NOW C · 2026-10-07 — `/model` offered only code names (terra·sol·luna…), so a first
+// user had nothing to choose by (F14). Three human words now sit in front: 빠름·보통·깊음 resolve to
+// the CURRENT provider's budget·better·best tiers via `lookupLlmTierSpec` (no hard-coded model ids).
+// The seven code names keep going to the same model and provider as before.
+// A tier is «model ⊕ reasoning level» — on several ladders better and best share a model and differ only
+// in reasoning (codex gpt-6-sol medium/high · opus medium/medium), so a human word also carries the tier's
+// reasoning level; otherwise 보통 and 깊음 would be the same choice. Code names leave reasoning alone.
+import type { LLMProviderName, ReasoningLevel } from '../../user-config.js';
+import { lookupLlmTierSpec } from '../../model-tier/index.js';
+import type { ModelTier } from '../../model-tier/types.js';
+
+export interface ModelTarget {
+  readonly model: string;
+  readonly provider: LLMProviderName;
+}
+
+// 명시 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.
+export const MODEL_TARGETS: Readonly<Record<string, ModelTarget>> = {
+  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' },
+};
+
+export const MODEL_CODE_NAMES: readonly string[] = Object.keys(MODEL_TARGETS);
+
+export interface HumanModelChoice {
+  readonly word: '빠름' | '보통' | '깊음';
+  readonly english: 'fast' | 'normal' | 'deep';
+  readonly tier: ModelTier;
+}
+
+export const HUMAN_MODEL_CHOICES: readonly HumanModelChoice[] = [
+  { word: '빠름', english: 'fast', tier: 'budget' },
+  { word: '보통', english: 'normal', tier: 'better' },
+  { word: '깊음', english: 'deep', tier: 'best' },
+];
+
+export const HUMAN_MODEL_WORDS: readonly string[] = HUMAN_MODEL_CHOICES.map(({ word }) => word);
+
+export type ModelChoiceResolution =
+  | { readonly kind: 'human'; readonly word: HumanModelChoice['word']; readonly tier: ModelTier; readonly target: ModelTarget; readonly reasoningLevel?: ReasoningLevel }
+  | { readonly kind: 'code'; readonly name: string; readonly target: ModelTarget }
+  /** A human word while the provider is `auto` — there is no single ladder to read. */
+  | { readonly kind: 'needs-provider'; readonly word: HumanModelChoice['word'] }
+  | { readonly kind: 'unknown'; readonly arg: string };
+
+/** Resolve a `/model` argument against the provider that is active right now. */
+export function resolveModelChoice(rawArg: string, currentProvider: LLMProviderName): ModelChoiceResolution {
+  const arg = rawArg.trim().toLowerCase();
+  const human = HUMAN_MODEL_CHOICES.find(({ word, english }) => arg === word || arg === english);
+  if (human) {
+    if (currentProvider === 'auto') return { kind: 'needs-provider', word: human.word };
+    const spec = lookupLlmTierSpec(currentProvider, human.tier);
+    return {
+      kind: 'human', word: human.word, tier: human.tier, target: { model: spec.model, provider: currentProvider },
+      ...(spec.reasoningLevel ? { reasoningLevel: spec.reasoningLevel } : {}),
+    };
+  }
+  const target = MODEL_TARGETS[arg];
+  if (target) return { kind: 'code', name: arg, target };
+  return { kind: 'unknown', arg };
+}
+
+/**
+ * The human word for (`model`, `reasoning`) on `provider`: an exact tier match first; without a reasoning
+ * level (or no exact match) only a model that names a single tier counts — an ambiguous model gets no word.
+ */
+export function humanWordForModel(
+  provider: LLMProviderName,
+  model: string | undefined | null,
+  reasoning?: ReasoningLevel,
+): HumanModelChoice['word'] | undefined {
+  if (!model || provider === 'auto') return undefined;
+  const sameModel = HUMAN_MODEL_CHOICES.filter(({ tier }) => lookupLlmTierSpec(provider, tier).model === model);
+  if (reasoning) {
+    const exact = sameModel.find(({ tier }) => {
+      const level = lookupLlmTierSpec(provider, tier).reasoningLevel;
+      return level === undefined || level === reasoning;
+    });
+    if (exact) return exact.word;
+  }
+  return sameModel.length === 1 ? sameModel[0]!.word : undefined;
+}
+
+function currentLabel(provider: LLMProviderName, model: string | undefined | null, reasoning?: ReasoningLevel): string {
+  return humanWordForModel(provider, model, reasoning) ?? (model?.trim() || '기본 모델');
+}
+
+/** `/model` with no argument: the current choice, then how to choose. The second line is muted by the caller. */
+export function modelOverviewLines(
+  provider: LLMProviderName,
+  model: string | undefined | null,
+  reasoning?: ReasoningLevel,
+): [string, string] {
+  const word = humanWordForModel(provider, model, reasoning);
+  const now = word ? `${word} (${model})` : (model?.trim() || '기본 모델');
+  return [
+    `지금: ${now} · 고르기: /model ${HUMAN_MODEL_WORDS.join(' | ')}`,
+    `  코드명도 됨: ${MODEL_CODE_NAMES.join(' · ')}  ·  provider ${provider}  ·  생각 깊이: /reasoning`,
+  ];
+}
+
+/** Confirmation after a switch: «보통 → 깊음 (<model>)». */
+export function modelChangeLine(
+  before: { provider: LLMProviderName; model: string | undefined | null; reasoning?: ReasoningLevel },
+  resolution: Extract<ModelChoiceResolution, { kind: 'human' | 'code' }>,
+): string {
+  const after = resolution.kind === 'human'
+    ? resolution.word
+    : humanWordForModel(resolution.target.provider, resolution.target.model) ?? resolution.name;
+  const reasoningNote = resolution.kind === 'human' && resolution.reasoningLevel ? ` · 생각 ${resolution.reasoningLevel}` : '';
+  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}`;
+}

package/src/discord-self-message.ts

@@ -65,7 +65,9 @@ import { detectCard, runCardFollowup, NotACardError } from './card-followup/core
 import { localOcrText } from './telegram-card-followup.js';
 import type { runGraph } from './graph-runner/runner.js';
 import { readSlashContextNow, renderTelegramNow } from './context-bus/context-now-surfaces.js';
-import type { ContextNowDeps } from './context-bus/context-now.js';
+import { contextNow, type ContextNowDeps } from './context-bus/context-now.js';
+import { createContextFirstGate, renderContextFirst } from './context-bus/context-first.js';
+import { telegramLoopsStatus, type LoopsSources } from './telegram-loops-command.js';
 import { botUnavailableSlashReply, deriveTuiSlashAvailability, type TuiSlashAvailability } from './maturity/tui-slash-availability.js';
 
 const SLASH_FOCUS_TURNS_DEFAULT = 8;
@@ -143,6 +145,9 @@ export interface DiscordSelfMessageDeps {
   log?: (msg: string) => void;
   cardFollowupDeps?: { ocrText?: (path: string) => Promise<string | null>; runGraph?: typeof runGraph; rootDir?: () => string };
   nowDeps?: ContextNowDeps;
+  /** Override the clock for the context-first gate in isolated message-path tests. */
+  contextFirstNow?: () => number;
+  loopsSources?: LoopsSources;
   /** Override the TUI slash projection for isolated message-path tests. */
   tuiSlashAvailability?: readonly TuiSlashAvailability[];
 }
@@ -151,6 +156,15 @@ export interface DiscordSelfMessageDeps {
 export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessageHandler {
   const log = deps.log ?? ((): void => {});
   const cfg = deps.userConfig;
+  const contextFirstGate = createContextFirstGate({ now: deps.contextFirstNow ?? Date.now });
+  const maybeSendContextFirst = async (channelId: string): Promise<void> => {
+    if (!contextFirstGate.take(channelId) || cfg.discord?.contextFirst === false) return;
+    try {
+      await deps.getBot()?.sendMessage(channelId, renderContextFirst(contextNow, deps.nowDeps, renderTelegramNow));
+    } catch (err) {
+      log(`discord context-first failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  };
   // C2+ (2026-07-12 dogfood): 디스코드 첨부는 메시지 단위라 "사진 먼저,
   // !cdx 명령은 다음 메시지" 패턴에서 위임 턴이 빈손이 된다. 채널별로
   // 마지막 첨부를 기억해 두고, 첨부 없는 위임 명령이 2분 내 같은
@@ -359,6 +373,7 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
 
   return async (ctx, streamer) => {
     if (deps.channelScope && ctx.channelId !== deps.channelScope) return undefined;
+    contextFirstGate.note(ctx.channelId);
     // Voice text commands pass the guild gate for the voice adapter's
     // sake — never route them into the LLM turn (legacy behavior).
     if (/^\/voice-(join|leave|status)\b/.test(ctx.text.trim())) return undefined;
@@ -367,6 +382,8 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
       const args = nowCommand[1]?.trim().split(/\s+/).filter(Boolean) ?? [];
       return renderTelegramNow(readSlashContextNow(args, deps.nowDeps));
     }
+    if (/^[/!]loops$/.test(ctx.text.trim())) return telegramLoopsStatus([], deps.loopsSources);
+    if (/^[/!]loops\s+\S/.test(ctx.text.trim())) return telegramLoopsStatus(['extra'], deps.loopsSources);
     if (!ctx.text.trim() && ctx.attachments.length === 1 && ctx.attachments[0]!.contentType?.startsWith('image/')) {
       const photo = ctx.attachments[0]!;
       if (detectCard({ width: photo.width, height: photo.height, ocrText: null }).decision !== 'skip') {
@@ -408,6 +425,8 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
       const unavailable = botUnavailableSlashReply(entry, 'discord');
       if (unavailable) return unavailable;
     }
+    const cmd = parseDiscordAcpCommand(ctx.text);
+    if (!cmd && !/^[!/]/.test(ctx.text.trim())) await maybeSendContextFirst(ctx.channelId);
     log(`◀ ${ctx.userName ?? ctx.userId}: ${ctx.text.slice(0, 80)}${ctx.attachments.length ? ` (+첨부 ${ctx.attachments.length})` : ''}`);
     debug.log('discord.self.turn', 'inbound', { channelId: ctx.channelId, chars: ctx.text.length, attachments: ctx.attachments.length });
     // C2+ — 첨부 기억(사진만 먼저 올리는 패턴 지원). 명령 여부와 무관.
@@ -416,7 +435,6 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
     const delegationKey = delegationChatKey('dc', ctx.channelId);
 
     // 1) Explicit text commands — /cc·/cdx·/gem delegate, /brain exits.
-    const cmd = parseDiscordAcpCommand(ctx.text);
     if (cmd?.kind === 'brain') {
       clearActiveDelegation(delegationKey);
       return '🧠 브레인 모드로 복귀했습니다 (active delegation 해제).';

package/src/discord-slash-wire.ts

@@ -48,6 +48,7 @@ export const ELANOUS_SLASH_COMMANDS: readonly SlashCommandSchema[] = [
   { name: 'now', description: '지금 판·칸·결정·자리·최근 맥락 보기', options: [
     { name: 'topic', description: '좁혀 볼 주제 (선택)', type: 3, required: false },
   ] },
+  { name: 'loops', description: '루프·크론 현황 (늦음·실패 먼저)' },
   { name: 'sessions', description: '바인딩된 세션 목록' },
   { name: 'new', description: '새 세션으로 시작 (이전 대화 보존)' },
   { name: 'attach', description: '이 채널을 다른 세션에 연결', options: [