deel-local-cli 1.8.0 → 1.10.0

package/src/repl.js

@@ -22,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';
@@ -39,7 +39,8 @@ 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';
@@ -167,6 +168,22 @@ export async function chatLoop(opts = {}) {
     바로쓰기(`  ${mark.ok} ${잠금}`);
   }
 
+  /*
+   * 잠근 열쇠를 못 풀었으면 **그 까닭을** 적는다.
+   *
+   * 이걸 안 하면 빈 열쇠가 그대로 나가서 Authorization 머리말이 아예 안 붙고,
+   * 사람은 401 만 보고 방화벽·주소·계정을 뒤진다. 진짜 까닭은 대개
+   * 「설정 파일을 다른 PC 로 옮겼다」 이고, 그건 우리만 알고 있다.
+   *
+   * 아래 conn 을 짓는 자리에서 resolveKey 가 불리므로, 읽는 것은 그 뒤여야 한다.
+   */
+  const 열쇠탈보이기 = () => {
+    const 탈 = 열쇠탈소식();
+    if (!탈) return;
+    바로쓰기('');
+    바로쓰기(`  ${mark.warn} ${탈}`);
+  };
+
   /*
    * 여기서부터 화면에 나가는 것은 전부 `화면` 을 거친다.
    *
@@ -207,6 +224,9 @@ export async function chatLoop(opts = {}) {
     vision: prof.vision ?? false,
   };
 
+  // conn 을 짓느라 resolveKey 가 방금 불렸다. 못 푼 것이 있으면 여기서 말한다.
+  열쇠탈보이기();
+
   /*
    * ── 주소와 허가를 뗀다 ───────────────────────────────────────────────
    *
@@ -276,7 +296,9 @@ export async function chatLoop(opts = {}) {
    * 여기서 한 번만 읽는다. 상태줄은 글자를 칠 때마다 다시 그려지는데,
    * 그때마다 설정 파일을 열면 디스크를 초당 수십 번 두드리게 된다.
    */
-  session.요금표 = cfg?.요금 ?? null;
+  // `pricing` 으로 적어도 받는다 — 설정은 사람이 손으로 적는 것이라, 한글
+  // 자판이 없는 사람이 못 적는 이름 하나에 기능이 통째로 막히면 안 된다.
+  session.요금표 = cfg?.요금 ?? cfg?.pricing ?? null;
   session.제공자 = prof?.제공자 ?? null;
 
   /*
@@ -367,7 +389,7 @@ export async function chatLoop(opts = {}) {
    */
   const mcp붙임 = await 다붙이기(root, {
     offline: isOffline(),
-    audit: new Audit(root),
+    audit: new Audit(root, { 열쇠들: 열쇠묻기(conn) }),
   });
 
   // 이 PC 에 있는 스킬·명령·플러그인을 찾아 붙인다. 품고 다니지 않는다.
