deel-local-cli 1.2.0 → 1.4.1

package/src/repl.js

@@ -1,24 +1,31 @@
 // 대화 화면. 루프가 보내는 이벤트를 Claude Code 풍으로 그린다.
 import { createInterface, emitKeypressEvents } from 'node:readline';
 import { homedir } from 'node:os';
-import { resolve } from 'node:path';
+import { resolve, basename } from 'node:path';
 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 { 언어잡기 } from './i18n/index.js';
 import { 화면고르기 } from './ui/screen.js';
 import { STAGES } from './agent/effort.js';
 import { handle, COMMANDS, 미리보기끄기 } from './commands.js';
-import { next as nextWork, get as getWork, canWrite } from './agent/modes.js';
+import { next as nextWork, get as getWork, canWrite, 보일이름, 보일한줄 } from './agent/modes.js';
 import { route } from './agent/route.js';
 import { run } from './agent/loop.js';
 import { Session, repairToolPairs } from './agent/session.js';
 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 { discover } from './skills/discover.js';
-import { allowEndpoint, setOffline, isOffline } from './safety/network.js';
+import { allowEndpoint, setOffline, isOffline, isLocalHost } from './safety/network.js';
 import { Store, latest, prune } from './agent/store.js';
 import { Threads } from './agent/threads.js';
+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';
@@ -160,6 +167,27 @@ export async function chatLoop(opts = {}) {
   allowEndpoint(conn.base);
   if (opts.offline ?? prof.offline) setOffline(true);
 
+  /*
+   * ── 끝났을 때 알리기 ─────────────────────────────────────────────────
+   *
+   * 로컬 모델은 느리다. 7B 를 CPU 로 돌리면 한 턴에 2~3분이 예사고, 그동안
+   * 사람은 다른 창으로 간다. 돌아와 보면 5분 전에 끝나 있거나, 더 나쁘게는
+   * "실행할까요?" 에서 3분째 멈춰 서 있다 — 물어본 줄을 몰라서.
+   *
+   * 폴더 이름을 같이 들고 있는다. 창을 여럿 띄워 놓고 쓰는 사람이 많은데
+   * 전부 'deel' 이면 어느 탭이 끝난 건지 알 수가 없다. (ui/notify.js)
+   */
+  const 알림 = { 켬: cfg.bell !== false, 폴더: basename(root) };
+
+  /*
+   * 화면 말을 여기서 한 번 정한다.
+   *
+   * 켤 때 딱 한 번이면 된다 — 그 뒤로는 /lang 이 바꾼다. 환경변수가 설정을
+   * 이긴다. 한 번만 영어로 켜 보려는 사람이 설정을 건드리지 않고
+   * `DEEL_LANG=en deel` 로 할 수 있어야 하기 때문이다. (i18n/index.js)
+   */
+  언어잡기({ cfg });
+
   const session = new Session(conn, {
     root,
     mode: opts.mode ?? 'auto',
@@ -196,6 +224,17 @@ export async function chatLoop(opts = {}) {
           say(`  ${c.gray(`중단된 도구 호출 ${고친것}개를 걷어냈습니다 — 그때 하던 일은 다시 시켜 주세요.`)}`);
         }
       }
+      /*
+       * 못 박아 둔 것도 같이 되살린다 (agent/pins.js).
+       *
+       * 이걸 안 되살리면 '접어도 요약해도 안 지워진다' 가 **껐다 켜는 한 번에**
+       * 거짓이 된다. 사람은 이미 말했다고 믿고 있으니 다시 말하지 않는다.
+       */
+      const 박힌것 = store.못박은것읽기();
+      if (박힌것.length) {
+        session.못박은것 = new 못박기(박힌것);
+        say(`  ${c.gray(`못 박아 둔 것 ${session.못박은것.개수()}개도 그대로 이어 받았습니다 —`)} ${c.cyan('/pin')}`);
+      }
     }
   }
   if (!store) store = new Store(root);
