deel-local-cli 1.7.0 → 1.10.0

package/src/repl.js

@@ -1,6 +1,7 @@
 // 대화 화면. 루프가 보내는 이벤트를 Claude Code 풍으로 그린다.
 import { createInterface, emitKeypressEvents } from 'node:readline';
-import { 규칙모으기 } from './safety/policy.js';
+import { 규칙모으기, 정책읽기 } from './safety/policy.js';
+import { 받기설정 } from './safety/authcmd.js';
 import { 주소가리기 } from './safety/secrets.js';
 import { homedir } from 'node:os';
 import { resolve, basename } from 'node:path';
@@ -8,7 +9,7 @@ import { c, say as 바로쓰기, mark, clip } from './ui/ansi.js';
 import { headerLines } from './ui/status.js';
 import { 종, 창제목, 제목되돌리기, 알릴까, 제목글 } from './ui/notify.js';
 import { 보이기 as 인트로, 기본곁말 } from './ui/intro.js';
-import { 언어잡기, 말 as 옮긴말 } from './i18n/index.js';
+import { 언어잡기, 말 as 옮긴말, 세말 } from './i18n/index.js';
 import { 알림채움 } from './backend/retry.js';
 import { 화면고르기 } from './ui/screen.js';
 import { STAGES } from './agent/effort.js';
@@ -21,8 +22,8 @@ import { makeScope } from './safety/guard.js';
 import { 언어서버있나 } from './tools/index.js';
 import { 모두끄기 as 언어서버다끄기 } from './lsp/client.js';
 import { History } from './safety/undo.js';
-import { Audit } from './safety/audit.js';
-import { activeProfile, load, resolveKey, save as saveCfg, homeDir, 잠금소식 } from './config.js';
+import { Audit, 열쇠묻기 } from './safety/audit.js';
+import { activeProfile, load, resolveKey, save as saveCfg, homeDir, 잠금소식, 열쇠탈소식 } from './config.js';
 import { discover } from './skills/discover.js';
 import { allowEndpoint, setOffline, isOffline } from './safety/network.js';
 import { 지금모드, 바깥인가, 나갈수있나 } from './safety/runmode.js';
@@ -33,12 +34,13 @@ import { 못박기 } from './agent/pins.js';
 import { 카드 } from './agent/card.js';
 import { 배움 } from './agent/evolve.js';
 import { 마크다운 } from './ui/md.js';
-import { askHidden } from './ui/prompt.js';
+import { askHidden, confirm } from './ui/prompt.js';
 import { explain, shows as levelShows } from './ui/level.js';
 import { 고르기 as 승인고르기, 다음 as 승인다음 } from './ui/approve.js';
 import { 추천, 채울글 } from './ui/complete.js';
 import { 접어쓰기 } from './ui/wrap.js';
-import { 접을까 as 붙임접을까, 표만들기 as 붙임표, 펼치기 as 붙임펼치기, 쓴번호들 as 붙임쓴번호들 } from './ui/pastechip.js';
+import { 접을까 as 붙임접을까, 표만들기 as 붙임표, 펼치기 as 붙임펼치기, 쓴번호들 as 붙임쓴번호들, 남길글 } from './ui/pastechip.js';
+import { 고른것풀기, 계획답풀기 } from './ui/pick.js';
 import { 이력지킴이 } from './ui/histline.js';
 import { probeCtx, 기본값 as CTX_DEFAULT } from './backend/ctxsize.js';
 import { renderDiff, shortStat } from './ui/diff.js';