@@ -612,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(한줄)}`);
@@ -759,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;
@@ -767,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;
@@ -788,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;
       }
@@ -927,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}] `) : ''}`;
     화면.붙임(앞);
@@ -944,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; }
@@ -992,6 +1097,24 @@ export async function chatLoop(opts = {}) {
     }
   };
 
+  /*
+   * 시킨 것 중 자국이 하나도 안 남은 항목을 적는다.
+   *
+   * 조용히 넘어가면 사람은 다 된 줄 알고 그 위에 다음 것을 쌓는다. 나중에
+   * 발견했을 때는 이미 늦다. 「몇 번 까먹거나 누락되거나」라는 제보가 정확히
+   * 그 모양이었다 — 빠진 것 자체보다, 빠졌다는 말을 안 한 것이 문제다.
+   *
+   * 세 자리(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).
@@ -1002,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붙임.서버들,
@@ -1146,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 고른것;
@@ -1164,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 === 'ㅇ';
     },
@@ -1304,7 +1439,7 @@ 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.tools) warn.push(옮긴말('run.noTools'));
   if (!conn.streaming) warn.push(옮긴말('run.noStream'));
   warn.push(...길이경고);
   // 잘 된 것은 경고 표시를 달지 않는다. ⚠ 가 붙으면 뭘 고쳐야 하나 싶어진다.
@@ -1945,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':
@@ -1966,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})`)}`);
@@ -1993,6 +2177,9 @@ export async function chatLoop(opts = {}) {
               if (ev.남은할일.length > 8) say(`    ${c.gray(`… 그 밖에 ${ev.남은할일.length - 8}개`)}`);
             }
             만든파일보이기(ev.files);
+            // 할 일 목록에 못 들어간 채로 빠진 것도 같이 적는다 — 목록에
+            // 없으면 「안 끝난 것」 에도 안 뜨므로 여기서 말 안 하면 아무 데도 없다.
+            빠진것보이기(ev.빠진);
             break;
 
           // 같은 자리를 계속 반복하고 있다. 두면 컨텍스트만 차고 아무것도 안 나온다.
@@ -2016,6 +2203,7 @@ export async function chatLoop(opts = {}) {
             // 멈췄어도 여기까지 만든 것은 있다. 그것부터 알려 준다 —
             // 없는 줄 알고 다시 시키면 앞서 만든 것을 덮어쓴다.
             만든파일보이기(ev.files);
+            빠진것보이기(ev.빠진);
             break;
 
           case 'aborted':
@@ -2034,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;
 
           /*
@@ -2065,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;
         }
       }
@@ -2107,6 +2300,10 @@ 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);
@@ -2148,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 (계획답.갈래 === '진행') {
         /*
          * 승인한 계획을 **글자 그대로 실어 보낸다.**
          *
@@ -2175,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 (끊긴할일) {
       /*

package/src/safety/audit.js

@@ -1,22 +1,106 @@
 // 감사 로그. 무엇을 언제 어떻게 했는지 전부 남긴다.
 // 자율 실행을 사내에 설득할 때 이 파일이 근거가 된다.
 import { join } from 'node:path';
-import { appendFileSync, mkdirSync, existsSync, readFileSync } from 'node:fs';
+import { appendFileSync, mkdirSync, existsSync, readFileSync, chmodSync } from 'node:fs';
+import { 가리기 } from './secrets.js';
+
+/**
+ * 감사기록에 넘길 '아는 열쇠' 를 묻는 길. loop.js 가 대화 쪽에서 쓰는 것과 같은 값이다.
+ * 값이 아니라 길로 주는 까닭은 Audit 만들기 머리말에 적어 뒀다.
+ */
+export const 열쇠묻기 = (conn) => () => [conn?.key, process.env.DEEL_API_KEY].filter(Boolean);
 
 export class Audit {
-  constructor(root) {
+  /**
+   * @param {string} root 작업 폴더
+   * @param {object} o
+   * @param {string[]|(() => string[])} o.열쇠들 정확히 아는 비밀 (설정에 든 게이트웨이 열쇠).
+   *   값이 아니라 **묻는 길**로 받아도 된다 — /model 로 갈아타면 conn 이 통째로
+   *   바뀌므로, 만들 때 붙잡아 둔 값은 그 판이 끝나기 전에 옛것이 된다.
+   */
+  constructor(root, { 열쇠들 = [] } = {}) {
     const dir = join(root, '.deel');
     mkdirSync(dir, { recursive: true });
     this.file = join(dir, 'audit.jsonl');
     this.session = `${new Date().toISOString().slice(0, 19).replace(/[:T]/g, '')}`;
+    /** 적으려다 못 적은 건수와 첫 까닭. 0 이 아니면 이 세션의 기록은 불완전하다. */
+    this.못쓴수 = 0;
+    this.못쓴까닭 = null;
+    this.열쇠들 = 열쇠들;
+    /** 파일 권한을 건 결과. `{모드}` 면 걸었고, `{못함}` 이면 못 걸었다. */
+    this.잠금 = null;
+  }
+
+  /*
+   * ── 적기 전에 가린다 ────────────────────────────────────────────────
+   *
+   * 여기 적히는 target 은 Bash 명령줄 그 자체다. 모델은 열쇠를 헤더로
+   * (`-H "Authorization: Bearer …"`), 환경변수로(`DEEL_API_KEY=… node x`),
+   * 주소 안에 박아서(`https://사람:토큰@github.com/…`) 넘긴다.
+   *
+   * 도구 **결과**는 loop.js 가 secrets.js 로 가려서 대화에 싣는데, 감사기록은
+   * 그 길을 안 지난다. 그래서 대화에서는 지운 값이 디스크에는 평문으로 남았다 —
+   * 그것도 `deel audit` 로 사내 심사 자료에 딸려 나가는 파일에.
+   *
+   * 가리는 것은 자유롭게 적히는 글뿐이다. 도구 이름·성패 같은 정해진 값은
+   * 안 건드린다 — 넓게 잡으면 「무엇을 했는지」 가 «가림» 으로 뭉개진다.
+   */
+  #가린것(값) {
+    if (값 == null) return 값;
+    const 것들 = typeof this.열쇠들 === 'function' ? this.열쇠들() : this.열쇠들;
+    return 가리기(String(값), { 열쇠들: 것들 ?? [] }).글;
   }
 
