deel-local-cli 1.7.0 → 1.10.0

package/src/commands.js

@@ -12,7 +12,8 @@ import { allowEndpoint } from './safety/network.js';
 import { 지금모드, 바깥인가, 나갈수있나 } from './safety/runmode.js';
 import { 주소가리기 } from './safety/secrets.js';
 import { pick, confirm } from './ui/prompt.js';
-import { load, save, resolveKey, upsert, 열쇠보관, configPath } from './config.js';
+import { load, save, 저장시도, resolveKey, upsert, 열쇠보관, configPath } from './config.js';
+import { 지금상태 as 지금열쇠상태 } from './safety/authcmd.js';
 import { 제공자고르기 } from './providers/index.js';
 import { 종, 알릴만한초 } from './ui/notify.js';
 import { 말, 언어, 언어들, 언어정하기, 언어고르기, 옮긴만큼, 지시말, 지시말정하기, 지시말따로정했나 } from './i18n/index.js';
@@ -22,7 +23,7 @@ import { chat, 규격이름 } from './backend/adapter.js';
 import { 알림채움 } from './backend/retry.js';
 import { 프록시고르기, 프록시설정 } from './backend/proxy.js';
 import { 정한셸 } from './tools/shell.js';
-import { TOOLS } from './tools/index.js';
+import { TOOLS, 영어설명 } from './tools/index.js';
 import { 둘러보기, 프로젝트갈래 } from './lsp/servers.js';
 import { 지금것들 } from './lsp/client.js';
 import { 보고서적기 } from './ui/export.js';
@@ -170,6 +171,23 @@ function 경로처럼보이나(line) {
 }
 
 // 반환: { handled, exit? }  handled=false 면 모델에게 보낸다.