@@ -222,6 +261,14 @@ export async function chatLoop(opts = {}) {
   // 세션도 알아야 한다 — 밖에서 붙인 도구도 스키마가 매 요청에 실린다.
   // 안 세면 컨텍스트가 그만큼 조용히 줄어든다.
   session.mcp = mcp붙임.서버들;
+  /*
+   * 이 자리에 언어 서버가 깔려 있나 (Def·Refs 를 목록에 넣을지).
+   *
+   * 여기서 한 번만 잰다. PATH 훑기와 폴더 훑기라 값이 있고, 세션 도중에
+   * 답이 바뀌지 않는다. 아무것도 안 깔아 준다 — 있으면 쓰고 없으면 없는 대로
+   * Grep·Outline 으로 간다 (lsp/servers.js 머리말).
+   */
+  session.lsp = 언어서버있나(root);
   // 지난 대화에서 정해 둔 것을 들고 시작한다.
   // 기억은 Session 이 켤 때 직접 읽는다 (session.js 생성자) — deel run 도 같은 것을 들고 시작하게.
 
@@ -357,7 +404,7 @@ export async function chatLoop(opts = {}) {
         session.work = nextWork(session.work);
         const w = getWork(session.work);
         화면.입력지움();
-        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))}`
           + (canWrite(session.work) ? '' : `  ${c.green('· 파일을 못 바꿉니다')}`));
         prompt();
         return;
@@ -501,6 +548,8 @@ export async function chatLoop(opts = {}) {
     mcp: mcp붙임.서버들,
     skills: found.skills,
     loadedSkills: new Set(),
+    // 고친 뒤 진단을 볼지. /lsp off 로 끈다 (lsp/diag.js).
+    lsp: { 켬: true },
     ask,
     // 암호는 여기서만 받는다. 받은 값은 도구가 쓰고 버린다 —
     // 설정에도, 세션 기록에도, 감사기록에도, 명령줄에도 안 남는다.
@@ -512,7 +561,15 @@ export async function chatLoop(opts = {}) {
     confirm: async (name, args) => {
       say('');
       say(`  ${c.yellow('?')} ${toolLabel(name, args)}`);
+      /*
+       * 여기서 종을 울린다. 끝난 것은 늦게 알아도 되지만 **막혀 있는 것은**
+       * 기다린 만큼 그대로 손해다 — 다른 창에 가 있는 사이 3분째 이 줄에서
+       * 멈춰 서 있는 일이 실제로 잦다. 시간 문턱도 안 본다, 0초여도 알린다.
+       */
+      if (알릴까({ 물어봄: true, 켬: 알림.켬 })) 종();
+      창제목(제목글('물어봄', { 폴더: 알림.폴더 }));
       const a = (await ask('실행할까요? (y/n)', { def: 'y' })).toLowerCase();
+      창제목(제목글('도는중', { 폴더: 알림.폴더 }));
       return a === 'y' || a === 'yes' || a === 'ㅇ';
     },
   };
@@ -531,6 +588,22 @@ export async function chatLoop(opts = {}) {
   const 아는배수 = ctx.배움.아는보정(conn.model);
   if (아는배수) { session.보정 = 아는배수; session.보정잰것 = 1; }
 
+  /*
+   * 모델 카드 (agent/card.js).
+   *
+   * 겪어 본 버릇을 **하네스 설정으로** 바꾼다. 프롬프트에 "이렇게 해라" 고 적는
+   * 것과 다르다 — 작은 모델은 그 말을 잘 안 듣는다. 여기서 바꾸는 것은 deel 의
+   * 행동이라 모델의 협조가 필요 없다.
+   *
+   * 턴마다 다시 만든다. 이번 대화에서 겪는 것이 계속 쌓이므로, 켤 때 한 번
+   * 만들어 두면 그 뒤에 알아낸 것이 이번 대화에서는 안 쓰인다.
+   */
+  ctx.카드다시 = () => {
+    ctx.카드 = 카드(conn.model, session.본것, ctx.배움?.현황(conn.model)?.모델);
+    return ctx.카드;
+  };
+  ctx.카드다시();
+
   /*
    * 대화 갈래. 연결·도구·되돌리기는 같이 쓰고 오간 말만 여러 벌 갖는다.
    * 갈래마다 저장 파일을 따로 열어서, 나중에 `/sessions` 로 각각 찾아갈 수 있다.
@@ -585,6 +658,26 @@ export async function chatLoop(opts = {}) {
     }
   }
 
+  /*
+   * ── 켤 때 도는 글자 모션 ──────────────────────────────────────────────
+   *
+   * 사람은 `deel` 이라고 치고 들어온다. 그 글자가 그 자리에서 deel-local 로
+   * 자라고, 아래로 선이 그어지며 닫힌다. 꾸미기만은 아니다 — 이 프로그램이
+   * 하는 말이 딱 하나인데(소스가 이 컴퓨터 밖으로 안 나간다) 그 말을 켜는
+   * 첫 1초에 그림으로 한 번 하는 것이다. 바깥 게이트웨이면 같은 선이 노랗게
+   * 그어진다. 그러면 사람이 그 자리에서 안다.
+   *
+   * 여기서 도는 이유는 **연결이 정해진 다음**이라야 색을 제대로 칠하기
+   * 때문이다. 더 일찍 돌면 초록으로 그려 놓고 나중에 바깥이었다고 정정하는
+   * 꼴이 되는데, 그건 안 보여 주느니만 못하다.
+   */
+  {
+    let 바깥 = false;
+    try { 바깥 = !isLocalHost(new URL(conn.base).hostname); } catch { 바깥 = false; }
+    say('');
+    await 인트로({ 바깥, 곁말: 기본곁말(바깥), 쓰기: (t) => process.stdout.write(t) });
+  }
+
   // ── 머리말 ────────────────────────────────────────────────────────────
   화면.머리말(headerLines(session, found));
   const warn = [];
@@ -760,7 +853,7 @@ export async function chatLoop(opts = {}) {
         계획승인받나 = 골라진.겹침 === true;
         const w = getWork(골라진.mode);
         say('');
-        say(`  ${c.hcyan(w.glyph)} ${c.bold(w.name)} ${c.gray('(' + w.en + ')')}`
+        say(`  ${c.hcyan(w.glyph)} ${c.bold(보일이름(w.id))} ${c.gray('(' + w.en + ')')}`
           + `  ${c.gray('말 속에 ' + 골라진.why + ' 가 있어서')}`
           + (canWrite(골라진.mode) ? '' : `  ${c.green('· 파일은 안 바꿉니다')}`));
         // 겹친 요청은 '파일을 안 바꾼다' 로 끝나면 안 된다. 시킨 일의 절반만 한 것이다.
@@ -778,6 +871,20 @@ export async function chatLoop(opts = {}) {
     const started = Date.now();
     const before = { in: session.usage.in, out: session.usage.out };
 
+    /*
+     * 창 제목에 흐른 시간을 띄운다. 탭 이름만 봐도 도는 중인지 알게 하려는 것이다.
+     *
+     * 화면에 보이는 글자를 건드리지 않는다 — OSC 는 커서를 안 옮기고 아무것도
+     * 안 찍으므로, 한창 그리는 중에 끼어들어도 화면이 깨지지 않는다.
+     * unref 를 거는 이유는, 이 시계 하나 때문에 프로그램이 안 꺼지면 안 되기 때문이다.
+     */
+    창제목(제목글('도는중', { 폴더: 알림.폴더, 초: 0 }));
+    const 제목시계 = setInterval(
+      () => 창제목(제목글('도는중', { 폴더: 알림.폴더, 초: (Date.now() - started) / 1000 })),
+      1000,
+    );
+    제목시계.unref?.();
+
     // 어디까지 적었는지. 도중에 죽어도 여기까지는 남아 있게 자주 흘려 보낸다.
     let saved = session.messages.length;
     const flush = () => {
@@ -822,6 +929,9 @@ export async function chatLoop(opts = {}) {
      * 그렇게 날아간다. 테두리를 그대로 두고 안엣것만 바꾸는 이유다.
      */
     화면.일시작(session, '생각');
+    // 이번 턴에 쓸 카드를 지금 만든다. 앞 턴에서 겪은 것까지 반영돼야
+    // '겪을수록 나아진다' 가 이번 대화 안에서도 참이 된다.
+    ctx.카드다시?.();
     try {
       for await (const ev of run(session, ctx, 보낼글, { signal: turn.signal })) {
         /*
@@ -928,6 +1038,19 @@ export async function chatLoop(opts = {}) {
               }
             } else {
               say(`    ${toolResultLine(ev.result, ev.ms ?? 0)}`);
+              /*
+               * 비밀이 지나갔으면 반드시 말한다.
+               *
+               * 가렸으면 가렸다고, 못 가렸으면 못 가렸다고 적는다. 파일에서
+               * 읽어 온 글은 일부러 안 가린다 — 가리면 모델이 그 가린 글을
+               * 되돌려 써서 진짜 열쇠가 지워진다. 대신 사람에게 알린다.
+               * 조용히 넘어가면 사람은 제 열쇠가 대화에 들어간 줄을 모른다.
+               */
+              if (ev.비밀) {
+                say(ev.비밀.가렸나
+                  ? `      ${c.gray(`⊘ ${ev.비밀.말} — 모델에 가려서 보냈습니다`)}`
+                  : `      ${c.yellow('!')} ${c.yellow(ev.비밀.말)} ${c.gray('— 파일 내용은 가리지 않습니다 (가리면 되돌려 쓸 때 지워집니다)')}`);
+              }
               /*
                * 파일을 바꾸는 명령이었으면, 무엇을 떠 뒀는지 적는다.
                *
@@ -935,6 +1058,18 @@ export async function chatLoop(opts = {}) {
                * 수 있는지 없는지 알 길이 없어서, 사람은 되돌릴 수 있는 줄 알고
                * 넘어가거나 반대로 못 되돌리는 줄 알고 겁을 낸다. 사실을 적는다.
                */
+              /*
+               * 확인한 것을 센다. 상태줄이 이 숫자를 본다.
+               *
+               * 모델이 "다 됐습니다" 로 답을 맺는 것과 **실제로 돌려 본 것**은
+               * 다른 일이다. 화면에 초록 ✓ 가 없으면 아직 아무도 안 돌려 본
+               * 것이고, 그 구분이 상태줄에 있어야 사람이 속지 않는다.
+               */
+              if (ev.name === 'Verify' && ev.result) {
+                session.검증.돈횟수 += 1;
+                session.검증.확인 += ev.result.확인됨 ?? 0;
+                session.검증.탈 += ev.result.탈 ?? 0;
+              }
               if (ev.result?.되돌릴것?.length) {
                 const 것들 = ev.result.되돌릴것;
                 say(`      ${c.gray(`↩ ${것들.slice(0, 3).join(' · ')}${것들.length > 3 ? ` 외 ${것들.length - 3}개` : ''} 는 떠 뒀습니다 — /undo 로 되돌아갑니다`)}`);
@@ -996,8 +1131,20 @@ export async function chatLoop(opts = {}) {
             화면.일바꿈('하위', clip(ev.목적, 24));
             say('');
             say(`  ${c.hmagenta('⌥')} ${c.bold('하위 작업')} ${c.white(clip(ev.목적, 60))}`
-              + ` ${c.gray(`· ${getWork(ev.모드).name} · 최대 ${ev.steps}걸음`)}`);
+              + ` ${c.gray(`· ${보일이름(ev.모드)} · 최대 ${ev.steps}걸음`)}`);
             say(`  ${c.gray('여기서부터는 따로 떨어진 대화입니다 — 결과 요약만 위로 올라옵니다.')}`);
+            /*
+             * 다른 모델에게 떼어 줬으면 여기서 말한다.
+             *
+             * 상태줄의 ⌂ 는 이 세션의 연결을 보고 있어서 하위가 딴 데로
+             * 나가는 것을 모른다. 이 줄이 그 사실을 남기는 유일한 자리다.
+             * 바깥으로 나가면 노랗게 — 그냥 지나칠 수 없게.
+             */
+            if (ev.모델) {
+              say(ev.밖으로
+                ? `  ${c.hyellow('↗')} ${c.hyellow(ev.모델)} ${c.gray('— 이 덩이는 바깥으로 나갑니다')}`
+                : `  ${c.hgreen('⌂')} ${c.gray(`${ev.모델} — 이 컴퓨터 안입니다`)}`);
+            }
             break;
 
           case 'task_done': {
@@ -1010,7 +1157,7 @@ export async function chatLoop(opts = {}) {
               aborted: '중단했습니다' }[끝.type] ?? '끝난 이유를 알 수 없습니다';
             say('');
             say(`  ${잘됨 ? c.green('✓') : c.yellow('⚠')} ${c.gray('하위 작업')} ${c.white(clip(ev.목적, 50))}`
-              + ` ${c.gray(`— ${왜}`)} ${c.gray(`(${끝.steps ?? 0}걸음)`)}`);
+              + ` ${c.gray(`— ${왜}`)} ${c.gray(`(${끝.steps ?? 0}걸음${ev.모델 ? ` · ${ev.모델}` : ''})`)}`);
             // 무엇이 실제로 생겼는지는 하위가 한 말이 아니라 디스크가 말한다.
             만든파일보이기(끝.files);
             if (끝.why) say(`  ${c.gray(`막힌 데: ${clip(끝.why, 80)}`)}`);
@@ -1041,11 +1188,25 @@ export async function chatLoop(opts = {}) {
            * 요약 압축보다 먼저 오는 것. 대화는 안 건드리고 옛 도구 결과만 접었다.
            * 조용히 하면 사람은 어느 파일 내용이 왜 사라졌는지 모른다 — 한 줄로 알린다.
            */
-          case 'folded':
+          case 'folded': {
             clearThinking();
             say(`  ${c.cyan('◲')} ${c.gray(`오래된 도구 결과 ${ev.접은것}개를 접었습니다 — `)}`
               + `${c.white(ev.아낀토큰.toLocaleString())} ${c.gray('토큰을 비웠습니다. 대화는 그대로입니다.')}`);
+            /*
+             * 무엇을 접었는지 이름으로 보여 준다.
+             *
+             * 조용히 버리면 "아까 그 파일 내용 어디 갔지" 를 사람이 스스로 답할 수
+             * 없다. 개발자 수준에서만 편다 — 쉬움 수준에서는 숫자 한 줄이면 된다.
+             */
+            const 접은것들 = ev.접은것들 ?? [];
+            if (접은것들.length && session.level !== '쉬움') {
+              const 보일것 = 접은것들.slice(0, 4)
+                .map((x) => `${x.도구}${x.곳 ? `(${x.곳})` : ''}`).join(' · ');
+              const 남은수 = 접은것들.length - Math.min(4, 접은것들.length);
+              say(`    ${c.gray(`${보일것}${남은수 > 0 ? ` 외 ${남은수}개` : ''}`)}`);
+            }
             break;
+          }
 
           case 'compacted': {
             접기멈춤();
@@ -1156,6 +1317,22 @@ export async function chatLoop(opts = {}) {
     // 어떻게 끝났든 일하는 표시는 반드시 걷는다. 오류로 빠져나온 길에서
     // 안 걷으면 돌아가는 표시가 화면에 붙박이로 남고, 시계도 계속 돈다.
     화면.일끝();
+    clearInterval(제목시계);
+    /*
+     * 오래 걸린 턴만 알린다. "안녕" 에 1초 만에 답할 때마다 딩 소리가 나면
+     * 사람은 이틀 만에 알림을 꺼 버리고, 그러면 정작 3분짜리 턴도 못 듣는다.
+     * 알림은 아껴 써야 알림이다. (문턱은 ui/notify.js 의 알릴만한초)
+     */
+    /*
+     * 되돌릴 수 있는 턴 수를 여기서 한 번 센다.
+     *
+     * 상태줄이 직접 세게 하면 안 된다 — 상태줄은 사람이 글자 하나 칠 때마다
+     * 다시 그려지고, 거기서 이력 파일을 열면 타이핑이 끊긴다. 턴 경계에서
+     * 한 번 세어 두면 화면은 그 숫자만 읽으면 된다.
+     */
+    try { session.되돌릴턴 = ctx.history.turns().length; } catch { /* 못 세면 그냥 둔다 */ }
+    if (알릴까({ 걸린밀리초: Date.now() - started, 켬: 알림.켬 })) 종();
+    창제목(제목글(턴탈났나 ? '탈남' : '끝남', { 폴더: 알림.폴더 }));
     turn = null;
     interrupted = false;   // 중단은 '끝내기' 의사가 아니다. 종료 카운트를 되돌린다.
     flush();               // 오류로 끝났어도 여기까지는 남긴다
@@ -1185,6 +1362,9 @@ export async function chatLoop(opts = {}) {
       say('');
       계획상자(할일);
       say('');
+      // 계획을 다 내놓고 사람 답을 기다리는 자리다. 위 confirm 과 같은 이유로 알린다.
+      if (알릴까({ 물어봄: true, 켬: 알림.켬 })) 종();
+      창제목(제목글('물어봄', { 폴더: 알림.폴더 }));
       const 답 = String(await ask(
         `이대로 진행할까요? ${c.gray('⏎ 진행 · n 취소 · 그 밖엔 고칠 점')}`,
         { def: 'y' },
@@ -1211,9 +1391,14 @@ export async function chatLoop(opts = {}) {
   }
 
   rl.close();
+  // 남의 터미널을 우리 이름으로 두고 나가지 않는다. 켤 때 있던 제목으로 돌려놓는다.
+  제목되돌리기();
   // 띄운 남의 프로세스는 반드시 거둔다. 안 거두면 deel 을 껐는데도
   // 그 서버가 계속 돌고 있게 된다 — 사람 눈에는 안 보이는 채로.
   for (const s of mcp붙임.서버들) s.닫기();
+  // 언어 서버도 같이 거둔다. 이건 사람 눈에 안 보이는 채로 메모리를 몇백 MB
+  // 물고 있는 종류라, 남겨 두면 나중에 작업 관리자를 열기 전에는 모른다.
+  언어서버다끄기().catch(() => {});
   // 뒤에서 돌던 명령도 같이 거둔다. 이걸 조용히 하면 안 된다 —
   // 사람은 dev 서버가 아직 떠 있다고 여기고 브라우저를 새로 고치다가
   // "왜 안 되지" 로 시간을 쓴다. 몇 개를 껐는지 말해 준다.

package/src/safety/secrets.js

@@ -0,0 +1,205 @@
+// 비밀이 모델에게, 그리고 디스크에 남는 대화 기록에 끼어드는 것을 막는다.
+//
+// ── 어디서 새나 ────────────────────────────────────────────────────────
+//
+// 사람이 열쇠를 붙여 넣는 일은 드물다. 새는 자리는 거의 항상 **명령 출력**이다.
+//
+//   env · printenv · set              환경변수를 통째로 찍는다
+//   git remote -v                     https://사람:토큰@github.com/... 이 그대로
+//   docker inspect · kubectl get -o   설정에 박힌 열쇠가 그대로
+//   curl -v                           Authorization 헤더가 그대로
+//   검사 실패 로그                     연결 문자열이 통째로
+//
+// 이게 왜 문제인가. 그 글은 모델에게 실려 가고 — 사내 게이트웨이라 해도
+// 그쪽 로그에 남는다 — 동시에 `.deel/sessions/*.jsonl` 로 디스크에 적힌다.
+// 그 파일은 나중에 `/recall` 로 다시 읽히고, `deel pack` 에 딸려 갈 수도 있다.
+// 한 번 새면 여러 벌이 된다.
+//
+// ── 파일 내용은 안 가린다 ───────────────────────────────────────────────
+//
+// 여기서 제일 중요한 결정이다. **읽은 파일은 손대지 않는다.**
+//
+// 가리고 싶은 마음이 드는 자리가 바로 `.env` 인데, 거기를 가리면 이렇게 된다 —
+// 모델이 가려진 글을 보고, 그걸 고쳐서 Write 로 되돌려 쓴다. 그러면 진짜
+// 열쇠가 있던 자리에 `«가림»` 이 적힌다. **사람의 열쇠가 우리 손에 지워진다.**
+// 비밀을 지키려다 비밀을 파괴하는 셈이다.
+//
+// 그래서 파일 쪽은 가리는 대신 **알린다** — 감사기록에 남기고 화면에 띄운다.
+// 무엇을 못 막는지 분명히 말하는 편이, 막았다고 해 놓고 파일을 망가뜨리는 것보다
+// 언제나 낫다.
+//
+// 가리는 것은 **한 번 쓰고 버려지는 출력**뿐이다. 명령 출력·웹에서 받아온 글은
+// 모델이 그대로 되돌려 쓸 일이 없다.
+
+/** 가려진 자리에 남는 표. 종류를 같이 적어 무엇이 가려졌는지 알 수 있게 한다. */
+const 표 = (종류) => `«가림:${종류}»`;
+
+/**
+ * 찾는 것들.
+ *
+ * 순서가 뜻을 갖는다 — 좁은 것을 먼저 본다. `sk-ant-...` 를 `sk-...` 가 먼저
+ * 집어삼키면 무엇이 가려졌는지가 뭉개진다.
+ *
+ * 넓게 잡지 않는다. 코드에 흔한 글자를 비밀로 오인해 가려 버리면, 모델이 보는
+ * 코드가 조용히 달라진다. 그건 여기서 막으려는 것보다 더 나쁜 고장이다.
+ */
+export const 갈래 = [
+  {
+    id: '사설키',
+    re: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+  },
+  { id: 'anthropic', re: /\bsk-ant-[A-Za-z0-9_-]{16,}/g },
+  { id: 'openai', re: /\bsk-[A-Za-z0-9_-]{20,}/g },
+  { id: 'github', re: /\b(?:gh[pousr]_[A-Za-z0-9]{16,}|github_pat_[A-Za-z0-9_]{20,})\b/g },
+  { id: 'slack', re: /\bxox[baprs]-[A-Za-z0-9-]{10,}/g },
+  { id: 'aws', re: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g },
+  { id: 'google', re: /\bAIza[0-9A-Za-z_-]{35}\b/g },
+  {
+    // 머리.몸통.서명 세 토막. 안에 무엇이 들었는지 우리는 안 열어 본다.
+    id: 'jwt',
+    re: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g,
+  },
+  {
+    // https://사람:토큰@호스트 — git remote -v 가 이 모양으로 찍는다.
+    // 사람 이름은 남긴다. 무슨 계정인지 모르면 사람이 손을 못 쓴다.
+    id: '주소속열쇠',
+    re: /([a-z][a-z0-9+.-]*:\/\/)([^\s/:@]{1,64}):([^\s/@]{1,256})@/gi,
+    바꾸기: (m, 앞, 사람) => `${앞}${사람}:${표('주소속열쇠')}@`,
+  },
+  {
+    /*
+     * 줄 끝까지 가린다.
+     *
+     * `Authorization: Bearer eyJ…` 에서 `\S+` 만 잡으면 'Bearer' 만 가려지고
+     * 진짜 값은 그 뒤에 그대로 남는다. 앞의 낱말을 가리고 뒤의 열쇠를 남기는
+     * 것은 안 가린 것만 못하다 — 가렸다고 믿게 만들기 때문이다.
+     *
+     * 이미 가린 자리는 다시 안 건드린다. 두 번 가리면 무엇이 가려졌는지가
+     * 뭉개지고 셈도 부풀려진다.
+     */
+    id: '헤더',
+    re: /\b(Authorization|Proxy-Authorization|X-Api-Key|Api-Key|X-Auth-Token)(\s*[:=]\s*)(?!«)([^\r\n]+)/gi,
+    바꾸기: (m, 이름, 사이) => `${이름}${사이}${표('헤더')}`,
+  },
+  {
+    /*
+     * 이름이 열쇠라고 말하는 환경변수.
+     *
+     * 값이 비었거나 이미 가려진 것은 그냥 둔다 — `API_KEY=` 만 있는 줄까지
+     * 손대면 화면에 «가림» 만 늘어나고 알아볼 것이 없어진다.
+     */
+    id: '환경변수',
+    re: /\b([A-Z][A-Z0-9_]{2,}(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|PWD|CREDENTIALS?))(\s*[:=]\s*)(["']?)(?!«)([^\s"']{4,})\3/g,
+    바꾸기: (m, 이름, 사이) => `${이름}${사이}${표('환경변수')}`,
+  },
+];
+
+/**
+ * 안 고치고 세기만 한다.
+ *
+ * 파일을 읽었을 때 쓰는 길이다. 무엇이 들어왔는지는 알려야 하고, 글자는
+ * 건드리면 안 된다.
+ *
+ * @returns {Array<{종류: string, 몇번: number}>}
+ */
+export function 훑기(글, { 열쇠들 = [] } = {}) {
+  /*
+   * 가려 보고 그 결과만 센다. 글은 안 돌려준다.
+   *
+   * 세는 길을 따로 두면 두 벌이 되고, 두 벌은 언젠가 어긋난다 — "가릴 때는
+   * 3군데였는데 셀 때는 5군데" 같은 식으로. 겹치는 규칙 때문에 실제로 그렇게
+   * 된다. 한 길로만 간다.
+   */
+  return 가리기(글, { 열쇠들 }).가린것;
+}
+
+/**
+ * 가린다.
+ *
+ * @param {string} 글
+ * @param {object} o
+ * @param {string[]} o.열쇠들  정확히 아는 비밀 (설정에 든 게이트웨이 열쇠 등).
+ *                             이건 짐작이 아니라 아는 값이라 언제나 먼저 지운다.
+ * @returns {{글: string, 가린것: Array<{종류, 몇번}>}}
+ */
+export function 가리기(글, { 열쇠들 = [] } = {}) {
+  const 원본 = String(글 ?? '');
+  if (!원본) return { 글: 원본, 가린것: [] };
+
+  let s = 원본;
+
+  // 아는 값부터. 짐작보다 아는 것이 먼저다.
+  for (const 열쇠 of 아는열쇠(열쇠들)) {
+    if (s.includes(열쇠)) s = s.split(열쇠).join(표('설정한열쇠'));
+  }
+
+  for (const g of 갈래) {
+    g.re.lastIndex = 0;
+    s = s.replace(g.re, (...인자) => (g.바꾸기 ? g.바꾸기(...인자) : 표(g.id)));
+  }
+
+  return { 글: s, 가린것: 남은표세기(s) };
+}
+
+/*
+ * 몇 군데를 가렸는지는 **결과를 보고** 센다. 바꾼 횟수를 세면 안 된다.
+ *
+ * 규칙끼리 겹치기 때문이다 — `Authorization: Bearer eyJ…` 는 jwt 가 먼저
+ * 가리고 헤더가 그 위를 다시 가린다. 바꾼 횟수로 세면 "2군데를 가렸습니다"
+ * 가 되는데 글에는 표가 하나뿐이다. 사람이 세어 보면 안 맞는다.
+ */
+function 남은표세기(글) {
+  const 센것 = new Map();
+  for (const m of String(글).matchAll(/«가림:([^»]+)»/g)) {
+    센것.set(m[1], (센것.get(m[1]) ?? 0) + 1);
+  }
+  return [...센것].map(([종류, 몇번]) => ({ 종류, 몇번 }));
+}
+
+/**
+ * 모델에게 붙일 한마디.
+ *
+ * 표만 남기고 말이 없으면 모델은 «가림:openai» 를 진짜 값으로 알고 그걸
+ * 명령에 다시 써 넣는다. 그러면 명령이 실패하고, 왜 실패했는지 모른 채
+ * 같은 것을 되풀이한다. 한 줄이면 그 고리가 안 생긴다.
+ */
+export function 가렸다는말(가린것) {
+  if (!가린것?.length) return '';
+  const 셈 = 가린것.reduce((a, x) => a + x.몇번, 0);
+  const 종류 = 가린것.map((x) => x.종류).join(' · ');
+  return `\n\n(deel 이 이 출력에서 비밀로 보이는 값 ${셈}군데를 가렸습니다: ${종류}.`
+    + ' 「«가림:…»」 은 진짜 값이 아닙니다 — 명령에 그대로 써 넣지 마세요.'
+    + ' 그 값이 꼭 필요하면 사용자에게 물어보세요.)';
+}
+
+/** 사람에게 보일 한 줄. 파일 쪽에서는 이것만 하고 글은 안 건드린다. */
+export function 봤다는말(가린것) {
+  if (!가린것?.length) return '';
+  const 셈 = 가린것.reduce((a, x) => a + x.몇번, 0);
+  return `비밀로 보이는 값 ${셈}군데가 대화에 들어갔습니다 (${가린것.map((x) => x.종류).join(' · ')})`;
+}
+
+/**
+ * 지금 설정에서 '정확히 아는 비밀' 을 모은다.
+ *
+ * 짧은 것은 뺀다. 세 글자짜리 열쇠를 그대로 찾아 지우면 멀쩡한 글에서
+ * 그 세 글자가 든 자리가 전부 뭉개진다 — 열쇠가 'test' 인 시험 설정에서
+ * 실제로 그럴 수 있다.
+ */
+export function 아는열쇠(것들) {
+  const out = [];
+  for (const v of Array.isArray(것들) ? 것들 : [것들]) {
+    const s = typeof v === 'string' ? v.trim() : '';
+    if (s.length >= 8 && !out.includes(s)) out.push(s);
+  }
+  // 긴 것부터 지운다. 짧은 것이 긴 것의 일부일 때 순서가 뒤바뀌면 반쪽만 지워진다.
+  return out.sort((a, b) => b.length - a.length);
+}
+
+/**
+ * 이 도구의 결과를 가려도 되는가.
+ *
+ * 한 번 쓰고 버려지는 출력만 가린다. 파일에서 읽어 온 글은 모델이 그대로
+ * 되돌려 쓸 수 있으므로 절대 안 가린다 — 위 머리말 참고.
+ */
+export const 가릴도구 = new Set(['Bash', 'Verify', 'Jobs', 'WebFetch']);

package/src/safety/undo.js

@@ -131,11 +131,18 @@ export class History {
     return seen;
   }
 
-  // 최근 n 개 턴을 되돌린다. 되돌린 파일 목록을 반환.
+  /**
+   * 최근 n 개 턴을 되돌린다. 되돌린 파일 목록을 반환.
+   *
+   * turnIds 를 같이 준다 — **어느** 턴을 되돌렸는지 부르는 쪽이 알아야 한다.
+   * 파일만 되돌리고 대화는 그대로 두면, 모델은 지워진 코드가 아직 있는 줄 알고
+   * 그 위에 이어서 일한다. 그 거짓말을 걷어내려면 개수가 아니라 번호가 필요하다.
+   * (session.되감기 를 볼 것.)
+   */
   undo(n = 1) {
     const recs = this.all();
     const turns = this.turns().slice(-n);
-    if (!turns.length) return { restored: [], turns: 0 };
+    if (!turns.length) return { restored: [], turns: 0, turnIds: [] };
 
     const target = recs.filter((r) => turns.includes(r.turn));
     // 같은 파일이 여러 번 바뀌었으면 가장 이른 상태로 되돌려야 한다.
@@ -173,7 +180,7 @@ export class History {
     // 되돌린 기록은 잘라낸다.
     const keep = recs.filter((r) => !turns.includes(r.turn));
     writeFileSync(this.file, keep.map((r) => JSON.stringify(r)).join('\n') + (keep.length ? '\n' : ''), 'utf8');
-    return { restored, turns: turns.length };
+    return { restored, turns: turns.length, turnIds: turns.slice() };
   }
 }