+  /*
+   * 못 적어도 던지지 않는다 — 기록을 남기려다 작업을 죽이면 본말이 뒤집힌다.
+   *
+   * 다만 **조용히 삼키면 안 된다.** 이 파일의 첫 줄이 파는 문장이
+   * 「무엇을 언제 어떻게 했는지 전부 남는다」 이고, /mcp 화면은 대놓고
+   * `.deel/audit.jsonl 에 남습니다` 라고 적어 준다. 디스크가 차거나 폴더가
+   * 읽기 전용이면 그 두 문장이 거짓이 되는데, 그때도 화면은 아무 말이 없었다.
+   * 더 나쁜 건 증거모으기다 — 기록이 안 적히면 「고쳤는데 확인 안 됨」이
+   * 아니라 아예 **안 고친 것처럼** 보고서가 짧아진다.
+   * 그래서 못 적은 건수를 세어 두고, 보고서와 화면이 그걸 말하게 한다.
+   */
   write(kind, data) {
     const rec = { at: new Date().toISOString(), session: this.session, kind, ...data };
-    try { appendFileSync(this.file, JSON.stringify(rec) + '\n', 'utf8'); } catch {}
+    try {
+      appendFileSync(this.file, JSON.stringify(rec) + '\n', 'utf8');
+      this.#잠그기();
+    } catch (err) {
+      this.못쓴수 += 1;
+      if (!this.못쓴까닭) this.못쓴까닭 = err?.message ?? String(err);
+    }
     return rec;
   }
 
+  /*
+   * 만들자마자 본인만 읽게 잠근다 (config.js 가 설정 파일에 하는 것과 같다).
+   *
+   * 가리기를 지나도 여기에는 무엇을 언제 어디서 했는지가 남는다 — 파일 경로,
+   * 돌린 명령, 사람이 친 말. 같은 PC 를 여럿이 쓰거나 홈이 공유 폴더에 있으면
+   * 그게 그대로 남에게 읽힌다. 한 번만 건다 — 줄마다 걸 일이 아니다.
+   * 윈도우(NTFS)에서는 chmod 가 아무 일도 안 한다. 거기서는 못 잠근 것이지
+   * 잠근 척하지 않는다 — 보관방식 화면이 그 사실을 따로 말한다.
+   *
+   * 건 결과를 `잠금` 에 남긴다. "본인만 읽게 잠근다" 는 말은 지켜지는지
+   * **밖에서 볼 수 있어야** 뜻이 있다 (keystore.js 의 마지막명령줄 과 같은
+   * 까닭). 윈도우에서 값이 남는다고 실제로 잠겼다는 뜻은 아니다 —
+   * 우리가 걸어는 봤다는 뜻이다.
+   */
+  #잠갔나 = false;
+  #잠그기() {
+    if (this.#잠갔나) return;
+    this.#잠갔나 = true;
+    try { chmodSync(this.file, 0o600); this.잠금 = { 모드: 0o600 }; }
+    catch (err) { this.잠금 = { 못함: err?.code ?? String(err) }; }
+  }
+
+  /** 기록이 새고 있나. 새고 있으면 `{수, 까닭}`, 멀쩡하면 null. */
+  못쓴것() {
+    return this.못쓴수 ? { 수: this.못쓴수, 까닭: this.못쓴까닭 } : null;
+  }
+
   tool(name, args, result) {
     return this.write('tool', {
       tool: name,
@@ -24,15 +108,15 @@ export class Audit {
       // '하위 작업을 돌렸다' 만 남고 **무엇을** 돌렸는지가 안 남는다.
       // 옛 이름(목적)도 같이 본다 — 이름을 바꾼 판 이전의 기록이 남아 있고,
       // 옛 이름으로 부르는 모델도 있다.
-      target: args?.file_path ?? args?.path ?? args?.pattern ?? args?.command
-        ?? args?.purpose ?? args?.목적 ?? null,
+      target: this.#가린것(args?.file_path ?? args?.path ?? args?.pattern ?? args?.command
+        ?? args?.purpose ?? args?.목적 ?? null),
       ok: !result?.error,
-      note: result?.error ?? result?.summary ?? null,
+      note: this.#가린것(result?.error ?? result?.summary ?? null),
     });
   }
 
-  turn(text) { return this.write('turn', { text: String(text).slice(0, 500) }); }
-  blocked(why, what) { return this.write('blocked', { why, what: String(what).slice(0, 300) }); }
+  turn(text) { return this.write('turn', { text: this.#가린것(String(text).slice(0, 500)) }); }
+  blocked(why, what) { return this.write('blocked', { why, what: this.#가린것(String(what).slice(0, 300)) }); }
   undo(info) { return this.write('undo', info); }
 
   recent(n = 20) {