deel-local-cli 1.2.0 → 1.4.1

package/src/commands.js

@@ -3,17 +3,26 @@ import { writeFileSync, existsSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { c, say, rule, pad, bar, mark, width, clip } from './ui/ansi.js';
 import { compact } from './agent/compact.js';
+import { 증거모으기, 증거적기 } from './agent/evidence.js';
 import { allowEndpoint } from './safety/network.js';
 import { pick } from './ui/prompt.js';
 import { load, save, resolveKey, upsert } from './config.js';
+import { 종, 알릴만한초 } from './ui/notify.js';
+import { 말, 언어, 언어정하기, 언어고르기, 옮긴만큼 } from './i18n/index.js';
+import { 프로필찾기, 쓸수있나, 연결만들기, 알릴말, 목록보기 } from './agent/models.js';
+import { allowTemporarily } from './safety/network.js';
+import { chat } from './backend/adapter.js';
 import { TOOLS } from './tools/index.js';
+import { 둘러보기, 프로젝트갈래 } from './lsp/servers.js';
+import { 지금것들 } from './lsp/client.js';
+import { 보고서적기 } from './ui/export.js';
 import { loadCommand, discover } from './skills/discover.js';
 import { install, list, remove, pack } from './plugins/manage.js';
 import { spin } from './ui/spinner.js';
 import { PROFILES, LEVELS as THINK_LEVELS, normalizeProfile, table as effortTable } from './agent/effort.js';
 import { scanLocal, toProfiles } from './backend/scan.js';
 import { list as listSessions } from './agent/store.js';
-import { MODES as WORK_MODES, ORDER as WORK_ORDER, DEFAULT as WORK_DEFAULT, normalize as normWork, get as getWork, canWrite } from './agent/modes.js';
+import { MODES as WORK_MODES, ORDER as WORK_ORDER, DEFAULT as WORK_DEFAULT, normalize as normWork, get as getWork, canWrite, 보일이름, 보일한줄 } from './agent/modes.js';
 import { LEVELS, ORDER as LEVEL_ORDER, DEFAULT as LEVEL_DEFAULT, normalize as normLevel, shows as levelShows } from './ui/level.js';
 import { diffLines, renderDiff, shortStat } from './ui/diff.js';
 import { readTextFull } from './tools/fsutil.js';
@@ -24,48 +33,83 @@ const MODES = {
   strict: '엄격 — 파일 변경·명령 전부 물어봄',
 };
 
-export const COMMANDS = {
-  help:    { desc: '명령 목록' },
-  clear:   { desc: '대화 비우기' },
-  context: { desc: '컨텍스트 사용량 보기' },
-  ctx:     { desc: '컨텍스트 길이 — 모델에 맞춰 다시 재거나 직접 지정', arg: '[auto|숫자|640k]' },
-  out:     { desc: '한 번에 받을 답 길이 상한 — 큰 파일이 잘리면 여기를 올린다', arg: '[숫자|32k|auto]' },
-  grade:   { desc: '모델 급 — 얼마나 알아서 하나. 창 크기와는 다른 축', arg: '[작음|보통|큼|auto]' },
-  compact: { desc: '오래된 대화 줄이기' },
-  model:   { desc: '연결·모델 바꾸기 (이름 일부 · list · models)', arg: '[이름|list|models]' },
-  think:   { desc: '추론 강도 (off/low/medium/high/max)', arg: '<수준>' },
-  mode:    { desc: '승인 정책 — 얼마나 물어보나 (auto/confirm/strict)', arg: '<모드>' },
-  work:    { desc: '작업 모드 — 무슨 일을 하는 중인가 (종합이면 저절로)', arg: '[모드]' },
-  // 이름이 /mode auto 와 겹쳐 보이므로 설명에서 못을 박는다.
-  // /mode auto 는 '얼마나 물어보나', /auto 는 '무슨 일을 하는 중인가' 다.
-  auto:    { desc: '작업 모드 → 종합 (요청에 따라 저절로 옮겨 감. /mode 와 다름)' },
-  code:    { desc: '작업 모드 → 코드 (고치고 만든다)' },
-  plan:    { desc: '작업 모드 → 계획 (먼저 계획만)' },
-  architect:{ desc: '작업 모드 → 설계 (구조를 짠다)' },
-  debug:   { desc: '작업 모드 → 디버그 (원인을 찾는다)' },
-  ask:     { desc: '작업 모드 → 묻기 (설명만)' },
-  orchestrator: { desc: '작업 모드 → 총괄 (큰 일을 쪼개서)' },
-  undo:    { desc: '직전 작업 되돌리기', arg: '[턴수]' },
-  diff:    { desc: '이번 대화에서 바뀐 파일 · 바뀐 자리 보기', arg: '[파일]' },
-  preview: { desc: '만든 웹을 이 자리에서 띄워 본다 — 올릴 필요 없음', arg: '[폴더|off]' },
-  tools:   { desc: '쓸 수 있는 도구 보기' },
-  skills:  { desc: '스킬 보기·검색·골라 올리기', arg: '[검색어|all|off]' },
-  plugin:  { desc: '플러그인 목록·설치·삭제·반입묶음', arg: '[install|remove|pack]' },
-  cost:    { desc: '이번 세션 사용량' },
-  status:  { desc: '연결 상태' },
-  scan:    { desc: '이 PC 의 로컬 모델 서버 훑기', arg: '[save]' },
-  thread:  { desc: '대화 갈래 — 곁가지를 딴 자리에서. 연결·되돌리기는 같이 씀', arg: '[new|fork|close|번호|이름]' },
-  learned: { desc: '쓰면서 저절로 알게 된 것 — 되는 명령·이 모델의 버릇', arg: '[지우기]' },
-  sessions:{ desc: '이 폴더의 지난 대화 목록' },
-  recall:  { desc: '지난 대화에서 찾기 — 목록 말고 내용으로', arg: '<찾을 말>' },
-  mcp:     { desc: '밖에서 붙인 도구(MCP) 서버 보기' },
-  memory:  { desc: '대화가 끝나도 남는 기억 — 보기·지우기', arg: '[지우기 <번호>|비우기|<적을 말>]' },
-  level:   { desc: '사용자 수준 (쉬움/개발자)', arg: '[수준]' },
-  init:    { desc: 'DEEL.md 규칙 파일 만들기' },
-  exit:    { desc: '끝내기' },
-  quit:    { desc: '끝내기' },
+/*
+ * 슬래시 명령 목록.
+ *
+ * ── 왜 설명이 여기 없나 ─────────────────────────────────────────────────
+ *
+ * 이름과 인자 유무만 여기 두고, **사람이 읽는 글은 i18n/ko.js 에 있다.**
+ * 명령 이름은 원래부터 영어였는데(help·model·undo…) 그 옆의 설명이 전부
+ * 한글이라, 저장소를 처음 연 영어권 사람은 `/help` 를 쳐 봐도 무엇을 하는
+ * 명령인지 알 수가 없었다. 그래서 설명만 갈아 끼울 수 있게 뺐다.
+ *
+ * desc·arg 를 **게터로** 둔다. 켤 때 한 번 읽어 굳히면 /lang 으로 바꿔도
+ * 목록이 안 따라오고, 그러면 바뀐 것처럼 보이다가 안 바뀐 자리가 남는다.
+ * 볼 때마다 지금 언어로 읽는 편이 어긋날 자리가 없다.
+ *
+ * 없는 열쇠는 열쇠 이름이 그대로 나온다 — 빈칸이 아니다. 명령을 새로 넣고
+ * ko.js 에 적는 것을 빠뜨리면 `cmd.foo.desc` 가 화면에 찍혀서 바로 눈에 띈다.
+ * (검사도 그걸 잡는다.)
+ */
+const 명령들 = {
+  help: { arg: false },
+  clear: { arg: false },
+  context: { arg: false },
+  ctx: { arg: true },
+  out: { arg: true },
+  grade: { arg: true },
+  compact: { arg: false },
+  model: { arg: true },
+  think: { arg: true },
+  mode: { arg: true },
+  work: { arg: true },
+  auto: { arg: false },
+  code: { arg: false },
+  plan: { arg: false },
+  architect: { arg: false },
+  debug: { arg: false },
+  ask: { arg: false },
+  orchestrator: { arg: false },
+  undo: { arg: true },
+  diff: { arg: true },
+  preview: { arg: true },
+  tools: { arg: false },
+  skills: { arg: true },
+  plugin: { arg: true },
+  cost: { arg: false },
+  status: { arg: false },
+  scan: { arg: true },
+  thread: { arg: true },
+  learned: { arg: true },
+  pin: { arg: true },
+  evidence: { arg: true },
+  sessions: { arg: false },
+  recall: { arg: true },
+  mcp: { arg: false },
+  memory: { arg: true },
+  level: { arg: true },
+  bell: { arg: true },
+  consult: { arg: true },
+  lang: { arg: true },
+  lsp: { arg: true },
+  export: { arg: true },
+  init: { arg: false },
+  exit: { arg: false },
+  quit: { arg: false },
 };
 
+/**
+ * 화면에 낼 명령표. desc·arg 는 볼 때마다 지금 언어로 읽는다.
+ *
+ * @type {Record<string, {desc: string, arg?: string}>}
+ */
+export const COMMANDS = Object.fromEntries(Object.entries(명령들).map(([이름, 꼴]) => {
+  const 것 = { get desc() { return 말(`cmd.${이름}.desc`); } };
+  if (꼴.arg) Object.defineProperty(것, 'arg', { get: () => 말(`cmd.${이름}.arg`), enumerable: true });
+  return [이름, 것];
+}));
+
+
 /**
  * 이 줄이 명령이 아니라 '경로' 인가.
  *
@@ -98,6 +142,295 @@ export async function handle(line, session, ctx) {
   switch (name) {
     case 'help': return help(session), { handled: true };
     case 'level': return showLevel(session, arg), { handled: true };
+
+    /*
+     * 종소리 · 창 제목.
+     *
+     * 끄는 길을 굳이 명령으로 둔 이유가 있다. 사무실에서 소리가 나면 곤란한
+     * 사람이 있고, 그런 사람은 알림 자체를 못 쓰게 되는 것이 아니라 **그 자리에서
+     * 껐다 켤 수 있어야** 한다. 환경변수만 두면 프로그램을 껐다 켜야 한다.
+     */
+    /*
+     * 화면 말 — 한국어 / English.
+     *
+     * 코드는 한국어로 둔다. 함수 이름도 변수 이름도 한글이고 그게 이 저장소의
+     * 뜻이다. 바꾸는 것은 **화면에 나가는 말**뿐이다.
+     *
+     * 얼마나 옮겼는지를 숨기지 않고 그대로 적는다. 다 된 척하는 것보다
+     * "298개 중 47개는 아직 한국어" 가 낫다 — 그래야 안 옮긴 자리를 봤을 때
+     * 사람이 고장으로 안 읽고, 도와줄 사람도 어디를 도울지 안다.
+     */
+    /*
+     * 다른 모델에게 한 번 물어보기.
+     *
+     * ── 왜 따로 두나 ────────────────────────────────────────────────────
+     *
+     * 로컬에서는 모델 하나를 골라도 늘 어딘가 아쉽다. 7B 는 계획을 잘 세우는데
+     * 파일 열 개를 고치다 창이 차고, 1.5B 는 창은 넉넉한데 무엇을 할지를 못
+     * 정한다. 그런데 지금까지는 다른 것에게 물어보려면 /model 로 **갈아타야**
+     * 했고, 갈아타면 하던 대화가 그 모델의 것이 된다 — 한마디 물어보자고
+     * 판을 통째로 옮기는 셈이었다.
+     *
+     * ── 무엇을 보내나 ───────────────────────────────────────────────────
+     *
+     * **친 질문만** 보낸다. 지금 대화를 통째로 딸려 보내지 않는다.
+     *
+     * 이건 편의가 아니라 경계선 문제다. 대화에는 이 폴더의 소스가 통째로
+     * 들어 있는데, 그것이 어느 서버로 가는지는 사람이 정할 일이지 명령 하나가
+     * 조용히 정할 일이 아니다. 필요한 배경은 질문에 적으면 된다.
+     *
+     * 답은 화면에 보여 주고 **대화에도 넣는다.** 안 넣으면 사람이 그 답을
+     * 손으로 옮겨 적어야 하는데, 그러면 이건 다른 창에서 물어보는 것과 다를
+     * 것이 없다. 다만 누가 한 말인지 표를 달아 넣는다 — 지금 쓰는 모델이
+     * 제가 한 말로 착각하면 안 된다.
+     */
+    case 'consult': {
+      const 조각 = String(arg ?? '').trim().split(/\s+/);
+      const 이름 = 조각.shift() ?? '';
+      const 질문 = 조각.join(' ').trim();
+      const 목록 = 목록보기();
+
+      if (!이름) {
+        say('');
+        rule(말('consult.title'), 70);
+        if (!목록.length) {
+          say(`  ${c.gray(말('consult.noProfiles'))}`);
+        } else {
+          for (const p of 목록) {
+            const 표 = p.로컬 ? c.hgreen('⌂') : c.hyellow('↗');
+            say(`  ${표} ${c.cyan(pad(p.id, 16))} ${c.white(pad(p.model, 26))} ${c.gray(p.어디)}${p.지금 ? c.gray(` ${말('consult.current')}`) : ''}`);
+          }
+        }
+        say('');
+        say(`  ${c.gray(말('consult.usage'))}`);
+        say(`  ${c.gray(말('consult.questionOnly'))}`);
+        say('');
+        return { handled: true };
+      }
+
+      const 찾음 = 프로필찾기(이름);
+      if (!찾음.ok) {
+        say(`  ${c.gray(찾음.why)}`);
+        if (찾음.후보.length) say(`  ${c.gray(말('consult.candidates'))} ${찾음.후보.map((p) => c.cyan(p.id)).join(c.gray(' · '))}`);
+        else if (목록.length) say(`  ${c.gray(말('consult.have'))} ${목록.map((p) => c.cyan(p.id)).join(c.gray(' · '))}`);
+        say('');
+        return { handled: true };
+      }
+      const 되나 = 쓸수있나(찾음.prof);
+      if (!되나.ok) { say(`  ${c.yellow('!')} ${c.gray(되나.why)}`); say(''); return { handled: true }; }
+      if (!질문) {
+        say(`  ${c.gray(말('consult.needQuestion', { 이름: 찾음.prof.id }))}`);
+        say('');
+        return { handled: true };
+      }
+
+      const 새conn = 연결만들기(찾음.prof);
+      const 알림 = 알릴말(session.conn, 새conn);
+      say('');
+      say(알림.밖으로
+        ? `  ${c.hyellow('↗')} ${c.hyellow(알림.말)} ${c.gray(말('consult.goesOut'))}`
+        : `  ${c.hgreen('⌂')} ${c.gray(알림.말)}`);
+
+      // 그 한 번 동안만 연다. 끝나면 반드시 닫는다.
+      const 닫기 = 알림.다른자리 ? allowTemporarily(새conn.base) : null;
+      const 돌림 = spin(말('consult.asking', { 모델: 새conn.model }));
+      let 답 = null;
+      let 탈 = null;
+      const 잰때 = Date.now();
+      try {
+        const m = await chat(새conn, {
+          messages: [
+            { role: 'system', content: 말('consult.system') },
+            { role: 'user', content: 질문 },
+          ],
+          temperature: 0.3,
+        });
+        답 = String(m?.content ?? '').trim();
+      } catch (err) {
+        탈 = String(err?.message ?? err);
+      } finally {
+        돌림.stop();
+        try { 닫기?.(); } catch { /* 닫다 터져도 이번 대화는 이어간다 */ }
+      }
+
+      if (탈) {
+        say(`  ${c.yellow('!')} ${c.gray(말('consult.failed', { 왜: clip(탈, 120) }))}`);
+        say('');
+        return { handled: true };
+      }
+      if (!답) {
+        say(`  ${c.gray(말('consult.empty'))}`);
+        say('');
+        return { handled: true };
+      }
+
+      const 초 = ((Date.now() - 잰때) / 1000).toFixed(1);
+      say(`  ${c.gray('─'.repeat(2))} ${c.gray(`${찾음.prof.id} · ${초}초`)}`);
+      say('');
+      for (const l of 답.split('\n')) say(`  ${l}`);
+      say('');
+
+      /*
+       * 대화에 넣을 때 **누가 한 말인지 표를 단다.**
+       *
+       * 안 달면 지금 쓰는 모델이 제가 아까 한 말로 읽는다. 작은 모델이 대충
+       * 답한 것을 제 판단으로 삼아 그 위에 쌓으면, 틀린 자리가 어디서 왔는지
+       * 아무도 못 찾는다.
+       */
+      session.push({
+        role: 'user',
+        content: `[${찾음.prof.id} (${새conn.model}) 에게 따로 물어본 결과다. 네가 한 말이 아니다.]\n`
+          + `물음: ${질문}\n답: ${답}`,
+      });
+      ctx.audit.tool('Consult', { 프로필: 찾음.prof.id, 모델: 새conn.model, 질문: clip(질문, 200) },
+        { summary: `${알림.말} · ${답.length}자` });
+      say(`  ${c.gray(말('consult.added'))}`);
+      say('');
+      return { handled: true };
+    }
+
+    case 'lang': {
+      const 값 = String(arg ?? '').trim();
+      const 이름 = (l) => 말(`lang.${l}`);
+      if (!값) {
+        const p = 옮긴만큼();
+        say('');
+        say(`  ${c.gray(말('lang.now', { 이름: 이름(언어()) }))}`);
+        say(`  ${c.gray(말('lang.progress', { 언어: 언어(), 옮김: p.옮김, 전체: p.전체 }))}`);
+        if (p.남음) say(`  ${c.gray(말('lang.partial'))}`);
+        say(`  ${c.gray(말('lang.codeStays'))}`);
+        say(`  ${c.gray(말('lang.howto'))} ${c.cyan('/lang ko')} ${c.gray('·')} ${c.cyan('/lang en')}`);
+        say(`  ${c.gray(말('lang.envHint'))}`);
+        say('');
+        return { handled: true };
+      }
+      if (!언어고르기(값)) {
+        say(`  ${c.gray(말('lang.unknown'))}`);
+        say('');
+        return { handled: true };
+      }
+      언어정하기(값);
+      const cfg = load();
+      cfg.lang = 언어();
+      try { save(cfg); } catch { /* 못 남겨도 이번 세션에는 먹는다 */ }
+      const p = 옮긴만큼();
+      say('');
+      say(`  ${mark.ok} ${말('lang.changed', { 이름: 이름(언어()) })}`);
+      say(`     ${c.gray(말('lang.progress', { 언어: 언어(), 옮김: p.옮김, 전체: p.전체 }))}`);
+      if (p.남음) say(`     ${c.gray(말('lang.partial'))}`);
+      say('');
+      return { handled: true };
+    }
+
+    /*
+     * 언어 서버 — 무엇이 깔려 있고, 지금 무엇이 떠 있나.
+     *
+     * 이 화면이 필요한 이유는 하나다. Def·Refs 는 서버가 없으면 **목록에 아예
+     * 안 나온다.** 그러면 사용자 눈에는 "왜 어떤 프로젝트에서는 되고 어떤
+     * 데서는 안 되지" 로 보인다. 여기서 그 까닭과 깔 방법을 대신 말해 준다.
+     *
+     * 대신 **여기서도 안 깔아 준다.** 깔 명령을 글자로 보여 줄 뿐이고,
+     * 칠지 말지는 사람이 정한다 (lsp/servers.js 머리말).
+     */
+    /*
+     * 대화 → 보고서 한 장 (ui/export.js).
+     *
+     * 폐쇄망에는 세션 공유 링크가 없다. 이 자리의 공유는 파일이다 —
+     * 결재는 첨부로 돌고, 보고는 한 장으로 한다.
+     */
+    case 'export': {
+      const 자리 = 보고서적기(ctx.scope.root, session, { scope: ctx.scope, audit: ctx.audit });
+      say('');
+      if (자리) {
+        say(`  ${mark.ok} ${말('export.saved')} ${c.white(ctx.scope.show(자리))}`);
+        say(`     ${c.gray(말('export.openHint'))}`);
+      } else {
+        say(`  ${c.red('✗')} ${말('export.failed')}`);
+      }
+      say('');
+      return { handled: true };
+    }
+
+    case 'lsp': {
+      const 값 = String(arg ?? '').trim().toLowerCase();
+      if (값 === 'off' || 값 === '끔' || 값 === '꺼') {
+        if (ctx?.lsp) ctx.lsp.켬 = false;
+        say('');
+        say(`  ${mark.ok} ${말('lsp.diagOff')}`);
+        say('');
+        return { handled: true };
+      }
+      if (값 === 'on' || 값 === '켬' || 값 === '켜') {
+        if (ctx?.lsp) ctx.lsp.켬 = true;
+        say('');
+        say(`  ${mark.ok} ${말('lsp.diagOn')}`);
+        say('');
+        return { handled: true };
+      }
+
+      const { 있는것, 없는것 } = 둘러보기();
+      const 뿌리것 = ctx?.scope?.root ? 프로젝트갈래(ctx.scope.root) : null;
+      const 떠있는것 = 지금것들();
+      say('');
+      if (있는것.length) {
+        say(`  ${c.hcyan('◈')} ${c.white(말('lsp.found', { 수: 있는것.length }))}`);
+        for (const it of 있는것) say(`     ${c.hgreen('✓')} ${c.white(it.갈래.padEnd(5))} ${c.gray(it.이름)}`);
+      } else {
+        say(`  ${c.gray(말('lsp.none'))}`);
+      }
+      say('');
+      say(`  ${c.gray(말('lsp.thisFolder'))} ${뿌리것 ? c.hcyan(뿌리것.갈래) + c.gray(` · ${말('lsp.fileCount', { 수: 뿌리것.개수 })}`) : c.gray(말('lsp.noneHere'))}`);
+      say(`  ${c.gray(말('lsp.tools'))} ${session.lsp ? c.hgreen('Def · Refs') : c.gray(말('lsp.toolsHidden'))}`);
+      say(`  ${c.gray(말('lsp.diag'))} ${ctx?.lsp?.켬 === false ? c.gray(말('lsp.stateOff')) : c.hgreen(말('lsp.stateOn'))}`);
+      if (떠있는것.length) {
+        for (const it of 떠있는것) {
+          const 꼴 = it.죽음 ? c.yellow(it.죽음) : (it.준비 ? c.hgreen(말('lsp.ready')) : c.gray(말('lsp.starting')));
+          say(`     ${c.gray('·')} ${c.white(it.이름 ?? it.갈래)} ${꼴}`);
+        }
+      }
+      if (없는것.length && !있는것.length) {
+        say('');
+        say(`  ${c.gray(말('lsp.installHint'))}`);
+        for (const it of 없는것.slice(0, 4)) say(`     ${c.gray(`${it.갈래.padEnd(5)} ${it.깔기}`)}`);
+        say(`  ${c.gray(말('lsp.neverInstalls'))}`);
+      }
+      say(`  ${c.gray(말('lsp.howto'))} ${c.cyan('/lsp on')} ${c.gray('·')} ${c.cyan('/lsp off')}`);
+      say('');
+      return { handled: true };
+    }
+
+    case 'bell': {
+      const cfg = load();
+      const 켜는말 = ['on', '켬', '켜', '켜기', 'y', 'yes', 'ㅇ'];
+      const 끄는말 = ['off', '끔', '꺼', '끄기', 'n', 'no', 'ㄴ'];
+      const 값 = String(arg ?? '').trim().toLowerCase();
+      if (!값) {
+        const 켜져있나 = cfg.bell !== false;
+        const 상태 = 켜져있나 ? c.hgreen(말('bell.stateOn')) : c.gray(말('bell.stateOff'));
+        say('');
+        say(`  ${c.gray(말('bell.now', { 상태 }))}`);
+        say(`  ${c.gray(말('bell.when', { 초: 알릴만한초 }))}`);
+        say(`  ${c.gray(말('bell.title'))}`);
+        say(`  ${c.gray(말('bell.howto'))} ${c.cyan('/bell on')} ${c.gray('·')} ${c.cyan('/bell off')}`);
+        if (!process.stdout.isTTY && !process.stderr.isTTY) say(`  ${c.gray(말('bell.notATty'))}`);
+        say('');
+        return { handled: true };
+      }
+      if (!켜는말.includes(값) && !끄는말.includes(값)) {
+        say(`  ${c.gray(말('bell.needOnOff'))}`);
+        say('');
+        return { handled: true };
+      }
+      cfg.bell = 켜는말.includes(값);
+      try { save(cfg); } catch { /* 못 남겨도 이번 세션에는 먹는다 */ }
+      say('');
+      say(`  ${mark.ok} ${말(cfg.bell ? 'bell.turnedOn' : 'bell.turnedOff')}`);
+      // 켤 때는 한 번 울려 준다. "켰다는데 소리가 나나?" 를 그 자리에서 확인하게.
+      if (cfg.bell) { 종(); say(`     ${c.gray(말('bell.justRang'))}`); }
+      say(`     ${c.gray(말('bell.appliesNow'))}`);
+      say('');
+      return { handled: true };
+    }
     case 'exit':
     case 'quit': return { handled: true, exit: true };
 
@@ -139,7 +472,10 @@ export async function handle(line, session, ctx) {
       return { handled: true };
     }
 
-    case 'model': return await switchModel(session, ctx, arg), { handled: true };
+    case 'model':
+      // `/model 카드` 는 모델을 바꾸는 게 아니라 이 모델을 겪어 본 결과를 본다.
+      if (/^(카드|card)$/i.test(String(arg ?? '').trim())) return 카드명령(session, ctx), { handled: true };
+      return await switchModel(session, ctx, arg), { handled: true };
 
     /*
      * /think — '얼마나 생각하나' 하나만 정한다.
@@ -246,15 +582,52 @@ export async function handle(line, session, ctx) {
       return { handled: true };
     }
 
+    /*
+     * 되돌리기 — 파일과 **대화를 같이** 되감는다.
+     *
+     * 전에는 파일만 되돌렸다. 대화에는 "src/runner.js 를 고쳤습니다" 가 그대로
+     * 남아 있어서, 그다음 턴에 모델은 이미 고쳐 놓은 줄 알고 그 위에 이어
+     * 일했다 — 없는 코드를 고치려 들고, 없는 함수를 부른다. 사람 눈에는 모델이
+     * 헛소리하는 것으로 보이지만, 사실은 우리가 모델에게 거짓말을 남겨 둔 것이다.
+     *
+     * 세 군데를 같이 맞춰야 한 벌이 된다 — 오간 말, 적어 둔 파일(--resume 이
+     * 이어 여는 자리), 그리고 /diff 가 세는 '바뀐 파일'. 하나라도 빠지면
+     * 되돌린 것이 다음 순간 되살아난다.
+     */
     case 'undo': {
       const n = Math.max(1, parseInt(arg, 10) || 1);
       const r = ctx.history.undo(n);
       ctx.audit.undo({ turns: r.turns, files: r.restored.length });
       if (!r.restored.length) {
-        say(`  ${c.gray('되돌릴 것이 없습니다.')}`);
+        say(`  ${c.gray(말('undo.nothing'))}`);
+        say('');
+        return { handled: true };
+      }
+      say(`  ${mark.ok} ${말('undo.done', { turns: r.turns, files: r.restored.length })}`);
+      for (const f of r.restored) say(`    ${c.gray(ctx.scope.show(f.path))}  ${c.gray(f.how)}`);
+
+      // /diff 가 세던 것에서도 뺀다. 되돌린 파일이 '바뀐 파일' 로 남아 있으면
+      // 사람도 되돌아간 줄 모른다.
+      for (const f of r.restored) if (!f.skipped) session.changes.delete(f.path);
+      // 상태줄의 '되돌릴 턴' 도 여기서 줄여 준다. 안 줄이면 방금 되돌린 것을
+      // 아직 되돌릴 수 있는 것처럼 세고 있게 된다.
+      try { session.되돌릴턴 = ctx.history.turns().length; } catch { /* 못 세면 그냥 둔다 */ }
+
+      const 되감음 = session.되감기(r.turnIds ?? []);
+      if (되감음.걷은것) {
+        say(`    ${c.gray(말('undo.alsoTalk', { n: 되감음.걷은것 }))}`);
+        if (되감음.고친것) say(`    ${c.gray(말('undo.repaired', { n: 되감음.고친것 }))}`);
+        try { ctx?.갈래?.현재store?.()?.replace(session.messages, `되돌리기 — ${r.turns}개 턴`); }
+        catch { /* 적어 두지 못해도 이번 대화는 이어진다 */ }
+        if (되감음.사람말) {
+          const 한줄 = 되감음.사람말.replace(/\s+/g, ' ').trim();
+          say(`    ${c.gray(말('undo.saidWas'))} ${c.cyan(한줄.length > 60 ? `${한줄.slice(0, 60)}…` : 한줄)}`);
+        }
       } else {
-        say(`  ${mark.ok} ${r.turns}개 턴, 파일 ${r.restored.length}개를 되돌렸습니다.`);
-        for (const f of r.restored) say(`    ${c.gray(ctx.scope.show(f.path))}  ${c.gray(f.how)}`);
+        // 접기·요약이 그 자리를 이미 가져갔을 때다. 파일은 되돌아갔지만 대화는
+        // 못 걷었다는 것을 숨기지 않는다 — 숨기면 위의 사고가 그대로 난다.
+        say(`    ${c.gray(말('undo.talkKept'))}`);
+        say(`    ${c.gray(말('undo.talkKeptWhy'))}`);
       }
       say('');
       return { handled: true };
@@ -331,7 +704,7 @@ export async function handle(line, session, ctx) {
       session.routed = null;
       const w = getWork(골라진);
       say('');
-      say(`  ${c.hcyan(w.glyph)} ${c.bold(w.name)} ${c.gray('(' + w.en + ')')}  ${c.gray(w.hint)}`);
+      say(`  ${c.hcyan(w.glyph)} ${c.bold(보일이름(w.id))} ${c.gray('(' + w.en + ')')}  ${c.gray(보일한줄(w.id))}`);
       say(`  ${c.gray('도구')}    ${canWrite(골라진) ? c.yellow('읽기 + 파일 바꾸기') : c.green('읽기만 — 파일을 못 바꿉니다')}`);
       say(`  ${c.gray('생각')}    ${c.white(w.think ?? session.think)}${c.gray('·')}${c.magenta(w.effort)}   ${c.gray('최대 ' + w.steps + '걸음')}`);
       if (골라진 === 'auto') {
@@ -538,6 +911,12 @@ export async function handle(line, session, ctx) {
     case 'learned':
     case '배움': return 배움명령(session, ctx, arg), { handled: true };
 
+    case 'pin':
+    case '못박기': return 못박기명령(session, ctx, arg), { handled: true };
+
+    case 'evidence':
+    case '증거': return 증거명령(session, ctx, arg), { handled: true };
+
     case 'sessions': {
       const rows = listSessions(session.root, { limit: 12 });
       rule('이 폴더의 지난 대화', 70);
@@ -857,7 +1236,7 @@ function help(session) {
   const level = session?.level ?? LEVEL_DEFAULT;
   const 쉬움 = !levelShows(level, '__전부__');   // 개발자면 show 가 null 이라 전부 참
   say('');
-  rule(쉬움 ? '명령 (자주 쓰는 것)' : '명령', 70);
+  rule(말(쉬움 ? 'help.titleCommon' : 'help.title'), 70);
   let 감춘수 = 0;
   for (const [n, m] of Object.entries(COMMANDS)) {
     if (n === 'quit') continue;
@@ -867,11 +1246,11 @@ function help(session) {
   say('');
   // 감춘 것은 '못 쓰는 것' 이 아니다. 그 말을 분명히 해 둔다.
   if (감춘수) {
-    say(`  ${c.gray(`이 밖에 ${감춘수}개가 더 있습니다 — 직접 입력하면 그대로 실행됩니다.`)}`);
-    say(`  ${c.gray('전부 보려면')} ${c.cyan('/level 개발자')}`);
+    say(`  ${c.gray(말('help.moreHidden', { n: 감춘수 }))}`);
+    say(`  ${c.gray(말('help.showAll'))} ${c.cyan('/level developer')}`);
     say('');
   }
-  say(`  ${c.gray('그 밖의 입력은 모델에게 보냅니다. 빈 줄에서 Ctrl+C 로 끝냅니다.')}`);
+  say(`  ${c.gray(말('help.restGoesToModel'))}`);
   say('');
 }
 
@@ -1075,6 +1454,190 @@ function 갈래명령(session, ctx, arg = '') {
  * 모델이 왜 그렇게 답했는지 알 수 없게 된다 — 여기서 통째로 볼 수 있어야
  * '자동으로 쌓인다' 가 무섭지 않은 말이 된다. 지우는 길도 같이 둔다.
  */
+/**
+ * 증거 — 「다 됐습니다」 대신 검토할 수 있는 것.
+ *
+ * 화면에서 제일 중요한 것은 맨 아래 '증명 안 된 것' 이다. 바꾼 것을 늘어놓는
+ * 일은 /diff 도 한다. 안 한 것을 말하는 자리는 여기뿐이다.
+ */
+function 증거명령(session, ctx, arg = '') {
+  const e = 증거모으기(session, { audit: ctx?.audit });
+  const 말 = String(arg ?? '').trim();
+  say('');
+  rule('작업 증거', 70);
+
+  if (!e.바꾼것.length && !e.돌린것.length) {
+    say(`  ${c.gray('이번 대화에서 아직 바꾸거나 돌린 것이 없습니다.')}`);
+    say('');
+    return;
+  }
+
+  if (e.바꾼것.length) {
+    say(`  ${c.bold('바꾼 것')} ${c.gray(`— 파일 ${e.셈.파일}개 · +${e.셈.더한줄} / -${e.셈.뺀줄}`)}`);
+    for (const x of e.바꾼것.slice(0, 12)) {
+      const 표 = x.증명 ? c.green('✓') : c.yellow('?');
+      const 뒤 = x.증명 ? c.gray(`← ${x.증명}`) : c.yellow('확인 안 됨');
+      say(`    ${표} ${pad(x.파일, 34)} ${c.gray(`+${x.더한줄} -${x.뺀줄}`)}  ${뒤}`);
+    }
+    if (e.바꾼것.length > 12) say(`    ${c.gray(`… 그 밖에 ${e.바꾼것.length - 12}개`)}`);
+    say('');
+  }
+
+  if (e.돌린것.length) {
+    say(`  ${c.bold('돌린 것')} ${c.gray(`— ${e.셈.돌린것}개${e.셈.실패한것 ? `, 그중 ${e.셈.실패한것}개 실패` : ''}`)}`);
+    for (const x of e.돌린것.slice(-10)) {
+      const 표 = x.됐나 ? c.green('✓') : c.red('✗');
+      say(`    ${표} ${clip(x.무엇 || x.도구, 44)} ${c.gray(clip(x.남긴말 ?? '', 24))}`);
+    }
+    say('');
+  }
+
+  // 여기가 요점이다.
+  if (e.증명안된것.length) {
+    say(`  ${c.yellow('증명 안 된 것')} ${c.gray(`— ${e.증명안된것.length}개`)}`);
+    for (const x of e.증명안된것.slice(0, 8)) {
+      say(`    ${c.yellow('·')} ${c.bold(x.파일)}`);
+      say(`      ${c.gray(x.왜)}`);
+    }
+    say('');
+    say(`  ${c.gray('돌려 볼 것이 있으면 지금 돌리고 다시 보세요.')}`);
+  } else {
+    say(`  ${c.green('증명 안 된 것 없음')} ${c.gray('— 바꾼 것마다 그 뒤에 돌린 확인이 있습니다.')}`);
+  }
+  say('');
+
+  if (/^(파일|file|저장|save)$/i.test(말)) {
+    const 이름 = `${new Date().toISOString().slice(0, 19).replace(/[:T]/g, '')}`;
+    const 자리 = 증거적기(session.root, e, 이름);
+    if (자리) say(`  ${mark.ok} ${c.gray('남겼습니다 —')} ${c.cyan(자리)}`);
+    else say(`  ${c.gray('파일로 못 남겼습니다. 화면 것만 쓰세요.')}`);
+    say('');
+  } else {
+    say(`  ${c.gray('파일로 남기려면')} ${c.cyan('/evidence 파일')}`);
+    say('');
+  }
+}
+
+/**
+ * 모델 카드 — 겪어 본 버릇과, 그 때문에 deel 이 바꾼 것.
+ *
+ * 여기서 중요한 것은 아래쪽 '그래서 바꾼 것' 이다. 위쪽 숫자만 보여 주면
+ * 그냥 통계지만, 무엇이 달라졌는지까지 보여야 사람이 판단할 수 있다 —
+ * "이 모델을 계속 쓸까, 다른 걸 받을까" 가 실제로 묻는 것이다.
+ */
+function 카드명령(session, ctx) {
+  const 장 = ctx?.카드다시?.() ?? ctx?.카드 ?? null;
+  say('');
+  if (!장) {
+    say(`  ${c.gray('이 자리에서는 못 봅니다 — 대화 화면에서만 됩니다.')}`);
+    say('');
+    return;
+  }
+
+  rule('모델 카드', 70);
+  say(`  ${c.bold(장.모델 || '(이름 없음)')}  ${c.gray(`· 같이 걸어 본 걸음 ${장.걸음}`)}`);
+  /*
+   * 미리 아는 모델이면 이름표 한 줄 (agent/preset.js). 겪어서 안 것이 아니라
+   * 공개 문서로 아는 것이라, '겪어 본 버릇' 과 섞이지 않게 따로 선다.
+   */
+  if (장.내장) {
+    const 표지 = 언어() === 'en' ? 'known model' : '아는 모델';
+    say(`  ${c.hcyan('◆')} ${c.bold(장.내장.이름)} ${c.gray(`· ${표지}`)}`);
+    if (장.내장.한줄) say(`    ${c.gray(장.내장.한줄)}`);
+  }
+  say('');
+
+  const 줄 = (이름, v) => {
+    if (!v?.n) return;
+    const 센가 = v.율 >= 0.15;
+    const 표 = 센가 ? c.yellow('●') : c.gray('○');
+    say(`    ${표} ${pad(이름, 18)} ${pad(String(v.n), 5, 'right')} ${c.gray(`(${Math.round(v.율 * 100)}%)`)}`);
+  };
+  say(`  ${c.bold('겪어 본 버릇')}`);
+  줄('인자가 잘림', 장.버릇.잘린인자);
+  줄('빈 답', 장.버릇.빈답);
+  줄('편집이 빗나감', 장.버릇.편집실패);
+  줄('같은 것 되풀이', 장.버릇.되풀이);
+  if (!Object.values(장.버릇).some((v) => v.n)) say(`    ${c.gray('아직 걸린 것이 없습니다.')}`);
+  if (장.보정 && Math.abs(장.보정 - 1) > 0.01) {
+    say(`    ${c.gray(pad('토큰 추정 보정', 18))} ${pad(`×${장.보정.toFixed(2)}`, 5, 'right')}`);
+  }
+  say('');
+
+  say(`  ${c.bold('그래서 바꾼 것')}`);
+  if (장.아직모름) {
+    say(`    ${c.gray('아직 판단하지 않습니다 — 몇 걸음 안 걸어 보고 바꾸면 멀쩡한 모델을 붙들어 맵니다.')}`);
+  } else if (!장.왜.length) {
+    say(`    ${c.gray('바꾼 것 없음. 이 모델은 그대로 두어도 괜찮습니다.')}`);
+  } else {
+    for (const w of 장.왜) say(`    ${c.hcyan('→')} ${w}`);
+  }
+  say('');
+  say(`  ${c.gray('이 카드는 프롬프트에 안 실립니다 — deel 이 제 행동을 바꾸는 것이라 모델에게 말할 필요가 없습니다.')}`);
+  say('');
+}
+
+/**
+ * 못 박기.
+ *
+ * 여기서 하는 일은 화면과 말뿐이다. 들고 있는 것은 agent/pins.js 이고,
+ * 그것이 session 에 붙어 있어서 접기·요약이 닿지 못한다.
+ */
+function 못박기명령(session, ctx, arg = '') {
+  const 못 = session?.못박은것;
+  say('');
+  if (!못) {
+    say(`  ${c.gray('이 자리에서는 못 씁니다 — 대화 화면에서만 됩니다.')}`);
+    say('');
+    return;
+  }
+
+  const 적어두기 = () => { try { ctx?.갈래?.현재store?.()?.못박기목록(못.직렬화()); } catch { /* 못 적어도 대화는 계속된다 */ } };
+  const 말 = String(arg ?? '').trim();
+  const [머리, ...나머지] = 말.split(/\s+/);
+
+  if (/^(지우기|빼기|clear|rm|remove)$/i.test(머리 ?? '')) {
+    const r = 못.지우기(나머지.join(' ') || '전부');
+    if (!r.ok) say(`  ${c.red(r.why)}`);
+    else if (typeof r.뺀것 === 'number') say(`  ${mark.ok} ${c.gray(`못 박아 둔 것 ${r.뺀것}개를 뺐습니다.`)}`);
+    else say(`  ${mark.ok} ${c.gray('뺐습니다 —')} ${r.뺀것}`);
+    적어두기();
+    say('');
+    return;
+  }
+
+  if (말) {
+    const r = 못.더하기(말);
+    if (!r.ok) {
+      say(`  ${c.red(r.why)}`);
+      say('');
+      return;
+    }
+    적어두기();
+    say(`  ${c.hcyan('📌')} ${c.bold(`${r.번호}.`)} ${말}`);
+    say(`  ${c.gray('접거나 요약해도 안 지워집니다. 빼려면')} ${c.cyan(`/pin 지우기 ${r.번호}`)}`);
+    say('');
+    return;
+  }
+
+  const 목록 = 못.목록();
+  rule('못 박은 것', 70);
+  if (!목록.length) {
+    say(`  ${c.gray('아직 없습니다. 대화 내내 지켜야 할 말을 박아 두세요.')}`);
+    say(`  ${c.gray('예:')} ${c.cyan('/pin 운영 DB 는 건드리지 마라')}`);
+    say('');
+    return;
+  }
+  for (const x of 목록) say(`  ${c.hcyan(`${x.번호}.`)} ${x.말}`);
+  say('');
+  const 실린것 = 못.실린것();
+  say(`  ${c.gray(`매 턴 프롬프트에 실립니다 — 지금 ${실린것.개수}개, ${실린것.토큰}토큰.`)}`);
+  if (!실린것.다실렸나) {
+    say(`  ${c.yellow(`자리가 모자라 뒤의 ${목록.length - 실린것.개수}개는 안 실립니다.`)} ${c.gray('짧게 줄이거나 빼세요.')}`);
+  }
+  say('');
+}
+
 function 배움명령(session, ctx, arg = '') {
   const 배움 = ctx?.배움;
   say('');
@@ -1743,8 +2306,9 @@ function showWork(session) {
     const w = WORK_MODES[k];
     const 지금 = k === (normWork(session.work) ?? WORK_DEFAULT);
     const 표 = 지금 ? c.hgreen('●') : c.gray('·');
-    const 이름 = 지금 ? c.bold(c.white(pad(w.name, 8))) : c.gray(pad(w.name, 8));
-    say(`  ${표} ${c.hcyan(w.glyph)} ${이름}${c.gray(pad(w.en, 14))}${c.gray(w.hint)}`);
+    const 보임 = 보일이름(w.id);
+    const 이름 = 지금 ? c.bold(c.white(pad(보임, 8))) : c.gray(pad(보임, 8));
+    say(`  ${표} ${c.hcyan(w.glyph)} ${이름}${c.gray(pad(w.en, 14))}${c.gray(보일한줄(w.id))}`);
     say(`        ${canWrite(k) ? c.gray('파일 바꿈') : c.green('읽기만')}${c.gray('  ·  생각 ' + (w.think ?? '그대로') + '·' + w.effort + '  ·  최대 ' + w.steps + '걸음')}`);
   }
   say('');