+
+/**
+ * 설정을 남기고, 못 남겼으면 화면에 한 줄 (config.js 의 저장시도).
+ *
+ * 여태 아홉 자리가 전부 `try { save(cfg) } catch {}` 였다. 못 남겨도 이번 판에는
+ * 먹으니 대화는 계속되는데, 바로 다음 줄에서 화면은 `✓ 바꿨습니다` 를 찍는다.
+ * 사람은 정해진 줄 알고 창을 닫았다가 다음에 옛 값을 보고, 그때는 무엇 때문인지
+ * 알 길이 없다 — 홈이 읽기 전용인지, 디스크가 찼는지.
+ *
+ * @returns {boolean} 남겼나
+ */
+function 설정남기기(cfg, 옵션 = {}) {
+  const r = 저장시도(cfg, 옵션);
+  if (!r.ok) say(`  ${mark.warn} ${c.yellow(말('common.cfgSaveFailed', { 왜: clip(r.왜, 70) }))}`);
+  return r.ok;
+}
+
 /** /mode 아래에 규칙을 늘어놓는다. 아무것도 안 걸려 있으면 아무 말도 안 한다. */
 function 규칙보이기(규칙들) {
   if (!규칙들) return;
@@ -410,7 +428,7 @@ export async function handle(line, session, ctx) {
       // 「화면 말을 따라간다」 가 아니라 옛 값이 되살아난다.
       if (지시말따로정했나()) cfg.promptLang = 지시말();
       else delete cfg.promptLang;
-      try { save(cfg); } catch { /* 못 남겨도 이번 세션에는 먹는다 */ }
+      설정남기기(cfg);
       const p = 옮긴만큼();
       say('');
       say(`  ${mark.ok} ${말('lang.changed', { 이름: 이름(언어()) })}`);
@@ -541,7 +559,7 @@ export async function handle(line, session, ctx) {
         return { handled: true };
       }
       cfg.bell = 켜는말.includes(값);
-      try { save(cfg); } catch { /* 못 남겨도 이번 세션에는 먹는다 */ }
+      설정남기기(cfg);
       say('');
       say(`  ${mark.ok} ${말(cfg.bell ? 'bell.turnedOn' : 'bell.turnedOff')}`);
       // 켤 때는 한 번 울려 준다. "켰다는데 소리가 나나?" 를 그 자리에서 확인하게.
@@ -605,7 +623,7 @@ export async function handle(line, session, ctx) {
       }
 
       cfg.motion = 고른것.값;
-      try { save(cfg); } catch { /* 못 남겨도 이번 세션에는 먹는다 */ }
+      설정남기기(cfg);
       적용하기(cfg.motion);
 
       say('');
@@ -821,18 +839,32 @@ export async function handle(line, session, ctx) {
     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 });
+      /*
+       * 세는 수는 **진짜로 되돌아간 것**이다.
+       *
+       * 전에는 restored.length 를 그대로 썼다. 그 배열에는 못 되돌린 것과
+       * 손대지 않은 것(바이너리처럼 내용을 못 떠 둔 파일)까지 들어 있어서,
+       * 하나도 못 되돌린 판에도 「파일 2개를 되돌렸습니다」 가 나올 수 있었다.
+       * 감사기록에도 그 부풀린 수가 그대로 남았다.
+       */
+      const 되돌린수 = r.되돌린수 ?? r.restored.length;
+      ctx.audit.undo({ turns: r.turns, files: 되돌린수 });
       if (!r.restored.length) {
         say(`  ${c.gray(말('undo.nothing'))}`);
         say('');
         return { handled: true };
       }
-      say(`  ${mark.ok} ${말('undo.done', { turns: r.turns, files: r.restored.length })}`);
+      say(`  ${mark.ok} ${말('undo.done', { turns: r.turns, files: 되돌린수 })}`);
       for (const f of r.restored) say(`    ${c.gray(ctx.scope.show(f.path))}  ${c.gray(f.how)}`);
+      // 못 되돌린 것이 있으면 그것만 따로 못 박는다. 위 목록에 섞여 있으면 안 읽힌다.
+      if (r.못한것?.length) {
+        say(`  ${mark.warn} ${말('undo.failed', { n: r.못한것.length })}`);
+      }
 
       // /diff 가 세던 것에서도 뺀다. 되돌린 파일이 '바뀐 파일' 로 남아 있으면
-      // 사람도 되돌아간 줄 모른다.
-      for (const f of r.restored) if (!f.skipped) session.changes.delete(f.path);
+      // 사람도 되돌아간 줄 모른다. **되돌아간 것만** 뺀다 — 못 되돌린 파일을
+      // 여기서 빼면 진짜로 바뀌어 있는 파일이 /diff 에서도 사라진다.
+      for (const f of r.restored) if (f.ok === true) session.changes.delete(f.path);
       // 상태줄의 '되돌릴 턴' 도 여기서 줄여 준다. 안 줄이면 방금 되돌린 것을
       // 아직 되돌릴 수 있는 것처럼 세고 있게 된다.
       try { session.되돌릴턴 = ctx.history.turns().length; } catch { /* 못 세면 그냥 둔다 */ }
@@ -863,9 +895,20 @@ export async function handle(line, session, ctx) {
     case 'serve': return await 미리보기(session, ctx, arg), { handled: true };
 
     case 'tools': {
-      rule('도구', 70);
+      rule(말('scr.tools'), 70);
+      /*
+       * 원본 schema.description 을 그대로 찍으면 안 된다.
+       *
+       * 그 글은 한국어다. 영어 표(tools/desc.en.js)는 **모델에게 줄 때만**
+       * 갈아 끼우고 있어서, 영어로 켠 사람의 `/tools` 는 스물한 줄이 통째로
+       * 한국어로 나왔다. `/lang` 은 그 사이에도 100% 라고 답했다 — 이 글들은
+       * 애초에 말 표에 들어간 적이 없어서 셈에 안 잡혔기 때문이다.
+       *
+       * 여기서는 **화면 말**(언어())로 고른다. 모델에게 주는 글의 말과는
+       * 다른 축이다 — 영어로 시키고 한국어로 보는 조합이 실제로 쓰인다.
+       */
       for (const [n, t] of Object.entries(TOOLS)) {
-        say(`  ${c.cyan(pad(n, 8))} ${c.gray(t.schema.description)}`);
+        say(`  ${c.cyan(pad(n, 8))} ${c.gray(영어설명(t.schema, n, 언어()).description)}`);
       }
       say('');
       return { handled: true };
@@ -873,14 +916,14 @@ export async function handle(line, session, ctx) {
 
     case 'cost': {
       const mins = ((Date.now() - session.startedAt) / 60000).toFixed(1);
-      rule('이번 세션', 70);
-      say(`  ${c.gray(pad('모델 호출', 14))} ${session.usage.calls}회`);
-      say(`  ${c.gray(pad('입력 토큰', 14))} ${session.usage.in.toLocaleString()}`);
-      say(`  ${c.gray(pad('출력 토큰', 14))} ${session.usage.out.toLocaleString()}`);
-      say(`  ${c.gray(pad('도구 시간', 14))} ${(session.usage.ms / 1000).toFixed(1)}초`);
+      rule(말('scr.session'), 70);
+      say(`  ${c.gray(pad(말('cost.calls'), 14))} ${말('unit.calls', { n: session.usage.calls })}`);
+      say(`  ${c.gray(pad(말('cost.tokIn'), 14))} ${session.usage.in.toLocaleString()}`);
+      say(`  ${c.gray(pad(말('cost.tokOut'), 14))} ${session.usage.out.toLocaleString()}`);
+      say(`  ${c.gray(pad(말('cost.toolMs'), 14))} ${말('unit.sec', { n: (session.usage.ms / 1000).toFixed(1) })}`);
       // 서버가 잠깐 막아 다시 부른 횟수. 0 이면 안 적는다 — 없는 일을 줄로 남기면 표만 길어진다.
-      if (session.usage.retries) say(`  ${c.gray(pad(말('cost.retries'), 14))} ${session.usage.retries}회`);
-      say(`  ${c.gray(pad('경과', 14))} ${mins}분`);
+      if (session.usage.retries) say(`  ${c.gray(pad(말('cost.retries'), 14))} ${말('unit.calls', { n: session.usage.retries })}`);
+      say(`  ${c.gray(pad(말('cost.elapsed'), 14))} ${말('unit.min', { n: mins })}`);
       /*
        * 돈.
        *
@@ -897,7 +940,7 @@ export async function handle(line, session, ctx) {
       const 요금값 = 세션요금(session);
       const 쓴돈 = 돈셈(session.usage, 요금값);
       if (쓴돈) {
-        say(`  ${c.gray(pad('요금', 14))} ${c.bold(돈말(쓴돈.달러))}`
+        say(`  ${c.gray(pad(말('cost.money'), 14))} ${c.bold(돈말(쓴돈.달러))}`
           + ` ${c.gray(`(${어디서온값(요금값)})`)}`);
       } else if (바깥인가(session.conn.base) && (session.usage.in || session.usage.out)) {
         const 붙은곳 = session.제공자 ? 제공자고르기(session.제공자) : null;
@@ -917,8 +960,8 @@ export async function handle(line, session, ctx) {
       const 남은것 = 마지막할당량();
       if (남은것) {
         const 말줄 = 할당량말(남은것);
-        say(`  ${c.gray(pad('서버 할당량', 14))} ${아슬아슬한가(남은것) ? c.yellow(말줄) : 말줄}`
-          + ` ${c.gray(`(${Math.round((Date.now() - 남은것.때) / 1000)}초 전 응답 기준)`)}`);
+        say(`  ${c.gray(pad(말('cost.quota'), 14))} ${아슬아슬한가(남은것) ? c.yellow(말줄) : 말줄}`
+          + ` ${c.gray(`(${말('cost.quotaAge', { 초: Math.round((Date.now() - 남은것.때) / 1000) })})`)}`);
       }
       say('');
       return { handled: true };
@@ -926,29 +969,53 @@ export async function handle(line, session, ctx) {
 
     case 'status': {
       const k = session.conn;
-      rule('연결', 70);
-      say(`  ${c.gray(pad('규격', 10))} ${규격이름(k.kind)}`);
-      say(`  ${c.gray(pad('주소', 10))} ${k.base}`);
+      rule(말('scr.conn'), 70);
+      say(`  ${c.gray(pad(말('status.kind'), 10))} ${규격이름(k.kind)}`);
+      say(`  ${c.gray(pad(말('status.url'), 10))} ${k.base}`);
       // 프록시를 거치면 어느 것을, 어디서 읽었는지(env · config)까지. 안 거치면 줄 자체가 없다.
       // 적어 놨는데 못 쓰는 것(socks5 등)이면 그 까닭을 — 조용히 직접 가면 사람은 프록시를 탄 줄 안다.
       const 프록시 = 프록시고르기(k.base);
-      if (프록시) say(`  ${c.gray(pad('프록시', 10))} ${프록시.url} ${c.gray(`(${프록시.출처})`)}`);
-      else if (프록시설정().탈) say(`  ${c.gray(pad('프록시', 10))} ${c.yellow('못 씀')} ${c.gray(`— ${프록시설정().탈}`)}`);
-      say(`  ${c.gray(pad('모델', 10))} ${k.model}`);
-      say(`  ${c.gray(pad('작업 폴더', 10))} ${session.root}`);
+      if (프록시) say(`  ${c.gray(pad(말('status.proxy'), 10))} ${프록시.url} ${c.gray(`(${프록시.출처})`)}`);
+      else if (프록시설정().탈) say(`  ${c.gray(pad(말('status.proxy'), 10))} ${c.yellow(말('status.proxyOff'))} ${c.gray(`— ${프록시설정().탈}`)}`);
+      say(`  ${c.gray(pad(말('status.model'), 10))} ${k.model}`);
+      say(`  ${c.gray(pad(말('status.root'), 10))} ${session.root}`);
       // 명령이 어느 셸에서 도는지. "ls 가 왜 안 되지" 의 답이 이 줄에 있다.
-      say(`  ${c.gray(pad('셸', 10))} ${정한셸().표시}`);
+      say(`  ${c.gray(pad(말('status.shell'), 10))} ${정한셸().표시}`);
       // 열쇠를 어디에 두고 있나. 사내 심사에서 제일 먼저 묻는 것이라
       // 「어딘가 잠겨 있겠지」 로 두지 않고 지금 상태를 그대로 적는다.
-      if (k.auth !== 'none') say(`  ${c.gray(pad('열쇠 보관', 10))} ${열쇠보관(load())}`);
-      say(`  ${c.gray(pad('규칙', 10))} ${session.rules ? session.rules.name : '없음 (/init 으로 만들 수 있습니다)'}`);
+      /*
+       * 열쇠를 어디에 두고 있나 — 또는 **어디서 받아 오나.**
+       *
+       * 받아 오는 연결에서는 「보관」 을 적으면 거짓말이 된다. 우리는 그
+       * 열쇠를 갖고 있지 않다. 사내 심사에서 제일 먼저 묻는 자리라
+       * 있는 그대로 적는다 (safety/authcmd.js).
+       */
+      if (session.conn.열쇠받기) {
+        const 상태 = 지금열쇠상태();
+        const 남은말 = 상태
+          ? 말('auth.leftMin', { 분: Math.round(상태.남은초 / 60) })
+          : 말('auth.notYet');
+        say(`  ${c.gray(pad(말('status.keyStore'), 10))} `
+          + `${말(session.conn.열쇠받기.곳 === '정책' ? 'auth.fromPolicy' : 'auth.from')} ${c.gray(`· ${남은말}`)}`);
+        say(`  ${c.gray(pad('', 10))} ${c.gray(clip(session.conn.열쇠받기.명령, 56))}`);
+      } else if (k.auth !== 'none') {
+        say(`  ${c.gray(pad(말('status.keyStore'), 10))} ${열쇠보관(load())}`);
+      }
+      say(`  ${c.gray(pad(말('status.rules'), 10))} ${session.rules ? session.rules.name : 말('status.noRules')}`);
+      // 파일이 있는데 못 읽은 것을 '없음' 으로 적으면, 규칙을 적어 둔 사람은
+      // 걸려 있다고 믿는다. 안 걸린 채로 도는 것이 여기서 제일 나쁜 모양이다.
+      if (session.규칙못읽음) {
+        say(`  ${c.gray(pad('', 10))} ${mark.warn} ${c.yellow(말('status.rulesUnread', {
+          이름: session.규칙못읽음.이름, 까닭: session.규칙못읽음.까닭,
+        }))}`);
+      }
       const caps = [
-        k.tools ? c.green('도구') : c.red('도구'),
-        k.streaming ? c.green('스트림') : c.gray('스트림'),
-        k.json ? c.green('스키마') : c.gray('스키마'),
-        k.think ? c.green('추론') : c.gray('추론'),
+        k.tools ? c.green(말('status.capTools')) : c.red(말('status.capTools')),
+        k.streaming ? c.green(말('status.capStream')) : c.gray(말('status.capStream')),
+        k.json ? c.green(말('status.capSchema')) : c.gray(말('status.capSchema')),
+        k.think ? c.green(말('status.capThink')) : c.gray(말('status.capThink')),
       ].join(c.gray(' · '));
-      say(`  ${c.gray(pad('지원', 10))} ${caps}`);
+      say(`  ${c.gray(pad(말('status.caps'), 10))} ${caps}`);
       say('');
       return { handled: true };
     }
@@ -1176,6 +1243,10 @@ export async function handle(line, session, ctx) {
       say(`  ${c.gray('모델에게는')} ${c.white('mcp__<서버>__<도구>')} ${c.gray('라는 이름으로 보입니다.')}`);
       say(`  ${c.yellow('※')} ${c.gray('이 도구들은 남의 프로그램이 돌립니다 —')} ${c.white('작업 범위(' + session.root + ') 를 안 지킵니다.')}`);
       say(`  ${c.gray('  무엇을 불렀는지는')} ${c.white('.deel/audit.jsonl')} ${c.gray('에 남습니다.')}`);
+      // 바로 위 줄이 약속이다. 못 지키고 있으면 여기서 말해야 한다.
+      if (ctx?.audit?.못쓴것?.()) {
+        say(`  ${mark.warn} ${c.yellow('지금 그 파일에 못 적고 있습니다')} ${c.gray('— /증거 에서 까닭을 보세요.')}`);
+      }
       say('');
       return { handled: true };
     }
@@ -1225,7 +1296,19 @@ export async function handle(line, session, ctx) {
       }
       say('');
       say(`  ${c.gray('이어하려면 나갔다가')} ${c.cyan('deel --continue')} ${c.gray('또는')} ${c.cyan(`deel --resume ${rows[0].id}`)}`);
-      say(`  ${c.gray('지금 대화는 나가지 않아도 계속 저장되고 있습니다.')}`);
+      /*
+       * 바로 아래 줄이 약속이다. 못 지키고 있으면 약속을 되풀이하면 안 된다.
+       *
+       * /mcp 화면에서 감사기록을 두고 한 것과 같은 자리다 — 「남습니다」 라고
+       * 적어 놓고 실제로는 안 남는 것이 제일 나쁘다. 이 화면은 이어하기를
+       * 보러 온 화면이라, 여기서 안 말하면 사람이 알 자리가 없다.
+       */
+      const 저장샘 = ctx?.갈래?.현재store?.()?.못쓴것?.();
+      if (저장샘) {
+        say(`  ${mark.warn} ${c.yellow(말('store.notSaving', { n: 저장샘.수, 까닭: 저장샘.까닭 }))}`);
+      } else {
+        say(`  ${c.gray('지금 대화는 나가지 않아도 계속 저장되고 있습니다.')}`);
+      }
       say('');
       return { handled: true };
     }
@@ -1630,13 +1713,26 @@ function showThink(session, { 자세히 = false } = {}) {
   const 개발자 = session.level === '개발자';
   const 단계 = t.rows.map((r) => `${r.label} ${r.level}`).join(c.gray(' · '));
 
+  /*
+   * 이 화면은 여태 통째로 한국어였다.
+   *
+   * `/lang en` 으로 켠 사람에게 「추론 강도 medium (첫 판단 medium · …)」 이
+   * 뜨면 아무것도 안 읽힌다. 명령 이름만 영어고 화면이 한국어인 자리는
+   * 「덜 옮겨졌다」 가 아니라 「고장 났다」 로 읽힌다 — i18n/index.js 머리말.
+   *
+   * 예로 드는 명령도 말을 따라간다. `/think 배분 절약` 은 영어로 켠 사람이
+   * 칠 수 없는 글자다. 두 이름 다 진짜로 받는다(위 배분말·자세히 갈래).
+   */
+  const 한국어 = 언어() === 'ko';
+  const 배분예 = 한국어 ? '/think 배분 절약' : '/think profile save';
+  const 자세히예 = 한국어 ? '/think 자세히' : '/think detail';
   say('');
-  say(`  ${c.gray('추론 강도')}  ${c.bold(session.think)}   ${c.gray(`(${단계})`)}`);
-  if (개발자 || 자세히) say(`  ${c.gray('배분')}      ${c.bold(t.name)}   ${c.gray(t.desc)}`);
+  say(`  ${c.gray(말('think.effort'))}  ${c.bold(session.think)}   ${c.gray(`(${단계})`)}`);
+  if (개발자 || 자세히) say(`  ${c.gray(pad(말('think.profile'), 한국어 ? 8 : 10))}${c.bold(t.name)}   ${c.gray(t.desc)}`);
 
   if (자세히) {
     say('');
-    say(`  ${c.gray(pad('단계', 12) + pad('강도', 10) + pad('출력상한', 10) + '언제')}`);
+    say(`  ${c.gray(pad(말('think.col.stage'), 12) + pad(말('think.col.level'), 10) + pad(말('think.col.cap'), 10) + 말('think.col.when'))}`);
     for (const r of t.rows) {
       const 화살 = r.moved > 0 ? c.yellow('↑') : r.moved < 0 ? c.cyan('↓') : c.gray('·');
       say(`  ${pad(r.label, 12)}${화살} ${pad(r.level, 8)}${pad(r.cap.toLocaleString(), 10, 'right')}  ${c.gray(r.why)}`);
@@ -1644,21 +1740,21 @@ function showThink(session, { 자세히 = false } = {}) {
     say('');
     // 상한이 어디서 왔는지 밝힌다. 세 줄이 같은 값일 때 그게 고장인지 아닌지
     // 이 한 줄로 갈린다 — 아는 상한이 낮으면 셋이 같아지는 것이 맞다.
-    say(`  ${c.gray('출력 상한은')} ${c.white((아는상한 ?? 16384).toLocaleString())} ${c.gray(
-      session.conn.maxTokens ? '(직접 정하신 값)' : session.conn.maxOut ? '(서버에서 알아낸 값)' : '(모르는 값이라 기본값)',
-    )}${c.gray(' 안에서 나눕니다 —')} ${c.cyan('/out')}`);
-    say(`  ${c.gray('컨텍스트')} ${c.white(t.ctx.toLocaleString())}${c.gray(' · 지금 찬 양 ')}${c.white(t.used.toLocaleString())}`);
+    const 어디서 = session.conn.maxTokens ? 말('think.cap.you')
+      : session.conn.maxOut ? 말('think.cap.server') : 말('think.cap.guess');
+    say(`  ${c.gray(말('think.cap.head'))} ${c.white((아는상한 ?? 16384).toLocaleString())} ${c.gray(어디서)}${c.gray(말('think.cap.tail'))} ${c.cyan('/out')}`);
+    say(`  ${c.gray(말('think.ctx'))} ${c.white(t.ctx.toLocaleString())}${c.gray(말('think.ctx.used'))}${c.white(t.used.toLocaleString())}`);
     say('');
-    say(`  ${c.gray('강도')}  ${THINK_LEVELS.join(' · ')}   ${c.gray('예')} ${c.cyan('/think high')}`);
-    say(`  ${c.gray('배분')}  ${Object.entries(PROFILES).map(([k, v]) => `${k}(${v.name})`).join(' · ')}   ${c.gray('예')} ${c.cyan('/think 배분 절약')}`);
+    say(`  ${c.gray(말('think.effort'))}  ${THINK_LEVELS.join(' · ')}   ${c.gray(말('think.eg'))} ${c.cyan('/think high')}`);
+    say(`  ${c.gray(말('think.profile'))}  ${Object.entries(PROFILES).map(([k, v]) => { const n = 한국어 ? v.name : (v.en ?? v.name); return n === k ? k : `${k}(${n})`; }).join(' · ')}   ${c.gray(말('think.eg'))} ${c.cyan(배분예)}`);
   } else if (개발자) {
-    say(`  ${c.gray('강도')} ${c.cyan('/think high')}   ${c.gray('배분')} ${c.cyan('/think 배분 절약')}   ${c.gray('자세히')} ${c.cyan('/think 자세히')}`);
+    say(`  ${c.gray(말('think.effort'))} ${c.cyan('/think high')}   ${c.gray(말('think.profile'))} ${c.cyan(배분예)}   ${c.gray(말('think.detail'))} ${c.cyan(자세히예)}`);
   } else {
-    say(`  ${c.gray('더 세게')} ${c.cyan('/think high')}   ${c.gray('더 빠르게')} ${c.cyan('/think low')}`);
+    say(`  ${c.gray(말('think.harder'))} ${c.cyan('/think high')}   ${c.gray(말('think.faster'))} ${c.cyan('/think low')}`);
   }
 
   if (!session.conn.think && session.think !== 'off') {
-    say(`  ${c.yellow('이 연결은 모델 층 강도 조절이 적용되지 않습니다.')} ${c.gray('출력 상한만 단계별로 적용됩니다.')}`);
+    say(`  ${c.yellow(말('think.nomodel'))} ${c.gray(말('think.nomodel.note'))}`);
   }
   say('');
 }
@@ -1760,6 +1856,19 @@ function 증거명령(session, ctx, arg = '') {
   say('');
   rule('작업 증거', 70);
 
+  /*
+   * 기록이 새고 있으면 **목록보다 먼저** 말한다.
+   *
+   * 이 화면은 감사기록을 읽어서 만든다. 기록이 안 적히면 목록이 짧아지는
+   * 게 아니라 「아무것도 안 했다」로 보인다 — 아래 이른 반환이 그 자리다.
+   * 안 한 것을 말하라고 만든 화면이 안 한 것처럼 보이게 하면 안 된다.
+   */
+  if (e.기록못씀) {
+    say(`  ${mark.warn} ${c.yellow(`감사기록 ${e.기록못씀.수}건이 안 적혔습니다`)} ${c.gray(`— ${clip(e.기록못씀.까닭, 60)}`)}`);
+    say(`  ${c.gray('아래는 실제로 한 것보다 짧습니다.')}`);
+    say('');
+  }
+
   if (!e.바꾼것.length && !e.돌린것.length) {
     say(`  ${c.gray('이번 대화에서 아직 바꾸거나 돌린 것이 없습니다.')}`);
     say('');
@@ -2219,8 +2328,8 @@ function 배움명령(session, ctx, arg = '') {
 function showContext(session) {
   const b = session.breakdown();
   say('');
-  rule('컨텍스트', 70);
-  say(`  ${c.bold(session.conn.model)} ${c.gray('·')} ${b.total.toLocaleString()} 토큰`);
+  rule(말('scr.context'), 70);
+  say(`  ${c.bold(session.conn.model)} ${c.gray('·')} ${말('unit.tokens', { n: b.total.toLocaleString() })}`);
   say('');
   say(`  ${bar(b.used, b.total, 32)}  ${b.used.toLocaleString()} / ${b.total.toLocaleString()}  ${c.gray(`${Math.round((b.used / b.total) * 100)}%`)}`);
   say('');
@@ -2229,9 +2338,9 @@ function showContext(session) {
     say(`  ${c.gray(pad(r.label, 26))} ${pad(r.n.toLocaleString(), 8, 'right')}`);
   }
   say(`  ${c.gray('─'.repeat(35))}`);
-  say(`  ${c.gray(pad('남음', 26))} ${pad(b.left.toLocaleString(), 8, 'right')}`);
+  say(`  ${c.gray(pad(말('ctx.left'), 26))} ${pad(b.left.toLocaleString(), 8, 'right')}`);
   say('');
-  say(`  ${c.gray('/compact 대화 줄이기   /clear 통째로 비우기')}`);
+  say(`  ${c.gray(`/compact ${말('ctx.compactHint')}   /clear ${말('ctx.clearHint')}`)}`);
   /*
    * 추정이라고만 적어 두면 사람은 얼마나 믿어야 할지 모른다. 서버가 알려 준
    * 실제값에 맞춰 가고 있으면 그 사실을 적는다 — '추정' 과 '맞춰 본 추정' 은
@@ -2239,9 +2348,9 @@ function showContext(session) {
    */
   if (b.보정잰것 > 0) {
     const 차이 = Math.round((b.보정 - 1) * 100);
-    say(`  ${c.gray(`서버가 알려 준 실제값에 맞춰 ${차이 >= 0 ? '+' : ''}${차이}% 보정했습니다 (${b.보정잰것}번 재봄).`)}`);
+    say(`  ${c.gray(말('ctx.calibrated', { 부호: 차이 >= 0 ? '+' : '', 퍼센트: 차이, 번: b.보정잰것 }))}`);
   } else {
-    say(`  ${c.gray('숫자는 추정입니다 — 정확한 토크나이저를 쓰지 않습니다.')}`);
+    say(`  ${c.gray(말('ctx.estimate'))}`);
   }
   say('');
 }
@@ -2348,7 +2457,7 @@ async function 출력상한(session, arg = '') {
 
   if (말 === 'auto' || 말 === '자동') {
     session.conn.maxTokens = null;
-    if (prof) { delete prof.maxTokens; try { save(cfg); } catch {} }
+    if (prof) { delete prof.maxTokens; 설정남기기(cfg); }
     say(`  ${mark.ok} 직접 정한 값을 지웠습니다.`);
     say(`     ${c.gray(알아낸것 ? `서버에서 알아낸 ${알아낸것.toLocaleString()} 토큰을 씁니다.` : '모르는 값이라 16,384 토큰으로 갑니다.')}`);
     say('');
@@ -2364,7 +2473,7 @@ async function 출력상한(session, arg = '') {
       return;
     }
     session.conn.maxTokens = 값;
-    if (prof) { prof.maxTokens = 값; try { save(cfg); } catch {} }
+    if (prof) { prof.maxTokens = 값; 설정남기기(cfg); }
     say(`  ${mark.ok} 답 길이 상한 ${c.bold(값.toLocaleString())} 토큰`);
     say(`     ${c.gray('모델이 못 내는 값을 넣으면 서버가 거절합니다. 거절당하면')} ${c.cyan('/out auto')} ${c.gray('로 되돌리세요.')}`);
     say('');
@@ -2736,7 +2845,7 @@ async function 나가도되나묻기(session, p) {
 async function 골라적용(session, cfg, p) {
   if (!await 나가도되나묻기(session, p)) return;
   cfg.active = p.id;
-  try { save(cfg); } catch { /* 못 남겨도 이번 세션에는 바뀐다 */ }
+  설정남기기(cfg);
   연결적용(session, p);
   say(`  ${mark.ok} ${c.bold(p.name)} ${c.gray(p.model)} 로 바꿨습니다. 대화는 이어집니다.`);
   say('');
@@ -2765,8 +2874,8 @@ async function 모델만바꾸기(session, cfg, 모델) {
   // 서버는 그대로지만 문은 같이 지난다. 등록 안 된 서버로 옮겨 가는 길도
   // 여기라서, 여기를 열어 두면 자물쇠에 구멍이 하나 남는다.
   if (!await 나가도되나묻기(session, p)) return;
-  if (!이미) { try { save(upsert(cfg, p)); } catch { /* 못 남겨도 이번 세션에는 바뀐다 */ } }
-  else { cfg.active = p.id; try { save(cfg); } catch {} }
+  if (!이미) 설정남기기(upsert(cfg, p));
+  else { cfg.active = p.id; 설정남기기(cfg); }
   연결적용(session, p);
   say(`  ${mark.ok} 모델을 ${c.bold(모델)} 로 바꿨습니다. ${c.gray('서버는 그대로입니다.')}`);
   await 길이맞추기(session, cfg, p);
@@ -2788,7 +2897,7 @@ async function 길이맞추기(session, cfg, prof) {
   session.conn.ctx = 값;
   if (prof) {
     prof.ctx = 값;
-    try { save(cfg); } catch { /* 못 남겨도 이번 세션에는 먹는다 */ }
+    설정남기기(cfg);
   }
   say(`     ${c.gray('컨텍스트')} ${c.white(값.toLocaleString())} ${c.gray('토큰 (' + fmtSize(값) + ') — ' + (r?.source ? r.source + '에서 읽음' : '서버가 안 알려줘 기본값'))}`);
   if (r?.max && r?.loaded && r.max > r.loaded) {

package/src/completion.js

@@ -23,6 +23,10 @@
  */
 import { MODES } from './agent/modes.js';
 import { LEVELS, PROFILES } from './agent/effort.js';
+// 승인 모드(auto·confirm·strict). agent/modes.js 의 MODES 와 헷갈리기 쉬운데,
+// 저쪽은 `--work` 가 받는 '무슨 일을 하는 중인가' 다. 실제로 한 번 뒤바뀌어
+// 있었다 — `--mode` 를 누르면 code·plan 이 나오고 `--work` 는 폴더를 냈다.
+import { 차례 as 승인모드 } from './ui/approve.js';
 
 /** deel 이 받는 명령. bin/deel.js 의 switch 와 같아야 한다(검사가 지킨다). */
 export const 명령들 = [
@@ -39,6 +43,7 @@ export const 명령들 = [
   { 이름: 'scan', 뜻: '게이트웨이에 어떤 모델이 있나 훑는다', en: 'scan the gateway for available models' },
   { 이름: 'sessions', 뜻: '지난 대화 목록', en: 'list past conversations' },
   { 이름: 'ls', 뜻: 'sessions 와 같다', en: 'same as sessions' },
+  { 이름: 'reset', 뜻: '설정·기억·기록을 지운다 (그냥 치면 보여만 준다)', en: 'wipe settings, memory and records (bare: just shows)' },
   { 이름: 'completion', 뜻: '탭 완성 스크립트를 낸다', en: 'print a tab-completion script' },
   { 이름: 'version', 뜻: '판 번호', en: 'version number' },
   { 이름: 'help', 뜻: '도움말', en: 'help' },
@@ -55,8 +60,20 @@ export const 숨은명령 = ['-p'];
  */
 export const 깃발들 = [
   { 이름: '--root', 뜻: '작업 폴더', en: 'working folder', 값: '폴더' },
-  { 이름: '--work', 뜻: '살림 폴더 (.deel 자리)', en: 'state folder (where .deel lives)', 값: '폴더' },
-  { 이름: '--mode', 뜻: '무엇을 할 수 있게 할까', en: 'what the agent is allowed to do', 값: Object.keys(MODES) },
+  /*
+   * 이 둘은 한 번 뒤바뀌어 있었다.
+   *
+   * `--mode` 는 **승인 모드**(auto·confirm·strict)인데 작업 모드 목록이
+   * 붙어 있었고, `--work` 는 **작업 모드**인데 「살림 폴더」 라고 적혀 폴더를
+   * 완성해 주고 있었다. 그래서 `deel --mode <탭>` 을 누르면 받지도 않는
+   * code·plan 이 나왔다.
+   *
+   * 검사도 이걸 못 잡았다 — 완성 목록이 agent/modes.js 에서 온 것이 맞나만
+   * 봤기 때문이다. 베낀 자리가 맞는지는 봤는데, 베껴 온 곳이 맞는지는 안 봤다.
+   * 지금은 도움말에 적힌 값과 맞춰 본다 (test/completion.test.js).
+   */
+  { 이름: '--work', 뜻: '무슨 일을 하는 중인가', en: 'what kind of work this is', 값: Object.keys(MODES) },
+  { 이름: '--mode', 뜻: '무엇까지 물어보지 않고 할까', en: 'how much it may do without asking', 값: 승인모드 },
   { 이름: '--level', 뜻: '화면을 얼마나 자세히', en: 'how much detail on screen', 값: null },
   { 이름: '--ctx', 뜻: '창 크기 (예: 32k)', en: 'context window size (e.g. 32k)', 값: null },
   { 이름: '--max-tokens', 뜻: '한 번에 뱉을 최대 토큰', en: 'max tokens per reply', 값: null },
@@ -65,6 +82,7 @@ export const 깃발들 = [
   { 이름: '--online', 뜻: '묻지 않고 바깥으로 나간다', en: 'go outside without asking', 값: false },
   { 이름: '--offline', 뜻: '바깥으로 아예 안 나간다', en: 'never reach the network', 값: false },
   { 이름: '--yes', 뜻: '물어보지 않고 진행', en: 'do not ask, just proceed', 값: false },
+  { 이름: '--hard', 뜻: 'reset all 에서 되돌리기·감사기록까지', en: 'with reset all: undo snapshots and the audit log too', 값: false },
   { 이름: '--json', 뜻: '결과를 JSON 으로', en: 'output JSON', 값: false },
   { 이름: '--quiet', 뜻: '군말 없이', en: 'no chatter', 값: false },
   { 이름: '--tui', 뜻: '입력 상자를 켠다', en: 'force the input box on', 값: false },

package/src/config.js

@@ -164,6 +164,23 @@ export function save(cfg, { toProject = false } = {}) {
   return p;
 }
 
+/**
+ * 설정을 남긴다. 못 남겨도 던지지 않고, **왜 못 남겼는지를 돌려준다.**
+ *
+ * 부르는 자리가 아홉 군데인데 전부 `try { save(cfg) } catch {}` 였다. 「못
+ * 남겨도 이번 세션에는 먹는다」 는 맞는 말이지만, 그 뒤에 화면은 `✓` 를
+ * 찍는다 — 사람은 정해진 줄 알고 다음에 창을 열었다가 옛 값을 본다. 그리고
+ * 그때는 무엇 때문인지 알 길이 없다(홈이 읽기 전용인지, 디스크가 찼는지).
+ *
+ * 던지는 것은 안 바꾼다. 설정 하나 못 적었다고 대화가 끊기면 본말이 뒤집힌다.
+ *
+ * @returns {{ok: true, 자리: string} | {ok: false, 왜: string}}
+ */
+export function 저장시도(cfg, 옵션 = {}) {
+  try { return { ok: true, 자리: save(cfg, 옵션) }; }
+  catch (err) { return { ok: false, 왜: err?.message ?? String(err) }; }
+}
+
 export function activeProfile(cfg = load()) {
   if (!cfg.profiles.length) return null;
   return cfg.profiles.find((x) => x.id === cfg.active) ?? cfg.profiles[0];
@@ -172,6 +189,23 @@ export function activeProfile(cfg = load()) {
 // 환경변수가 있으면 파일보다 우선한다 — 사내망에서 키를 파일에 안 남기고 싶을 때 쓴다.
 const 푼것 = new Map();     // 잠긴 값 → 푼 글. 한 판에 한 번만 풀면 된다.
 
+/**
+ * 잠근 열쇠를 못 푼 까닭. 화면이 한 번 읽어 가면 지워진다.
+ *
+ * ── 왜 있어야 하나 ──────────────────────────────────────────────────────
+ *
+ * keystore.js 의 풀기() 는 왜 못 풀었는지를 성실하게 만들어 돌려준다 —
+ * 「이 PC 의 이 계정에서 잠근 것만 풀립니다」 같은 말이다. 그 함수 머리말이
+ * 그렇게 하는 까닭까지 적어 뒀다: **빈 글자만 돌려주면 사람은 401 만 보고
+ * 게이트웨이를 의심한다.**
+ *
+ * 그런데 부르는 쪽이 그 말을 버리고 있었다. 빈 열쇠가 나가면 http.js 는
+ * Authorization 머리말을 아예 안 붙이고, 게이트웨이는 401 을 준다. 사람은
+ * 방화벽·주소·계정을 뒤진다. 진짜 까닭은 「설정 파일을 다른 PC 로 옮겼다」 인데.
+ */
+let 열쇠탈 = null;
+export function 열쇠탈소식() { const s = 열쇠탈; 열쇠탈 = null; return s; }
+
 export function resolveKey(profile) {
   const byName = profile?.id ? process.env[`DEEL_KEY_${profile.id.toUpperCase()}`] : null;
   const 값 = byName || process.env.DEEL_API_KEY || profile?.apiKey || '';
@@ -180,8 +214,19 @@ export function resolveKey(profile) {
   // 기다리는 시간이라, 판에 한 번만 풀고 들고 있는다.
   if (푼것.has(값)) return 푼것.get(값);
   const r = 풀기(값);
-  푼것.set(값, r.ok ? r.text : '');
-  return r.ok ? r.text : '';
+  if (!r.ok) {
+    /*
+     * **실패는 안 담아 둔다.**
+     *
+     * 담아 두면 그 판 내내 다시 시도조차 안 한다. 사람이 그 사이에
+     * `deel setup` 으로 열쇠를 다시 넣어도 이 판에서는 영영 안 풀린다.
+     * 푸는 값이 0.2초라, 안 되는 것을 아껴서 얻을 것이 없다.
+     */
+    열쇠탈 = r.why || '잠근 열쇠를 못 풀었습니다';
+    return '';
+  }
+  푼것.set(값, r.text);
+  return r.text;
 }
 
 export function upsert(cfg, profile) {