@@ -70,7 +72,7 @@ const TOOL_GLYPH = {
 function toolLabel(name, args) {
   const a = args ?? {};
   const first =
-    a.file_path ?? a.pattern ?? a.path ?? a.url ?? a.name ?? a.목적 ??
+    a.file_path ?? a.pattern ?? a.path ?? a.url ?? a.name ?? a.purpose ?? a.목적 ??
     (a.command ? String(a.command).replace(/\s+/g, ' ').slice(0, 52) : null) ??
     // 뒤에서 도는 명령. 번호가 곧 그 일감의 이름이다 — 빈 괄호를 띄우면
     // 어느 것을 보고 있는지가 화면에서 사라진다. 서너 개를 띄워 놓고 나면
@@ -79,27 +81,27 @@ function toolLabel(name, args) {
     //
     // 이름 고르기는 jobs.js 에 맡긴다. 모델이 `job` 으로 보낼 수도 있는데,
     // 여기서 `a.번호` 만 보면 도구는 제대로 도는데 화면만 빈 괄호가 된다.
-    (() => { const g = 일감인자(a); return g.번호 != null ? `${g.번호}번${g.끝내기 ? ' · 끝내기' : ''}` : null; })() ??
+    (() => { const g = 일감인자(a); return g.번호 != null ? `${옮긴말('job.no', { n: g.번호 })}${g.끝내기 ? ` · ${옮긴말('job.stop')}` : ''}` : null; })() ??
     // 한 번에 여러 파일을 쓸 때. 빈 괄호를 띄우면 화면만 보고는 무엇을
     // 만들었는지 알 수 없다 — 첫 파일과 개수를 적는다.
     (Array.isArray(a.files) && a.files.length
-      ? `${a.files[0]?.file_path ?? '?'}${a.files.length > 1 ? ` 외 ${a.files.length - 1}개` : ''}`
+      ? `${a.files[0]?.file_path ?? '?'}${a.files.length > 1 ? ` ${옮긴말('more.files', { n: a.files.length - 1 })}` : ''}`
       : null) ??
     // 한 번에 여러 군데를 고칠 때. 파일 수와 군데 수는 다르다 — 한 파일을
     // 여섯 군데 고치는 것이 보통이라 '외 5개' 라고 적으면 거짓이 된다.
     (Array.isArray(a.edits) && a.edits.length
-      ? `${a.edits[0]?.file_path ?? '?'}${a.edits.length > 1 ? ` 외 ${a.edits.length - 1}군데` : ''}`
+      ? `${a.edits[0]?.file_path ?? '?'}${a.edits.length > 1 ? ` ${옮긴말('more.spots', { n: a.edits.length - 1 })}` : ''}`
       : null) ??
-    (Array.isArray(a.paths) && a.paths.length ? `${a.paths.length}개` : null) ??
+    (Array.isArray(a.paths) && a.paths.length ? 세말('count', a.paths.length) : null) ??
     // 할 일 목록은 보여줄 경로가 없다. 빈 괄호를 띄우느니 개수를 적는다.
-    (Array.isArray(a.todos) ? `${a.todos.length}건` : null) ?? '';
+    (Array.isArray(a.todos) ? 세말('hits', a.todos.length) : null) ?? '';
   const g = TOOL_GLYPH[name] ?? c.cyan('⏺');
   const 안 = clip(String(first ?? ''), 56);
   return `${g} ${c.bold(name)}${안 ? `${c.gray('(')}${c.gray(안)}${c.gray(')')}` : ''}`;
 }
 
 function toolResultLine(result, ms) {
-  const t = ms > 700 ? c.gray(`  ${(ms / 1000).toFixed(1)}초`) : '';
+  const t = ms > 700 ? c.gray(`  ${옮긴말('unit.sec', { n: (ms / 1000).toFixed(1) })}`) : '';
   if (result?.error) return `${c.red('└')} ${c.red(clip(String(result.error).split('\n')[0], 80))}${t}`;
 
   /*
@@ -111,16 +113,16 @@ function toolResultLine(result, ms) {
    */
   if (typeof result?.탈 === 'number') {
     const 조각 = [];
-    if (result.탈) 조각.push(c.red(`탈 ${result.탈}개`));
-    if (result.확인됨) 조각.push(c.green(`확인 ${result.확인됨}개`));
-    if (result.못확인) 조각.push(c.yellow(`못 확인 ${result.못확인}개`));
+    if (result.탈) 조각.push(c.red(옮긴말('sum.broken', { n: result.탈 })));
+    if (result.확인됨) 조각.push(c.green(옮긴말('sum.verified', { n: result.확인됨 })));
+    if (result.못확인) 조각.push(c.yellow(옮긴말('sum.unverified', { n: result.못확인 })));
     return `${result.탈 ? c.red('└') : c.gray('└')} `
-      + `${조각.join(c.gray(' · ')) || c.gray('확인할 것이 없었습니다')}${t}`;
+      + `${조각.join(c.gray(' · ')) || c.gray(옮긴말('sum.nothingToCheck'))}${t}`;
   }
 
   // 고친 자리는 몇 줄이 늘고 줄었는지를 요약 옆에 붙인다.
   const 셈 = result?.diff ? ` ${shortStat(result.diff)}` : '';
-  return `${c.gray('└')} ${c.gray(clip(result?.summary ?? '완료', 80))}${셈}${t}`;
+  return `${c.gray('└')} ${c.gray(clip(result?.summary ?? 옮긴말('sum.done'), 80))}${셈}${t}`;
 }
 
 // 수준별로 몇 줄까지 펼칠지. 초보에게 60줄을 쏟으면 아무것도 안 읽는다.
@@ -166,6 +168,22 @@ export async function chatLoop(opts = {}) {
     바로쓰기(`  ${mark.ok} ${잠금}`);
   }
 
+  /*
+   * 잠근 열쇠를 못 풀었으면 **그 까닭을** 적는다.
+   *
+   * 이걸 안 하면 빈 열쇠가 그대로 나가서 Authorization 머리말이 아예 안 붙고,
+   * 사람은 401 만 보고 방화벽·주소·계정을 뒤진다. 진짜 까닭은 대개
+   * 「설정 파일을 다른 PC 로 옮겼다」 이고, 그건 우리만 알고 있다.
+   *
+   * 아래 conn 을 짓는 자리에서 resolveKey 가 불리므로, 읽는 것은 그 뒤여야 한다.
+   */
+  const 열쇠탈보이기 = () => {
+    const 탈 = 열쇠탈소식();
+    if (!탈) return;
+    바로쓰기('');
+    바로쓰기(`  ${mark.warn} ${탈}`);
+  };
+
   /*
    * 여기서부터 화면에 나가는 것은 전부 `화면` 을 거친다.
    *
@@ -185,6 +203,14 @@ export async function chatLoop(opts = {}) {
   const conn = {
     kind: prof.kind, base: prof.baseUrl, auth: prof.auth,
     key: resolveKey(prof), model: prof.model,
+    /*
+     * 열쇠를 갖고 있는 대신 **받아 오는** 설정 (safety/authcmd.js).
+     *
+     * 여기서는 설정만 싣는다. 명령은 요청 직전에 부른다 — 켤 때 한 번
+     * 받아 두면 한 시간짜리 토큰이 세 시간짜리 대화 한복판에서 죽고,
+     * 그 401 은 화면에서 「열쇠가 틀렸다」 와 구별이 안 된다.
+     */
+    열쇠받기: 받기설정(prof, { 정책값: 정책읽기().값 }),
     // 컨텍스트 길이. 순서가 곧 우선순위다 —
     //   deel --ctx 655360  >  프로필에 저장된 값  >  기본값
     // 기본값으로 떨어졌다는 것은 '아직 못 쟀다' 는 뜻이다. 아래에서 그렇다고 말해 준다.
@@ -198,6 +224,9 @@ export async function chatLoop(opts = {}) {
     vision: prof.vision ?? false,
   };
 
+  // conn 을 짓느라 resolveKey 가 방금 불렸다. 못 푼 것이 있으면 여기서 말한다.
+  열쇠탈보이기();
+
   /*
    * ── 주소와 허가를 뗀다 ───────────────────────────────────────────────
    *
@@ -267,9 +296,49 @@ export async function chatLoop(opts = {}) {
    * 여기서 한 번만 읽는다. 상태줄은 글자를 칠 때마다 다시 그려지는데,
    * 그때마다 설정 파일을 열면 디스크를 초당 수십 번 두드리게 된다.
    */
-  session.요금표 = cfg?.요금 ?? null;
+  // `pricing` 으로 적어도 받는다 — 설정은 사람이 손으로 적는 것이라, 한글
+  // 자판이 없는 사람이 못 적는 이름 하나에 기능이 통째로 막히면 안 된다.
+  session.요금표 = cfg?.요금 ?? cfg?.pricing ?? null;
   session.제공자 = prof?.제공자 ?? null;
 
+  /*
+   * ── 열쇠를 받아 오는 연결 (safety/authcmd.js) ───────────────────────
+   *
+   * 두 자리를 여기서 잇는다.
+   *
+   *   묻기 — 우리가 남이 적어 준 명령을 띄우려는 참이다. 한 번은 물어야
+   *          한다. 다만 **한 판에 한 번만** 묻는다 (authcmd 가 기억한다) —
+   *          한 시간짜리 토큰으로 세 시간 일하면 세 번 받아 오는데, 세 번
+   *          다 물으면 사람은 손이 가는 대로 누른다. 관리 정책이 준
+   *          명령은 아예 안 묻는다.
+   *   표시 — 사내 로그인은 브라우저를 열고 사람을 기다린다. 그동안 화면이
+   *          조용하면 사람은 멈춘 줄 안다. 무엇을 기다리는지 적는다.
+   */
+  if (conn.열쇠받기) {
+    session.열쇠물어보기 = async (설정) => {
+      say('');
+      say(`  ${mark.warn} ${c.gray('이 연결은 열쇠를 받아 옵니다. 아래 명령을 띄웁니다:')}`);
+      say(`  ${c.white(clip(설정.명령, 88))}`);
+      say(`  ${c.gray('받은 열쇠는 이 판이 도는 동안 메모리에만 있고, 파일로 안 적습니다.')}`);
+      const 예 = await confirm('  띄울까요?', true);
+      say('');
+      return 예;
+    };
+    session.onAuth = (것) => {
+      if (것?.type === '시작') return 화면.돌리기(옮긴말('auth.waiting'));
+      if (것?.type === '끝') return 화면.돌림멈춤('');
+      화면.돌림멈춤('');
+      if (것?.ok) {
+        const 초 = Math.max(0, Math.round((것.만료 - Date.now()) / 1000));
+        return say(`  ${mark.ok} ${c.gray(옮긴말('auth.got', { 분: Math.round(초 / 60) }))}`);
+      }
+      // 못 받았어도 대화를 안 끊는다. 원래 열쇠로 가 보고, 그것도 안 되면
+      // 서버가 한 말이 화면에 나온다. 여기서 끊으면 무엇이 문제인지 못 본다.
+      say(`  ${mark.warn} ${c.gray(옮긴말('auth.failed', { 왜: 것?.왜 ?? '?' }))}`);
+      if (것?.보인것) say(`    ${c.gray(clip(String(것.보인것), 88))}`);
+    };
+  }
+
   // ── 대화 이어하기 ─────────────────────────────────────────────────────
   // 껐다 켜도 이어지도록, 메시지가 오갈 때마다 .deel/sessions/ 에 바로 적는다.
   let store = null;
@@ -320,7 +389,7 @@ export async function chatLoop(opts = {}) {
    */
   const mcp붙임 = await 다붙이기(root, {
     offline: isOffline(),
-    audit: new Audit(root),
+    audit: new Audit(root, { 열쇠들: 열쇠묻기(conn) }),
   });
 
   // 이 PC 에 있는 스킬·명령·플러그인을 찾아 붙인다. 품고 다니지 않는다.
@@ -565,7 +634,7 @@ export async function chatLoop(opts = {}) {
          * 백틱으로 이어 쓴 경우에는 앞줄이 이미 찍혀 있으므로 마지막 줄만
          * 이어 찍는다 — 안 그러면 같은 줄이 두 번 보인다.
          */
-        const 찍을것 = 이어쓴것 ? l : 보낼것;
+        const 찍을것 = 남길글(이어쓴것 ? l : 보낼것, 붙인것들);
         if (찍을것.trim() || 이었나) {
           for (const [i, 한줄] of String(찍을것).split('\n').entries()) {
             say(`${i === 0 && !이어쓴것 ? ` ${c.hcyan('❯')} ` : '   '}${c.white(한줄)}`);
@@ -712,7 +781,23 @@ export async function chatLoop(opts = {}) {
         const 붙인것 = 붙인줄들 ? 펴기(붙인줄들.join('\n')) : '';
         const 폭 = Math.max(20, (process.stdout.columns ?? 80) - 8);
 
-        if (붙인줄들 && 입력기다림 && 묻는중 === null && 붙임접을까(붙인것, { 폭 })) {
+        /*
+         * ── 일하는 도중에 붙여도 접는다 ──────────────────────────────────
+         *
+         * 여태 이 갈래는 `입력기다림` 일 때만 돌았다. 그런데 붙여넣기는
+         * **일하는 도중이 더 흔하다** — 몇 분짜리 턴이 도는 동안 다음에
+         * 시킬 것을 미리 붙여 두는 것이 그것이다.
+         *
+         * 그때 무슨 일이 났나. 붙인 마흔 줄 중 마지막 한 줄만 rl.line 에
+         * 남고 나머지는 상자 밖 버퍼로 간다. 일하는 중 화면(대기갱신)은
+         * rl.line 만 그리므로, 사람 눈에는 **한 줄만 들어간 것**으로 보인다.
+         * 그래서 다시 붙인다. 이번엔 진짜로 두 번 들어간다 — 접기가 애초에
+         * 막으려던 바로 그 사고가, 기다릴 때는 안 나고 일할 때만 났다.
+         *
+         * 펴는 자리는 그대로다(아래 붙임펼치기). 어느 길로 보내든 원문이
+         * 간다 — 접는 자리만 넓혔지 되돌리는 길은 안 건드렸다.
+         */
+        if (붙인줄들 && 묻는중 === null && 붙임접을까(붙인것, { 폭 })) {
           const 번호 = ++붙임번호;
           붙인것들.set(번호, 붙인것);
           이어쓰기줄들 = 붙임앞줄수 ? (이어쓰기줄들 ?? []).slice(0, 붙임앞줄수) : null;
@@ -720,13 +805,22 @@ export async function chatLoop(opts = {}) {
           const 표 = 붙임표(번호, 붙인것);
           rl.line = 앞머리 + 표;
           rl.cursor = rl.line.length;
-          화면.입력지움();
-          say(`  ${c.gray(`${표} — 접어 뒀습니다. 보낼 때 그대로 펴집니다.`)}`);
+          if (입력기다림) {
+            화면.입력지움();
+            say(`  ${c.gray(옮긴말('paste.folded', { 표 }))}`);
+          } else {
+            /*
+             * 일하는 중에는 대화에 안 찍는다. 찍으면 이미 보낸 것처럼 보인다
+             * (아래 미리 쳐 둔 것 갈래와 같은 까닭이다). 일감 상자에 지금
+             * 들고 있는 것으로 그려 주면 그것으로 족하다.
+             */
+            화면.대기갱신(펴기(rl.line), queue.length);
+          }
         } else if (이어쓰기줄들?.length && 입력기다림) {
           // 접지 않은 덩이는 몇 줄인지라도 알려 준다. 안 보이면 사라진 줄
           // 알고 다시 붙인다.
           화면.입력지움();
-          say(`  ${c.gray(`${이어쓰기줄들.length + 1}줄을 붙여넣었습니다 — Enter 로 한 번에 보냅니다`)}`);
+          say(`  ${c.gray(옮긴말('paste.pasted', { n: 이어쓰기줄들.length + 1 }))}`);
         }
         화면.입력갱신?.(session, 펴기(rl.line), rl.cursor ?? 0);
         return;
@@ -741,8 +835,25 @@ export async function chatLoop(opts = {}) {
        * ESC 는 **멈추기만** 한다. 끝내지 않는다. 그래서 마음 놓고 누를 수 있다.
        * 도는 중이 아닐 때는 아무것도 안 한다 — 입력칸에서 ESC 를 눌렀다고
        * 치던 글이 날아가면 그게 더 놀랍다.
+       *
+       * ── meta 를 안 본다 ──────────────────────────────────────────────
+       *
+       * 여기 `!key.meta` 가 붙어 있었다. 그래서 이 갈래는 **한 번도 안
+       * 돌았다** — 사람이 ESC 를 눌러도 아무 일이 안 났다.
+       *
+       * 홑 ESC 는 그 자체가 escape 열쇠의 시작 바이트이기도 해서, Node 의
+       * readline 은 뒤에 뭐가 더 올지 500ms 를 기다렸다가 아무것도 안 오면
+       * `{ name:'escape', meta:true }` 로 배달한다. 즉 **ESC 는 언제나
+       * meta 가 참**이다. 직접 재어 봤다 —
+       *
+       *     \x1b       → {"name":"escape","meta":true}
+       *     \x1b\x1b   → {"name":"escape","meta":true}
+       *
+       * 그러니 meta 를 보고 거르면 ESC 를 통째로 거르는 셈이다. 이름이
+       * escape 인 것에 Ctrl·Shift 가 붙는 조합은 터미널이 아예 안 보내므로
+       * 나머지 둘만 본다.
        */
-      if (key?.name === 'escape' && !key.ctrl && !key.meta && !key.shift) {
+      if (key?.name === 'escape' && !key.ctrl && !key.shift) {
         if (turn && !turn.signal.aborted) { turn.abort(); 멈추는중(); return; }
         return;
       }
@@ -880,12 +991,46 @@ export async function chatLoop(opts = {}) {
     });
   }
 
-  const nextLine = () => {
+  /*
+   * 다음 줄을 기다린다. 멈춤신호를 주면 **기다리다가도 손을 뗀다.**
+   *
+   * 신호 없이 기다리는 자리(맨 위 입력칸)는 여태 그대로다 — 거기서 ESC 는
+   * 아무 일도 안 하는 것이 맞다. 신호를 주는 쪽은 turn 이 도는 동안 사람
+   * 답을 기다리는 자리뿐이다.
+   */
+  const nextLine = (멈춤 = null) => {
     if (queue.length) return Promise.resolve(queue.shift());
     if (closed) return Promise.resolve(null);
-    return new Promise((res) => { waiter = res; });
+    if (멈춤?.aborted) return Promise.resolve(null);
+    return new Promise((res) => {
+      waiter = res;
+      if (!멈춤) return;
+      /*
+       * 기다리던 자리를 **반드시 비우고** 돌아간다.
+       *
+       * 안 비우면 다음에 사람이 친 줄이 이미 없어진 물음에게 배달되고,
+       * 그 줄은 화면에서 그냥 사라진다 — 「쳤는데 안 먹었다」 가 된다.
+       */
+      멈춤.addEventListener('abort', () => {
+        if (waiter === res) waiter = null;
+        res(null);
+      }, { once: true });
+    });
   };
 
+  /*
+   * ── 사람에게 되묻는 자리 ────────────────────────────────────────────────
+   *
+   * 여기도 ESC 로 손을 뗄 수 있어야 한다. 예전에는 이 자리가 **멈춤에서
+   * 빠져 있었다** — 도구가 「실행할까요?」 를 띄운 채 답을 기다리면 ESC 를
+   * 몇 번을 눌러도 아무 일도 안 났다. turn 은 이미 끊긴 상태인데 화면은
+   * 물음을 그대로 들고 서 있으니, 사람은 Ctrl+C 로 손이 가고 두 번 누르면
+   * 대화가 통째로 닫힌다. "ESC 를 눌러도 안 멈춘다" 는 제보의 한 갈래다.
+   *
+   * 멈췄을 때 무엇으로 답한 셈 칠지는 부르는 쪽이 정한다(`멈추면`). 기본값을
+   * `def` 로 하면 안 된다 — confirm 의 def 는 'y' 라, 멈추라고 누른 것이
+   * 승인으로 읽힌다.
+   */
   const ask = async (label, o = {}) => {
     const 앞 = `  ${c.gray('›')} ${label} ${o.def ? c.gray(`[${o.def}] `) : ''}`;
     화면.붙임(앞);
@@ -897,8 +1042,15 @@ export async function chatLoop(opts = {}) {
      */
     묻는중 = 상자쓰나 ? 앞 : null;
     이어쓰기줄들 = null; 이어쓴것 = false;   // 되묻는 사이에 걸쳐 있던 미완성 이어쓰기는 버린다
+    const 멈춤 = o.signal ?? turn?.signal ?? null;
     try {
-      const a = await nextLine();
+      const a = await nextLine(멈춤);
+      if (멈춤?.aborted) {
+        // 물음이 화면에 걸린 채로 남으면 안 된다. 줄을 끊고 멈췄다고 적는다.
+        say('');
+        say(`  ${c.gray(옮긴말('ask.stopped'))}`);
+        return o.멈추면 ?? '';
+      }
       if (a === null) return o.def ?? '';
       return a.trim() || o.def || '';
     } finally { 묻는중 = null; }
@@ -936,15 +1088,33 @@ export async function chatLoop(opts = {}) {
     for (const f of files) {
       const 이름 = ctx?.scope ? ctx.scope.show(f.path) : f.path;
       if (f.missing) {
-        say(`  ${c.yellow('⚠')} ${c.white(이름)} ${c.gray('— 만들어지지 않았습니다')}`);
+        say(`  ${c.yellow('⚠')} ${c.white(이름)} ${c.gray(옮긴말('run.notMade'))}`);
         continue;
       }
       if (f.dir) continue;
       const kb = f.bytes >= 1024 ? `${(f.bytes / 1024).toFixed(1)}KB` : `${f.bytes}B`;
-      say(`  ${c.green('✓')} ${c.white(이름)} ${c.gray(`· ${f.lines.toLocaleString()}줄 · ${kb}`)}`);
+      say(`  ${c.green('✓')} ${c.white(이름)} ${c.gray(`· ${세말('lines', f.lines)} · ${kb}`)}`);
     }
   };
 
+  /*
+   * 시킨 것 중 자국이 하나도 안 남은 항목을 적는다.
+   *
+   * 조용히 넘어가면 사람은 다 된 줄 알고 그 위에 다음 것을 쌓는다. 나중에
+   * 발견했을 때는 이미 늦다. 「몇 번 까먹거나 누락되거나」라는 제보가 정확히
+   * 그 모양이었다 — 빠진 것 자체보다, 빠졌다는 말을 안 한 것이 문제다.
+   *
+   * 세 자리(done·limit·stuck)가 같은 글을 내야 한다. 한 군데만 고치면
+   * 「끝났을 때는 알려 주는데 끊겼을 때는 안 알려 주는」 화면이 된다 —
+   * 정작 빠질 확률은 끊겼을 때가 훨씬 높다.
+   */
+  const 빠진것보이기 = (빠진) => {
+    if (!빠진?.length) return;
+    say('');
+    say(`  ${c.yellow('!')} ${c.white(`시킨 것 중 ${빠진.length}가지가 안 다뤄졌습니다`)}`);
+    for (const x of 빠진) say(`    ${c.gray(`${x.번호}. ${clip(x.글, 68)}`)}`);
+  };
+
   const ctx = {
     scope: makeScope(root),
     // 도구가 한 번에 돌려줄 양을 이 값에서 뽑는다 (agent/budget.js).
@@ -955,7 +1125,7 @@ export async function chatLoop(opts = {}) {
     // 적어 둔 허락·금지 규칙 (safety/policy.js). 승인 모드보다 먼저 본다.
     규칙들: 규칙모으기(cfg),
     history: new History(root),
-    audit: new Audit(root),
+    audit: new Audit(root, { 열쇠들: 열쇠묻기(conn) }),
     seen: new Set(),
     // 붙은 MCP 서버. 도구를 부를 때 여기서 찾는다.
     mcp: mcp붙임.서버들,
@@ -1099,10 +1269,21 @@ export async function chatLoop(opts = {}) {
       창제목(제목글('도는중', { 폴더: 알림.폴더 }));
 
       if (!답) return null;
-      // 숫자로 골랐으면 그 줄의 글을 그대로 돌려준다 — 모델에게 "2" 만 가면
-      // 무엇을 고른 것인지 모른다.
-      const n = Number(답);
-      const 고른것 = Number.isInteger(n) && n >= 1 && n <= 고를것.length ? 고를것[n - 1] : 답;
+      /*
+       * 숫자로 골랐으면 그 줄의 글을 그대로 돌려준다 — 모델에게 "2" 만 가면
+       * 무엇을 고른 것인지 모른다.
+       *
+       * 그리고 **고르면서 한마디 덧붙일 수 있다.** 여태는 둘 중 하나였다 —
+       * 숫자만 치면 고른 것이고, 그 밖의 글은 고른 것 없는 자유 답이었다.
+       * 그래서 「2 파일은 나눠서」 라고 치면 2번을 골랐다는 사실이 사라졌다.
+       * 가르는 규칙은 ui/pick.js 머리말에 적어 두었다.
+       */
+      const 푼것 = 고른것풀기(답, 고를것);
+      const 고른것 = 푼것.글;
+      /*
+       * 되비추는 줄에도 **둘 다** 보인다. 고른 것만 보이면 덧붙인 말이
+       * 갔는지 안 갔는지 알 길이 없어서, 사람은 다음 턴에 그 말을 또 친다.
+       */
       say(`  ${c.hgreen('▶')} ${c.gray(clip(고른것, 70))}`);
       say('');
       return 고른것;
@@ -1117,7 +1298,8 @@ export async function chatLoop(opts = {}) {
        */
       if (알릴까({ 물어봄: true, 켬: 알림.켬 })) 종();
       창제목(제목글('물어봄', { 폴더: 알림.폴더 }));
-      const a = (await ask('실행할까요? (y/n)', { def: 'y' })).toLowerCase();
+      // 멈추라고 누른 것은 **거절**이다. def 인 'y' 로 물러나면 ESC 가 승인이 된다.
+      const a = (await ask('실행할까요? (y/n)', { def: 'y', 멈추면: 'n' })).toLowerCase();
       창제목(제목글('도는중', { 폴더: 알림.폴더 }));
       return a === 'y' || a === 'yes' || a === 'ㅇ';
     },
@@ -1171,7 +1353,7 @@ export async function chatLoop(opts = {}) {
   if (opts.ctx == null) {
     // 이 컴퓨터 안의 서버면 눈 깜짝할 새다. 사내 게이트웨이는 몇 초 걸릴 수 있어
     // 무슨 일이 일어나는 중인지 알려 준다 — 멈춘 것처럼 보이면 안 된다.
-    화면.돌리기('모델에 걸린 컨텍스트 길이를 확인하는 중…');
+    화면.돌리기(옮긴말('run.ctxProbe'));
     let r = null;
     try { r = await probeCtx(conn, { timeout: 6000 }); } catch { /* 못 물어보면 아래에서 처리 */ }
     화면.돌림멈춤('');
@@ -1257,15 +1439,15 @@ export async function chatLoop(opts = {}) {
   }
   // 안 뜬 것은 조용히 빠지면 안 된다. "왜 그 도구가 없지" 를 영영 알 수 없다.
   for (const m of mcp붙임.못한것) warn.push(`MCP ${c.white(m.이름)} 을 못 붙였습니다 — ${m.왜}`);
-  if (!conn.tools) warn.push('도구 호출이 확인되지 않았습니다 — deel diagnose 로 점검하세요');
-  if (!conn.streaming) warn.push('스트리밍이 없어 응답이 한 번에 나옵니다');
+  if (!conn.tools) warn.push(옮긴말('run.noTools'));
+  if (!conn.streaming) warn.push(옮긴말('run.noStream'));
   warn.push(...길이경고);
   // 잘 된 것은 경고 표시를 달지 않는다. ⚠ 가 붙으면 뭘 고쳐야 하나 싶어진다.
   for (const l of 길이알림) say(`  ${mark.ok} ${c.gray(l)}`);
   for (const w of warn) say(`  ${mark.warn} ${c.gray(w)}`);
   // ESC 를 앞에 둔다 — 멈추는 길로는 이것이 먼저다. Ctrl+C 는 두 번 누르면
   // 끝나 버려서, 급히 멈추려던 사람이 대화를 통째로 닫는 일이 실제로 있었다.
-  say(`  ${c.gray('/help 명령 목록')}   ${c.gray('ESC 중단')}   ${c.gray('Ctrl+C 중단·끝내기')}`);
+  say(`  ${c.gray(옮긴말('run.hintHelp'))}   ${c.gray(옮긴말('run.hintEsc'))}   ${c.gray(옮긴말('run.hintQuit'))}`);
 
   /*
    * ── 바깥으로 나가도 되는지 한 번 묻는다 ─────────────────────────────
@@ -1606,7 +1788,7 @@ export async function chatLoop(opts = {}) {
             break;
 
           case 'waiting':
-            화면.기다림(c.gray(꼬리표(stage) + '생각 중…'));
+            화면.기다림(c.gray(꼬리표(stage) + 옮긴말('run.thinking')));
             // 지워야 할 줄이 화면에 있다고 표시해 둔다.
             //
             // 전에는 이 표시를 안 세웠다. \r 로 커서만 앞으로 보내 놓고 지우지는
@@ -1617,7 +1799,7 @@ export async function chatLoop(opts = {}) {
 
           case 'thinking':
             thinkChars += ev.text.length;
-            화면.생각(`${mark.think} ${c.gray(꼬리표(stage))}${c.gray(`생각 중… ${thinkChars.toLocaleString()}자`)}`);
+            화면.생각(`${mark.think} ${c.gray(꼬리표(stage))}${c.gray(옮긴말('run.thinkingChars', { n: thinkChars.toLocaleString() }))}`);
             if (process.stdout.isTTY) thinkingShown = true;
             break;
 
@@ -1898,6 +2080,30 @@ export async function chatLoop(opts = {}) {
             break;
           }
 
+          /*
+           * 자리가 다 차서 기억을 비웠다. **턴은 안 죽었다.**
+           *
+           * 여기 붉은 줄을 찍으면 사람은 하던 일이 엎어진 줄 알고 /clear 를
+           * 치고 시킨 말을 다시 타이핑한다 — 정작 지금은 시킨 말과 남은 할 일을
+           * 들고 그대로 이어 가는 중이다. 접기(compacted)와 같은 자리·같은
+           * 빛깔로 한 줄만 적는다.
+           */
+          case 'reset': {
+            접기멈춤();
+            clearThinking();
+            const 할일수 = ev.kept?.할일 ?? 0;
+            say(`  ${c.cyan('◱')} ${c.gray(할일수
+              ? 옮긴말('ev.reset', { 버린수: ev.dropped, 할일: 할일수 })
+              : 옮긴말('ev.resetBare', { 버린수: ev.dropped }))}`);
+            /*
+             * 비우면 이력이 통째로 바뀐다. 덧붙이기로는 못 맞춘다.
+             * 여기서 안 적으면, 비운 뒤에 죽었을 때 /resume 이 옛 대화를
+             * 통째로 되살려 놓는다 — 자리가 없어서 비운 것이 도로 차 있다.
+             */
+            ctx.갈래.현재store().replace(session.messages, `자리부족 — 앞선 대화 ${ev.dropped}개를 비움`);
+            saved = session.messages.length;
+            break;
+          }
           // 서버가 거절하면서 알려 준 한계를 받아 적었다. 실패로 보이면 안 된다 —
           // 사용자 눈에는 잠깐 멈췄다가 그냥 잘 되는 것으로 보여야 맞다.
           case 'learned':
@@ -1919,13 +2125,38 @@ export async function chatLoop(opts = {}) {
            * 대충 답한 줄 알고 같은 것을 다시 시키고, 같은 자리에서 또 잘린다.
            * 손댈 자리를 그 자리에서 알려 준다.
            */
+          /*
+           * ── 붙잡아 둔 반 줄을 먼저 비운다 ────────────────────────────
+           *
+           * 표를 그리려면 줄이 다 모여야 해서, 마크다운 그림은 마지막
+           * 몇 줄을 손에 쥐고 있다. `done` 은 그걸 비우고 끝나는데
+           * capped·cutoff·error 는 안 비우고 있었다.
+           *
+           * 그러면 두 가지가 난다. 붙잡힌 글이 **화면에서 그냥 사라지거나**
+           * (오류로 끝나면 뒤에 done 이 없다), 무엇이 잘렸는지 보라고 띄운
+           * 경고가 정작 그 답의 마지막 줄보다 **위에** 찍힌다.
+           */
           case 'capped':
             clearThinking();
+            if (streamed) { 답비우기(); say(''); streamed = false; }
             say(`  ${mark.warn} ${c.gray(`답이 ${c.white(ev.cap.toLocaleString())} 토큰에서 잘렸습니다`)}`
               + `${ev.정한값 ? c.gray(' (직접 정하신 상한입니다)') : c.gray(' — 더 못 올리는 천장입니다')}`);
             say(`     ${c.gray('한 번에 더 길게 받으려면')} ${c.cyan('/out 32k')}${c.gray('. 파일을 쓰는 중이었다면 Append 로 나눠 쓰게 하세요.')}`);
             break;
 
+          /*
+           * 상한에서 잘린 것이 아니라, 서버가 **끝난 까닭을 한 번도 안 주고**
+           * 흘려보내기를 멈춘 것이다. 여태 이건 정상 종료와 구별이 안 돼서
+           * 중간에서 끊긴 답이 온전한 답인 척 지나갔다.
+           * /out 을 권하면 안 된다 — 상한 얘기가 아니라 연결 얘기다.
+           */
+          case 'cutoff':
+            clearThinking();
+            if (streamed) { 답비우기(); say(''); streamed = false; }
+            say(`  ${mark.warn} ${c.gray('서버가 끝났다는 말 없이 답을 멈췄습니다 — 중간에서 끊겼을 수 있습니다.')}`);
+            say(`     ${c.gray('중계 프록시·게이트웨이를 거치면 나는 일입니다. 같은 것을 다시 물어 보세요.')}`);
+            break;
+
           case 'compact_failed':
             접기멈춤();
             say(`  ${c.gray(`(접지 못했습니다: ${ev.why})`)}`);
@@ -1946,6 +2177,9 @@ export async function chatLoop(opts = {}) {
               if (ev.남은할일.length > 8) say(`    ${c.gray(`… 그 밖에 ${ev.남은할일.length - 8}개`)}`);
             }
             만든파일보이기(ev.files);
+            // 할 일 목록에 못 들어간 채로 빠진 것도 같이 적는다 — 목록에
+            // 없으면 「안 끝난 것」 에도 안 뜨므로 여기서 말 안 하면 아무 데도 없다.
+            빠진것보이기(ev.빠진);
             break;
 
           // 같은 자리를 계속 반복하고 있다. 두면 컨텍스트만 차고 아무것도 안 나온다.
@@ -1969,6 +2203,7 @@ export async function chatLoop(opts = {}) {
             // 멈췄어도 여기까지 만든 것은 있다. 그것부터 알려 준다 —
             // 없는 줄 알고 다시 시키면 앞서 만든 것을 덮어쓴다.
             만든파일보이기(ev.files);
+            빠진것보이기(ev.빠진);
             break;
 
           case 'aborted':
@@ -1987,8 +2222,17 @@ export async function chatLoop(opts = {}) {
           case 'error':
             턴탈났나 = true;
             clearThinking();
+            // 붙잡아 둔 반 줄을 먼저 비운다 — 까닭은 위 capped 자리에 적어 두었다.
+            if (streamed) { 답비우기(); say(''); streamed = false; }
             say('');
             오류보이기(ev.text);
+            /*
+             * 반쪽이라도 남겼으면 그렇다고 말해 준다.
+             *
+             * 안 말하면 사람은 화면에 보이는 200자가 대화에도 들어갔는지를
+             * 모른다. 모르면 "이어서 해줘" 를 못 치고 처음부터 다시 친다.
+             */
+            if (ev.kept) say(`  ${c.gray(옮긴말('run.errKept'))}`);
             break;
 
           /*
@@ -2018,11 +2262,7 @@ export async function chatLoop(opts = {}) {
              * 제보가 정확히 그 모양이었다 — 빠진 것 자체보다, 빠졌다는 말을
              * 안 한 것이 문제다.
              */
-            if (ev.빠진?.length) {
-              say('');
-              say(`  ${c.yellow('!')} ${c.white(`시킨 것 중 ${ev.빠진.length}가지가 안 다뤄졌습니다`)}`);
-              for (const x of ev.빠진) say(`    ${c.gray(`${x.번호}. ${clip(x.글, 68)}`)}`);
-            }
+            빠진것보이기(ev.빠진);
             break;
         }
       }
@@ -2060,11 +2300,15 @@ export async function chatLoop(opts = {}) {
     turn = null;
     interrupted = false;   // 중단은 '끝내기' 의사가 아니다. 종료 카운트를 되돌린다.
     flush();               // 오류로 끝났어도 여기까지는 남긴다
+    // 대화가 파일에 안 적히고 있으면 여기서 **한 번** 말한다 (agent/store.js).
+    // 여태는 아무 말이 없어서, 사람이 알아차리는 자리가 다음 날 --resume 이었다.
+    const 저장샘 = ctx.갈래?.현재store?.()?.처음못쓴것?.();
+    if (저장샘) say(`  ${mark.warn} ${c.yellow(옮긴말('store.notSaving', { n: 저장샘.수, 까닭: 저장샘.까닭 }))}`);
 
     // ── 꼬리말 — 이번 턴만의 숫자 ────────────────────────────────────────
     const secs = ((Date.now() - started) / 1000).toFixed(1);
-    const bits = [`${secs}초`];
-    if (tools) bits.push(`도구 ${tools}회`);
+    const bits = [옮긴말('unit.sec', { n: secs })];
+    if (tools) bits.push(`${옮긴말('scr.tools')} ${옮긴말('unit.calls', { n: tools })}`);
     const dIn = session.usage.in - before.in;
     const dOut = session.usage.out - before.out;
     if (dIn || dOut) bits.push(`↑${dIn.toLocaleString()} ↓${dOut.toLocaleString()}`);
@@ -2101,14 +2345,29 @@ export async function chatLoop(opts = {}) {
       if (알릴까({ 물어봄: true, 켬: 알림.켬 })) 종();
       창제목(제목글('물어봄', { 폴더: 알림.폴더 }));
       const 답 = String(await ask(
-        `이대로 진행할까요? ${c.gray('⏎ 진행 · n 취소 · 그 밖엔 고칠 점')}`,
+        `${옮긴말('plan.ask')} ${c.gray(옮긴말('plan.hint'))}`,
         { def: 'y' },
       )).trim();
-      const 낮춘 = 답.toLowerCase();
+      /*
+       * ── 골라진 것 + 하고 싶은 말 ────────────────────────────────────
+       *
+       * 여태는 셋 중 하나였다. ⏎ 면 진행, n 이면 그만, 그 밖의 글은 통째로
+       * 「이걸 고쳐서 다시 내라」. 그래서 「그대로 하되 검사도 넣어줘」 라고
+       * 치면 **계획을 다시 짜러 갔다** — 사람은 진행하라고 한 것인데.
+       * 반대로 「3단계는 빼자」 도 그냥 글 한 줄로 갔다. 어느 단계 얘긴지
+       * 모델이 다시 세어 봐야 한다.
+       *
+       * 이제 넷이다. 가르는 규칙은 ui/pick.js 의 계획답풀기() 에 있다.
+       *   ⏎ · y            → 그대로 진행
+       *   y 검사도 넣어줘    → 진행하되 그 말을 얹어서
+       *   3 이건 빼자        → 3단계에 대고 하는 말로 붙여 다시 짜라
+       *   그 밖의 글         → 여태 그대로 (다시 짜라)
+       */
+      const 계획답 = 계획답풀기(답, 할일.length);
 
-      if (['n', 'no', 'ㄴ', '취소', '아니', '아니요', '아니오'].includes(낮춘)) {
-        say(`  ${c.gray('그만뒀습니다. 계획은 위에 남아 있으니 이어서 말씀하셔도 됩니다.')}`);
-      } else if (['y', 'yes', 'ㅇ', 'ㅇㅇ', 'ㄱ', 'ㄱㄱ', '네', '응', '진행', 'ok'].includes(낮춘)) {
+      if (계획답.갈래 === '그만') {
+        say(`  ${c.gray(옮긴말('plan.cancelled'))}`);
+      } else if (계획답.갈래 === '진행') {
         /*
          * 승인한 계획을 **글자 그대로 실어 보낸다.**
          *
@@ -2128,16 +2387,33 @@ export async function chatLoop(opts = {}) {
           : '바로 위에 네가 적은 계획을 사람이 승인했다.'
             + ' 그 계획을 다시 적지 말고 지금부터 그대로 해라.')
           + ' 계획을 다시 적지 마라. **지난 대화를 뒤지지 마라** — 필요한 것은'
-          + ' 이 대화 안에 다 있다. 다 끝나면 무엇을 만들었는지만 짧게 알려라.';
+          + ' 이 대화 안에 다 있다. 다 끝나면 무엇을 만들었는지만 짧게 알려라.'
+          /*
+           * 승인하며 덧붙인 말은 **맨 뒤에** 붙인다.
+           *
+           * 계획 다음에 오는 말이라 「계획은 그대로, 다만 이것」 으로 읽힌다.
+           * 앞에 붙이면 계획보다 먼저 읽혀서, 작은 모델은 그 한마디만
+           * 하고 계획은 안 한다.
+           */
+          + (계획답.덧말 ? `\n\n사람이 승인하며 덧붙인 말: ${계획답.덧말}` : '');
         이어갈모드 = 'code';
         say('');
-        say(`  ${c.hgreen('▶')} ${c.gray('계획대로 진행합니다.')}`);
+        say(`  ${c.hgreen('▶')} ${c.gray(계획답.덧말
+          ? 옮긴말('plan.goingWith', { 말: clip(계획답.덧말, 50) })
+          : 옮긴말('plan.going'))}`);
       } else {
         // 'e' 를 따로 두지 않는다 — 고칠 점을 바로 치는 것이 한 걸음 짧다.
-        이어갈것 = `계획에서 이걸 고쳐서 **계획만** 다시 내라 (아직 실행하지 마라): ${답}`;
+        // 단계 번호를 댔으면 그 단계에 대고 하는 말로 적어 준다. 모델이
+        // 어느 단계 얘긴지 다시 세어 볼 까닭이 없다.
+        const 고칠말 = 계획답.단계
+          ? `${계획답.단계}단계에 대해: ${계획답.덧말}`
+          : 계획답.덧말;
+        이어갈것 = `계획에서 이걸 고쳐서 **계획만** 다시 내라 (아직 실행하지 마라): ${고칠말}`;
         이어갈모드 = 'plan';
         say('');
-        say(`  ${c.hcyan('☰')} ${c.gray('그 점을 반영해 계획을 다시 냅니다.')}`);
+        say(`  ${c.hcyan('☰')} ${c.gray(계획답.단계
+          ? 옮긴말('plan.replanStep', { 단계: 계획답.단계 })
+          : 옮긴말('plan.replan'))}`);
       }
     } else if (끊긴할일) {
       /*
@@ -2212,7 +2488,12 @@ export async function chatLoop(opts = {}) {
   // 끝맺음은 화면을 접기 **전에** 그린다. close() 가 상자를 걷어내므로,
   // 그 뒤에 찍으면 걷어낸 자리에 뜬금없이 한 줄이 남는다.
   say('');
-  say(`  ${c.gray('끝냅니다.')} ${c.gray(`모델 호출 ${session.usage.calls}회 · 도구 시간 ${(session.usage.ms / 1000).toFixed(1)}초 · ↑${session.usage.in.toLocaleString()} ↓${session.usage.out.toLocaleString()}`)}`);
+  say(`  ${c.gray(옮긴말('run.bye'))} ${c.gray(옮긴말('run.byeStats', {
+    n: session.usage.calls,
+    초: (session.usage.ms / 1000).toFixed(1),
+    입력: session.usage.in.toLocaleString(),
+    출력: session.usage.out.toLocaleString(),
+  }))}`);
   say('');
   화면.close();
   return 0;
@@ -2227,6 +2508,8 @@ export async function chatLoop(opts = {}) {
  */
 function stageTag(ev, level) {
   if (!ev || level === '쉬움') return '';
-  const label = STAGES[ev.stage]?.label ?? ev.stage;
+  // 아는 단계만 표를 거친다. 모르는 것에 말() 을 태우면 못 찾은 열쇠가
+  // 그대로 화면에 찍혀 `stage.xyz 생각 중…` 이 된다.
+  const label = STAGES[ev.stage] ? 옮긴말(`stage.${ev.stage}`) : ev.stage;
   return `${label}·${ev.level}`;
 }