deel-local-cli 1.20.10 → 1.20.11

package/src/agent/threads.js

@@ -68,8 +68,53 @@ export class Threads {
     }];
     this.자리 = 0;
     this.센것 = 1;
+    /*
+     * ── 닫은 갈래가 **쓴 돈**은 어디로 가나 ────────────────────────
+     *
+     * 여태 아무 데도 안 갔다. 닫기() 는 갈래를 splice 로 빼기만 했고,
+     * 그 갈래가 태운 토큰·호출·시간은 그 자리에서 사라졌다. 곁가지에서
+     * 오래 헤매다 닫고 본줄기로 돌아오면 `/cost` 는 그 값을 못 본다 —
+     * **실제로 낸 돈보다 적은 금액**이 화면에 뜬다.
+     *
+     * 갈래를 지운다고 청구서가 지워지지는 않는다. 그래서 여기에 쌓는다.
+     */
+    this.닫힌셈 = { in: 0, out: 0, prompt: 0, calls: 0, ms: 0, retries: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, 못잰것: 0 };
+    this.닫힌수 = 0;
+  }
+
+  /**
+   * **모든 갈래**가 지금까지 쓴 것을 합친다. 닫은 갈래 것까지 센다.
+   *
+   * `/cost` 가 session.usage 하나만 보고 있었다. 그건 지금 갈래 것이다.
+   * 갈래를 셋 굴리면 화면의 금액은 그중 하나 몫이고, 갈래를 바꾸는
+   * 것만으로 숫자가 내려간다 — 돈은 그대로 나가는데.
+   *
+   * 지금 갈래 값은 **session 쪽**에서 가져온다.
+   *
+   * 처음에 여기 「갈래 표에 담긴 것은 마지막으로 옮길 때 담아 둔 값이라
+   * 이번 턴 것이 빠져 있다」 라고 적어 뒀는데, **그건 사실이 아니다.**
+   * #꺼내기() 가 `session.usage = g.usage` 로 **같은 객체를 물려** 주고,
+   * session 쪽에서 그 객체를 갈아 끼우는 자리는 생성자 말고는 없다.
+   * 그러니 지금은 둘이 늘 같은 값이다 — 어긋내기 판이 이 줄을 표 쪽으로
+   * 바꿔도 검사가 안 빨개져서 그걸로 알았다.
+   *
+   * 그래도 session 쪽을 읽는다. 언젠가 누가 usage 를 통째로 갈아 끼우면
+   * (되감기·이어받기가 그럴 만한 자리다) 표 쪽만 읽는 코드는 그 순간부터
+   * 조용히 적은 금액을 적는다. 값을 두 군데서 들고 있을 때는 **살아 있는
+   * 쪽**을 읽는 것이 맞다.
+   */
+  전체usage() {
+    const 합 = { ...this.닫힌셈 };
+    for (let i = 0; i < this.갈래들.length; i++) {
+      const u = (i === this.자리 ? this.session.usage : this.갈래들[i].usage) ?? {};
+      for (const k of Object.keys(합)) 합[k] += Number(u[k] ?? 0);
+    }
+    return 합;
   }
 
+  /** 지금 갈래 것과 전부의 것이 다른가. 다를 때만 화면에 두 줄이 필요하다. */
+  갈래여럿인가() { return this.갈래들.length > 1 || this.닫힌수 > 0; }
+
   현재() { return this.갈래들[this.자리]; }
   현재store() { return this.현재().store; }
   개수() { return this.갈래들.length; }
@@ -128,7 +173,10 @@ export class Threads {
     const g = {
       이름: String(이름 ?? '').trim() || 기본이름(this.센것),
       messages: 물려줄것 ? [...물려줄것] : [],
-      usage: { in: 0, out: 0, calls: 0, ms: 0, retries: 0 },
+      // session.usage 와 **같은 모양**이어야 한다. 여태 다섯 칸만 있어서
+      // 갈래에서는 캐시·생각·못잰것 칸이 아예 없었다. 더하는 자리들이 전부
+      // `?? 0` 을 써서 터지지는 않았지만, 모양이 둘인 것 자체가 다음 사람의 함정이다.
+      usage: { in: 0, out: 0, prompt: 0, calls: 0, ms: 0, retries: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, 못잰것: 0 },
       todos: null,
       // 할 일도 todos 와 같이 비워서 시작한다. 곁가지는 다른 일을 하러 나가는
       // 것이고, 물려받으면 본줄기의 남은 일을 곁가지 파일에도 적게 된다.
@@ -191,6 +239,9 @@ export class Threads {
     if (i < 0) return { ok: false, why: '그런 갈래가 없습니다.' };
     if (i === this.자리) this.#담아두기();
     const [닫은것] = this.갈래들.splice(i, 1);
+    // 갈래는 지워도 그 갈래가 낸 돈은 안 지워진다 (생성자의 닫힌셈).
+    for (const k of Object.keys(this.닫힌셈)) this.닫힌셈[k] += Number(닫은것.usage?.[k] ?? 0);
+    this.닫힌수 += 1;
     // 닫힌 자리보다 뒤에 있었으면 번호가 하나 당겨진다.
     const 다음 = i === this.자리 ? Math.max(0, i - 1) : (this.자리 > i ? this.자리 - 1 : this.자리);
     this.자리 = 다음;

package/src/commands.js

@@ -42,7 +42,7 @@ import { 보고서적기 } from './ui/export.js';
 import { loadCommand, discover } from './skills/discover.js';
 import { install, list, remove, pack } from './plugins/manage.js';
 import { spin } from './ui/spinner.js';
-import { 그림고르기설정, 끔설정 } from './ui/motion.js';
+import { 그림고르기설정, 끔설정, 환경그림, 환경으로껐나 } from './ui/motion.js';
 import { 사무실설정, 최소높이, 최소폭 } from './ui/office.js';
 
 /**
@@ -63,6 +63,28 @@ export function 적용하기(고른것) {
   // 지워 버리면, 껐다고 믿는 자리에서 그림이 다시 돈다. 설정용 값은 따로 둔다.
   끔설정(값 === '끔');
 }
+
+/**
+ * `/motion` 이 환경변수에 대해 해야 하는 말. 없으면 빈 배열.
+ *
+ * 여태 이 자리는 「DEEL_MOTION·DEEL_OFFICE 가 켜져 있으면 그쪽이 이깁니다」
+ * 한 줄이 전부였다. 그래서 두 가지를 틀리게 말했다.
+ *
+ *   · **DEEL_NO_MOTION 을 통째로 안 봤다.** 그게 켜져 있으면 무엇을 골라도
+ *     한 칸짜리 돌림표가 도는데, 화면은 「기사로 바꿨습니다 · 그 자리에서
+ *     바뀝니다」 라고 말한다. 아무것도 안 바뀐다.
+ *   · **모르는 값도 이긴다고 말했다.** `DEEL_MOTION=cat` 은 무시되고 설정
+ *     파일이 그대로 쓰이는데, 「환경변수가 이깁니다」 라고 적혔다. 사람은
+ *     설정을 바꿔도 소용없다고 믿는다 — 사실은 그 설정이 이기고 있는데.
+ */
+function 환경이하는말() {
+  const 말들 = [];
+  const 그림 = 환경그림();
+  if (그림?.이김 || process.env.DEEL_OFFICE) 말들.push(c.gray(말('motion.envWins')));
+  if (그림 && !그림.이김) 말들.push(c.gray(말('motion.envUnknown', { 값: 그림.값 })));
+  if (환경으로껐나()) 말들.push(c.gray(말('motion.envOff')));
+  return 말들;
+}
 import { PROFILES, LEVELS as THINK_LEVELS, normalizeProfile, table as effortTable, 가벼운강도, shiftLevel } from './agent/effort.js';
 import { 전선붙이기, 전선말 } from './backend/wire.js';
 import { scanLocal, toProfiles } from './backend/scan.js';
@@ -607,10 +629,8 @@ export async function handle(line, session, ctx) {
           say(`  ${c.yellow(mark.warn)} ${c.gray(말('motion.tooSmall', { 줄, 칸, 최소줄: 최소높이, 최소칸: 최소폭 }))}`);
           say('');
         }
-        if (process.env.DEEL_MOTION || process.env.DEEL_OFFICE) {
-          say(`  ${c.gray(말('motion.envWins'))}`);
-          say('');
-        }
+        const 환경말 = 환경이하는말();
+        if (환경말.length) { for (const 줄 of 환경말) say(`  ${줄}`); say(''); }
         return { handled: true };
       }
 
@@ -652,10 +672,17 @@ export async function handle(line, session, ctx) {
           say(`     ${c.yellow(mark.warn)} ${c.gray(말('motion.appleTerminal'))}`);
         }
       }
-      if (process.env.DEEL_MOTION || process.env.DEEL_OFFICE) {
-        say(`     ${c.yellow(mark.warn)} ${c.gray(말('motion.envWins'))}`);
-      }
-      say(`     ${c.gray(말('motion.appliesNow'))}`);
+      for (const 줄 of 환경이하는말()) say(`     ${c.yellow(mark.warn)} ${줄}`);
+      /*
+       * 「그 자리에서 바뀝니다」 는 **정말로 바뀔 때만** 적는다.
+       *
+       * DEEL_NO_MOTION 이 켜져 있으면 무엇을 골라도 한 칸짜리 돌림표가 돈다.
+       * 그런데 이 자리는 그걸 안 보고 늘 「바뀝니다」 를 적고 있었다. 바로
+       * 위에서 사무실이 작은 터미널에 안 뜬다고 굳이 말해 주는 것과 같은
+       * 까닭인데(「켰다고 말해 놓고 안 보이면 그게 고장이다」), 정작 같은
+       * 일이 환경변수로 일어날 때는 아무 말도 안 했다.
+       */
+      if (!환경으로껐나()) say(`     ${c.gray(말('motion.appliesNow'))}`);
       say('');
       return { handled: true };
     }
@@ -929,9 +956,40 @@ export async function handle(line, session, ctx) {
       // 사람도 되돌아간 줄 모른다. **되돌아간 것만** 뺀다 — 못 되돌린 파일을
       // 여기서 빼면 진짜로 바뀌어 있는 파일이 /diff 에서도 사라진다.
       for (const f of r.restored) if (f.ok === true) session.changes.delete(f.path);
+      /*
+       * ── 되돌리기는 됐는데 **이력을 못 지웠으면** 그것도 말한다 ──────────
+       *
+       * 파일은 이미 되돌아가 있다. 그런데 그 턴이 이력에 그대로 남으면,
+       * 사람이 /undo 를 한 번 더 쳤을 때 **같은 턴**이 또 되돌아간다.
+       * 두 턴을 되돌린 줄 알지만 한 턴이다 (safety/undo.js 의 이력줄임).
+       */
+      if (r.이력줄임 && r.이력줄임.ok === false) {
+        say(`  ${mark.warn} ${c.gray('파일은 되돌렸지만 되돌리기 기록을 못 지웠습니다')} ${c.gray(`— ${r.이력줄임.왜}`)}`);
+        say(`    ${c.gray('그래서 이 턴이 기록에 그대로 남아 있습니다. 여기서')} ${c.cyan('/undo')} ${c.gray('를 또 치면 같은 턴을 또 되돌립니다.')}`);
+      }
+      /*
+       * 깨진 줄은 **되돌릴 수 없는 파일**이다.
+       *
+       * 이력 한 줄이 곧 한 파일의 원문이라, 줄이 깨졌다는 것은 그 파일을
+       * 되돌릴 길이 사라졌다는 뜻이다. 안 말하면 「파일 3개를 되돌렸습니다」
+       * 만 남고 넷째가 왜 안 돌아왔는지는 아무 데도 안 적힌다.
+       */
+      if (r.깨진줄) {
+        say(`  ${mark.warn} ${c.gray(`되돌리기 기록에서 ${r.깨진줄}줄을 못 읽었습니다 — 그 줄에 걸린 파일은 되돌릴 길이 없습니다.`)}`);
+      }
+
       // 상태줄의 '되돌릴 턴' 도 여기서 줄여 준다. 안 줄이면 방금 되돌린 것을
       // 아직 되돌릴 수 있는 것처럼 세고 있게 된다.
-      try { session.되돌릴턴 = ctx.history.turns().length; } catch { /* 못 세면 그냥 둔다 */ }
+      /*
+       * 못 세면 **모른다고 말한다.** 그냥 두면 방금 되돌린 턴이 상태줄에
+       * 그대로 남아, 아직 되돌릴 수 있는 것처럼 보인다 (repl.js 에서 같은
+       * 자리를 이미 고쳤다 — 안전망 숫자가 조용히 틀리면 안 된다).
+       */
+      try { session.되돌릴턴 = ctx.history.turns().length; }
+      catch (e) {
+        session.되돌릴턴 = null;
+        say(`  ${mark.warn} ${c.gray(`되돌릴 턴이 몇 개 남았는지 못 셌습니다 — ${e?.message ?? e}`)}`);
+      }
 
       const 되감음 = session.되감기(r.turnIds ?? []);
       if (되감음.걷은것) {
@@ -1037,6 +1095,22 @@ export async function handle(line, session, ctx) {
       // 서버가 잠깐 막아 다시 부른 횟수. 0 이면 안 적는다 — 없는 일을 줄로 남기면 표만 길어진다.
       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 })}`);
+      /*
+       * ── 갈래를 쓰면 이 위의 숫자는 **한 갈래 것**이다 ────────────────
+       *
+       * session.usage 는 지금 갈래의 셈이다. 갈래를 셋 굴리면 화면의
+       * 금액은 그중 하나 몫이고, 갈래를 바꾸는 것만으로 숫자가 내려간다 —
+       * 돈은 그대로 나가는데. 닫은 갈래 것은 아예 안 보였다.
+       *
+       * 위 줄들을 갈래 합으로 바꾸지는 않는다. 「이 갈래에서 뭘 했나」 도
+       * 봐야 하는 값이라서다. 대신 **다를 때만** 한 줄을 더 붙인다.
+       */
+      const 갈래셈 = ctx?.갈래?.갈래여럿인가?.() ? ctx.갈래.전체usage() : null;
+      if (갈래셈) {
+        const 갈래수 = (ctx.갈래.개수?.() ?? 1) + (ctx.갈래.닫힌수 ?? 0);
+        say(`  ${c.gray(pad('갈래 전부', 14))} ${c.gray(`${갈래수}갈래 · 호출 ${갈래셈.calls.toLocaleString()} · 입력 ${갈래셈.in.toLocaleString()} · 출력 ${갈래셈.out.toLocaleString()}`)}`);
+        say(`  ${c.gray(pad('', 14))} ${c.gray('위 숫자는 지금 갈래 것입니다.')}`);
+      }
       /*
        * 돈.
        *
@@ -1153,6 +1227,29 @@ export async function handle(line, session, ctx) {
           이름: session.규칙못읽음.이름, 까닭: session.규칙못읽음.까닭,
         }))}`);
       }
+      /*
+       * 반만 실린 것도 같은 자리에서 말한다.
+       *
+       * 이름만 적으면 사람은 규칙이 통째로 걸려 있다고 믿는다. 2만 자를
+       * 넘긴 규칙 파일의 뒷부분은 모델에게 한 글자도 안 간다 — 「운영 DB 는
+       * 건드리지 마라」 가 하필 그 뒤에 있으면 그게 제일 나쁜 모양이다.
+       */
+      if (session.규칙잘림) {
+        const j = session.규칙잘림;
+        say(`  ${c.gray(pad('', 10))} ${mark.warn} ${c.yellow(`${j.이름} 은 ${j.원본.toLocaleString()}자라 앞 ${j.실린.toLocaleString()}자만 실렸습니다`)}`);
+        say(`  ${c.gray(pad('', 10))} ${c.gray('그 뒤에 적은 규칙은 모델에게 안 갑니다. 중요한 것을 앞으로 옮기세요.')}`);
+      }
+      /*
+       * 도구 정의를 못 쟀으면 그것도 적는다.
+       *
+       * 도구 정의는 매 요청에 통째로 실려 나간다. 못 재면 /context 는 그만큼
+       * 빈자리가 있다고 말하고, 그 값으로 출력 상한이 잡혀 답이 이유 없이
+       * 짧아진다. MCP 서버가 이상한 스키마를 주면 실제로 나는 일이다.
+       */
+      if (session.도구못쟀나) {
+        say(`  ${c.gray(pad('', 10))} ${mark.warn} ${c.yellow(`도구 정의 크기를 못 쟀습니다 — ${String(session.도구못쟀나).slice(0, 60)}`)}`);
+        say(`  ${c.gray(pad('', 10))} ${c.gray('/context 의 도구 칸이 0 으로 나오고, 답이 이유 없이 짧아질 수 있습니다.')}`);
+      }
       const caps = [
         k.tools ? c.green(말('status.capTools')) : c.red(말('status.capTools')),
         k.streaming ? c.green(말('status.capStream')) : c.gray(말('status.capStream')),
@@ -2812,6 +2909,23 @@ function showContext(session) {
   } else {
     say(`  ${c.gray(말('ctx.estimate'))}`);
   }
+  /*
+   * 재 봤는데 **못 믿어서 안 쓴** 것도 말한다.
+   *
+   * session.배운다() 는 서버가 알려 준 값이 우리 추정의 절반 아래거나 두 배
+   * 위면 표본을 버린다. 튄 값 하나에 게이지가 휘둘리면 안 되니 버리는 것은
+   * 맞다. 그런데 버린 것을 아무 데도 안 남기면, 「아직 한 번도 못 재 봤다」 와
+   * 「재 봤는데 세 배가 나와서 못 믿었다」 가 화면에서 똑같아진다.
+   *
+   * 뒤엣것은 우리 추정이 크게 틀렸다는 단서다. 그 말을 안 하면 게이지는 영영
+   * 짐작인 채로 도는데 사람은 그저 「추정입니다」 만 읽는다.
+   */
+  if (session?.보정버림 > 0) {
+    const 배 = session.보정마지막버린비율;
+    say(`  ${c.gray(`서버가 알려 준 값이 우리 추정과 너무 달라 ${session.보정버림}번은 안 썼습니다`
+      + (배 ? ` (마지막에 잰 것은 추정의 ${배.toFixed(1)}배)` : ''))}`);
+    say(`  ${c.gray('이 창구에서는 위 숫자가 실제와 크게 다를 수 있습니다.')}`);
+  }
   say('');
 }
 

package/src/i18n/en.js

@@ -240,6 +240,8 @@ export const en = {
   'motion.unknown': '"{값}" is not one of the drawings.',
   'motion.pickOne': 'Pick one of:',
   'motion.envWins': 'DEEL_MOTION / DEEL_OFFICE is set, and the environment wins.',
+  'motion.envUnknown': 'DEEL_MOTION is set to "{값}", which is not a name we know — it was ignored, and your saved choice is what applies.',
+  'motion.envOff': 'DEEL_NO_MOTION is set, so nothing is drawn. Your choice is saved and takes effect once you clear that variable.',
   'motion.tooSmall': 'This terminal is {줄} x {칸} — the office needs at least {최소줄} rows and {최소칸} columns.',
   'motion.appleTerminal': "macOS Terminal spaces lines apart, so the room gets horizontal seams — Terminal › Settings › Profiles › Text › Font \"Change\" › set Line Spacing to 1.0. (iTerm2 defaults to 1.0, which is why it looks right there)",
 
@@ -575,7 +577,7 @@ export const en = {
   'ctx.skills': 'Skill list ({실림}/{전체})',
   'ctx.tools': 'Tool definitions',
   'ctx.history': 'Conversation',
-  'ctx.toolResults': 'Tool results ({n} files)',
+  'ctx.toolResults': 'Tool results ({n})',
   'ctx.left': 'Left',
   'ctx.compactHint': 'shrink the conversation',
   'ctx.clearHint': 'clear it all',

package/src/i18n/ja.js

@@ -213,6 +213,8 @@ export const ja = {
   'motion.unknown': '"{값}" はその中にありません。',
   'motion.pickOne': 'この中から選んでください:',
   'motion.envWins': 'DEEL_MOTION / DEEL_OFFICE が設定されていて、そちらが優先されます。',
+  'motion.envUnknown': 'DEEL_MOTION の "{값}" は知らない名前なので無視しました — 設定で選んだものがそのまま使われます。',
+  'motion.envOff': 'DEEL_NO_MOTION が設定されているので何も描きません。選んだものは保存済みで、その環境変数を消せば効きます。',
   'motion.tooSmall': 'この端末は {줄} x {칸} です — オフィスには少なくとも {최소줄} 行 {최소칸} 桁が要ります。',
   'motion.appleTerminal': 'macOS の Terminal は行間を空けるので部屋に横筋が入ります — Terminal › 設定 › プロファイル › テキスト › フォント「変更」› 行間を 1.0 に。(iTerm2 は既定が 1.0 なので、あちらでは綺麗に出ます)',
   'lang.now': '画面の言葉は {이름} です。',
@@ -529,7 +531,7 @@ export const ja = {
   'ctx.skills': 'スキル一覧 ({실림}/{전체})',
   'ctx.tools': '道具の定義',
   'ctx.history': '会話の履歴',
-  'ctx.toolResults': '道具の結果 (ファイル{n}個)',
+  'ctx.toolResults': '道具の結果 ({n}件)',
   'ctx.left': '残り',
   'ctx.compactHint': '会話を畳む',
   'ctx.clearHint': 'まるごと消す',

package/src/i18n/ko.js

@@ -229,6 +229,8 @@ export const ko = {
   'motion.unknown': '"{값}"{~값:은는} 모르는 그림입니다.',
   'motion.pickOne': '고를 수 있는 것:',
   'motion.envWins': '환경변수(DEEL_MOTION·DEEL_OFFICE)가 켜져 있어 그쪽이 이깁니다.',
+  'motion.envUnknown': 'DEEL_MOTION 에 적힌 "{값}" — 모르는 이름이라 무시했습니다. 설정에 고른 것이 그대로 쓰입니다.',
+  'motion.envOff': 'DEEL_NO_MOTION 이 켜져 있어 그림은 안 돕니다. 고른 것은 적어 뒀고, 그 환경변수를 치우면 그때 살아납니다.',
   'motion.tooSmall': '이 터미널은 {줄}줄 × {칸}칸입니다 — 사무실은 {최소줄}줄 × {최소칸}칸부터 뜹니다.',
   'motion.appleTerminal': '맥 기본 터미널은 줄 간격이 넓어 방에 가로줄이 그어집니다 — 터미널 › 설정 › 프로파일 › 텍스트 › 글꼴 「변경」 › 행간을 1.0 으로. (iTerm2 는 기본이 1.0 이라 멀쩡합니다)',
 
@@ -622,7 +624,7 @@ export const ko = {
   'ctx.skills': '스킬 목록 ({실림}/{전체}개)',
   'ctx.tools': '도구 정의',
   'ctx.history': '대화 이력',
-  'ctx.toolResults': '도구 결과 (파일 {n}개)',
+  'ctx.toolResults': '도구 결과 ({n}개)',
   'ctx.left': '남음',
   'ctx.compactHint': '대화 줄이기',
   'ctx.clearHint': '통째로 비우기',

package/src/i18n/zh.js

@@ -213,6 +213,8 @@ export const zh = {
   'motion.unknown': '"{값}" 不在其中。',
   'motion.pickOne': '从这些里选一个:',
   'motion.envWins': '设置了 DEEL_MOTION / DEEL_OFFICE，环境变量优先。',
+  'motion.envUnknown': 'DEEL_MOTION 里的 "{값}" 不是我们认识的名字，已忽略 — 实际生效的是配置里选的那个。',
+  'motion.envOff': '设置了 DEEL_NO_MOTION，所以什么都不画。选择已保存，清掉那个环境变量后才会生效。',
   'motion.tooSmall': '这个终端是 {줄} x {칸} — 办公室至少要 {최소줄} 行 {최소칸} 列。',
   'motion.appleTerminal': 'macOS 的 Terminal 会拉开行距，房间里会出现横缝 — Terminal › 设置 › 描述文件 › 文本 › 字体「更改」› 把行距设为 1.0。(iTerm2 默认就是 1.0，所以那边看着正常)',
   'lang.now': '屏幕语言是 {이름}。',
@@ -529,7 +531,7 @@ export const zh = {
   'ctx.skills': '技能列表 ({실림}/{전체})',
   'ctx.tools': '工具定义',
   'ctx.history': '对话历史',
-  'ctx.toolResults': '工具结果 (文件{n}个)',
+  'ctx.toolResults': '工具结果 ({n}个)',
   'ctx.left': '剩余',
   'ctx.compactHint': '折叠对话',
   'ctx.clearHint': '全部清空',

package/src/repl.js

@@ -455,6 +455,8 @@ export async function chatLoop(opts = {}) {
   // 되돌리기 이력을 못 읽는다는 말은 한 판에 한 번만 한다 — 턴마다 세는 자리라
   // 안 막으면 같은 줄이 턴 수만큼 쌓인다.
   let 되돌리기못읽음말했나 = false;
+  // 이력이 커졌는데 못 줄인 것·깨진 줄. 둘 다 한 판에 한 번만 말한다.
+  let 이력탈말했나 = false;
   /*
    * 정리가 실패해도 켜는 것은 막지 않는다. 다만 **삼키지는 않는다.**
    * 계속 실패하면 .deel/sessions 가 끝없이 커지는데 화면에는 영영 안 떴다.
@@ -2335,6 +2337,21 @@ export async function chatLoop(opts = {}) {
                 const 것들 = ev.result.되돌릴것;
                 say(`      ${c.gray(`↩ ${것들.slice(0, 3).join(' · ')}${것들.length > 3 ? ` 외 ${것들.length - 3}개` : ''} 는 떠 뒀습니다 — /undo 로 되돌아갑니다`)}`);
               }
+              /*
+               * ── 못 뜬 것은 **되돌아가지 않는다** ──────────────────────
+               *
+               * 위 한 줄만 있을 때, `rm 로고.png` 는 「로고.png 는 떠 뒀습니다
+               * — /undo 로 되돌아갑니다」 를 찍었다. 그림·xlsx·zip 은 내용을
+               * 못 떠서 /undo 가 손도 안 대는데도 그랬다. 파일은 이미 없고,
+               * 안전망이 있다는 말만 남는다.
+               */
+              if (ev.result?.못뜬것?.length) {
+                const 못 = ev.result.못뜬것;
+                say(`      ${mark.warn} ${c.gray(`${못.slice(0, 3).join(' · ')}${못.length > 3 ? ` 외 ${못.length - 3}개` : ''} 는 못 떠 뒀습니다 — /undo 로 안 돌아옵니다`)}`);
+              }
+              if (ev.result?.스냅샷상한걸림) {
+                say(`      ${mark.warn} ${c.gray(`대상이 많아 앞 ${ev.result.되돌릴것?.length ?? 0}개만 떠 뒀습니다 — 나머지는 /undo 로 안 돌아옵니다`)}`);
+              }
               // 파일을 고쳤으면 무엇이 바뀌었는지 바로 보여 준다.
               //
               // auto 모드는 안 물어보고 고친다. 여기서 안 보여주면 사람이
@@ -2383,6 +2400,20 @@ export async function chatLoop(opts = {}) {
                  * 줄 수는 0 이다 — 옮긴 것이지 고친 것이 아니다.
                  */
                 for (const f of ev.result.바뀐것들) session.noteChange(f, { added: 0, removed: 0 });
+              } else if (ev.result?.changed) {
+                /*
+                 * ── 바뀐 **경로만** 주는 도구가 있다 ─────────────────────
+                 *
+                 * 파일 하나짜리 Move 와 hwpx Write 가 그렇다. 옮긴 것·새로 만든
+                 * 문서라 「몇 줄 바뀌었나」 가 없다. 그런데 위 세 갈래가 전부
+                 * diff·여럿·바뀐것들 을 보므로 셋 다 안 걸리고, 그러면
+                 * noteChange 가 **아예 안 불린다.**
+                 *
+                 * 파일은 진짜로 옮겨졌는데 /diff 목록에 없고, 상태줄 ✎ 에도 안
+                 * 들고, /commit 이 담는 목록에도 없다. 커밋은 초록으로 끝나고
+                 * 옮긴 파일만 안 담긴다 — 나중에 원격에서만 깨진다.
+                 */
+                session.noteChange(ev.result.changed, { added: 0, removed: 0 });
               }
             }
             flush();   // 도구가 하나 끝날 때마다 적어 둔다
@@ -2899,6 +2930,27 @@ export async function chatLoop(opts = {}) {
      */
     try {
       session.되돌릴턴 = ctx.history.turns().length;
+      /*
+       * ── 안전망이 **제 무게로 무너지는** 것도 여기서 잡힌다 ──────────
+       *
+       * 되돌리기 이력은 파일 내용을 통째로 담아서 금방 수십 MB 가 된다.
+       * 32MB 를 넘으면 오래된 턴부터 버리는데, 그 버리기가 실패하면
+       * (읽기 전용·디스크 참) 이력은 끝없이 자라고 화면에는 영영 안 떴다.
+       * 실패는 대개 이어지는 종류라 저절로 낫지도 않는다.
+       *
+       * 깨진 줄도 같다. 이력 한 줄이 곧 한 파일의 원문이라, 줄이 깨졌다는
+       * 것은 그 파일을 되돌릴 길이 사라졌다는 뜻이다. 상태줄의 `↩ 3` 은
+       * 그 셋이 다 되돌아간다는 말인데, 깨진 줄이 있으면 그게 아니다.
+       */
+      if (!이력탈말했나 && (ctx.history.줄이기못함 || ctx.history.깨진줄)) {
+        이력탈말했나 = true;
+        if (ctx.history.줄이기못함) {
+          say(`  ${mark.warn} ${c.gray('되돌리기 이력이 커졌는데 못 줄였습니다')} ${c.gray('— ' + clip(String(ctx.history.줄이기못함), 60))}`);
+        }
+        if (ctx.history.깨진줄) {
+          say(`  ${mark.warn} ${c.gray(`되돌리기 이력에서 ${ctx.history.깨진줄}줄을 못 읽었습니다 — 그만큼은 ${'/undo'} 로 안 돌아옵니다.`)}`);
+        }
+      }
     } catch (e) {
       session.되돌릴턴 = 0;
       if (!되돌리기못읽음말했나) {

package/src/safety/undo.js

@@ -122,18 +122,54 @@ export class History {
   #maybePrune() {
     this.#writes = (this.#writes ?? 0) + 1;
     if (this.#writes % 20 !== 0) return;
+    // 앞서 못 줄였으면 한참 쉬었다가 다시 본다 (prune 의 주석).
+    if (this.#writes < this.#다음줄이기) return;
     try {
       if (statSync(this.file).size < MAX_BYTES) return;
     } catch { return; }
-    this.prune();
+    /*
+     * 줄이다 터져도 **고치던 파일까지 말려들면 안 된다.**
+     *
+     * 이 함수는 snapshot() 안에서 돈다 — 즉 Write·Edit 이 파일을 쓰기
+     * 직전이다. prune() 이 이력을 읽다 던지면(EACCES·EBUSY) 그 예외가
+     * 도구 밖으로 새어 나가, 사람은 고치려던 파일과 아무 상관 없는
+     * 「EACCES: …/edits.jsonl」 을 보게 된다. 이력을 못 줄인 것은
+     * 위쪽(줄이기못함)에 남기고, 고치는 일은 그대로 이어 간다.
+     */
+    try { this.prune(); }
+    catch (err) {
+      this.줄이기못함 = err?.message ?? String(err);
+      this.#다음줄이기 = this.#writes + 500;
+    }
   }
 
+  #다음줄이기 = 0;
+  /** 이력을 못 줄였으면 그 까닭. 못 줄이면 안전망이 제 무게로 무너진다. */
+  줄이기못함 = null;
+
   #writes = 0;
 
   /** 최근 keep 개 턴만 남기고 자른다. 버린 줄 수를 돌려준다. */
   prune({ keep = KEEP_TURNS } = {}) {
-    const recs = this.all();
-    const turns = this.turns();
+    /*
+     * ── **읽다 터지는 것**도 못 줄인 것이다 ────────────────────────────
+     *
+     * 아래 쓰기만 감싸 두고 여기 읽기는 맨몸이었다. 그런데 이력을 못 읽는
+     * 판(권한·잠김·자리가 폴더로 바뀜)은 못 쓰는 판만큼이나 흔하고, 그때
+     * 예외가 여기를 뚫고 나가면 부르는 쪽 — 파일을 쓰던 Write·Edit — 이
+     * 고치려던 파일과 아무 상관 없는 오류를 뒤집어쓴다.
+     *
+     * 못 줄인 것은 못 줄였다고 위쪽(줄이기못함)에 남기고 0을 돌려준다.
+     * 그게 이 함수가 실패를 말하는 유일한 방식이라 여기서도 같아야 한다.
+     */
+    let recs;
+    let turns;
+    try { recs = this.all(); turns = this.turns(); }
+    catch (err) {
+      this.줄이기못함 = err?.message ?? String(err);
+      this.#다음줄이기 = (this.#writes ?? 0) + 500;
+      return 0;
+    }
     if (turns.length <= keep) return 0;
     const 남길턴 = new Set(turns.slice(-keep));
     const 남길것 = recs.filter((r) => 남길턴.has(r.turn));
@@ -143,7 +179,22 @@ export class History {
       writeFileSync(this.file, 남길것.map((r) => JSON.stringify(r)).join('\n') + (남길것.length ? '\n' : ''), 'utf8');
       // 통째로 다시 쓰면 새 파일일 수 있다 — 빗장을 다시 건다 (agent/store.js 도 같다).
       this.#잠갔나 = false; this.#잠그기();
-    } catch { return 0; }
+      this.줄이기못함 = null;
+    } catch (err) {
+      /*
+       * 못 줄인 것을 **0개 버렸다**와 같은 값으로 돌려주고 있었다.
+       *
+       * 부르는 쪽은 둘을 구별할 길이 없다. 그리고 실패는 대개 이어진다 —
+       * 읽기 전용이거나 디스크가 찬 것이라 다음 번에도 같다. 그러면 이력은
+       * 32MB 를 넘긴 채 끝없이 자라는데 화면에는 영영 안 뜬다.
+       *
+       * 곧바로 또 시도하지도 않는다. 32MB 짜리 파일을 스무 번 쓸 때마다
+       * 통째로 다시 읽는 셈이라, 실패가 이어지면 그 자체가 느려지는 원인이 된다.
+       */
+      this.줄이기못함 = err?.message ?? String(err);
+      this.#다음줄이기 = (this.#writes ?? 0) + 500;
+      return 0;
+    }
     return 버린수;
   }
 
@@ -152,12 +203,30 @@ export class History {
     try { return statSync(this.file).size; } catch { return 0; }
   }
 
+  /*
+   * ── 깨진 줄은 **되돌릴 수 없는 파일**이다 ────────────────────────────
+   *
+   * 여태 `catch { return null }` 로 조용히 버렸다. 그런데 이 파일의 한 줄은
+   * 곧 한 파일의 원문이다 — 줄이 깨졌다는 것은 그 파일을 되돌릴 길이
+   * 사라졌다는 뜻이다. 그걸 안 세면 `/undo` 는 「파일 3개를 되돌렸습니다」
+   * 라고만 하고, 넷째 파일이 왜 안 돌아왔는지는 아무 데도 안 남는다.
+   *
+   * 줄은 실제로 깨진다. 쓰다 죽으면 마지막 줄이 반만 적히고, 같은 폴더에서
+   * 창을 둘 띄워 놓으면 큰 줄 둘이 서로 끼어든다(appendFileSync 는 긴 줄을
+   * 통째로 보장하지 않는다).
+   */
+  /** 마지막으로 읽을 때 깨져 있던 줄 수. 0 이 아니면 그만큼 못 되돌린다. */
+  깨진줄 = 0;
+
   all() {
     if (!existsSync(this.file)) return [];
-    return readFileSync(this.file, 'utf8')
+    let 깨진 = 0;
+    const 것들 = readFileSync(this.file, 'utf8')
       .split('\n').filter(Boolean)
-      .map((l) => { try { return JSON.parse(l); } catch { return null; } })
+      .map((l) => { try { return JSON.parse(l); } catch { 깨진 += 1; return null; } })
       .filter(Boolean);
+    this.깨진줄 = 깨진;
+    return 것들;
   }
 
   turns() {
@@ -232,10 +301,31 @@ export class History {
      */
     const 못한것 = new Set(restored.filter((x) => x.ok === false).map((x) => x.path));
     const keep = recs.filter((r) => !turns.includes(r.turn) || 못한것.has(r.path));
-    writeFileSync(this.file, keep.map((r) => JSON.stringify(r)).join('\n') + (keep.length ? '\n' : ''), 'utf8');
-    this.#잠갔나 = false; this.#잠그기();
+    /*
+     * ── 여기가 터지면 **파일은 이미 되돌아가 있다** ────────────────────
+     *
+     * 감싸지 않은 쓰기였다. 던지면 위에서 받아 「명령을 처리하다 막혔습니다」
+     * 한 줄만 남는다 — 그런데 디스크의 파일들은 방금 되돌아갔다. 화면이
+     * 실패라고 말하는데 실제로는 성공한, 이 저장소가 계속 잡아 온 어긋남이
+     * 방향만 뒤집힌 꼴이다.
+     *
+     * 게다가 이력을 못 줄였으니 그 턴이 그대로 남는다. 사람이 「실패했으니
+     * 다시」 하고 /undo 를 또 치면 **같은 턴**을 또 되돌린다 — 두 턴을
+     * 되돌린 줄 알지만 한 턴이다.
+     */
+    let 이력줄임 = { ok: true };
+    try {
+      writeFileSync(this.file, keep.map((r) => JSON.stringify(r)).join('\n') + (keep.length ? '\n' : ''), 'utf8');
+      this.#잠갔나 = false; this.#잠그기();
+    } catch (err) {
+      이력줄임 = { ok: false, 왜: err?.message ?? String(err) };
+    }
     return {
       restored,
+      // 이력에서 그 턴을 지웠나. 못 지웠으면 같은 턴이 그대로 남아 있다.
+      이력줄임,
+      // 이력에서 못 읽은 줄 수. 그만큼은 되돌릴 길이 애초에 없었다.
+      깨진줄: this.깨진줄,
       // 화면·감사기록이 쓰는 수. **진짜로 되돌아간 것만** 센다.
       되돌린수: restored.filter((x) => x.ok === true).length,
       못한것: restored.filter((x) => x.ok === false),

package/src/tools/fsutil.js

@@ -297,6 +297,8 @@ const 한숨 = () => new Promise((풀기) => setImmediate(풀기));
 export async function walk(root, { limit = 훑기상한(), skipDirs = SKIP_DIRS, ignore = true, signal = null } = {}) {
   const out = [];
   const 건너뜀 = { 폴더: 0, 파일: 0 };
+  // .gitignore 로 건너뛴 것과 다르다 — 이쪽은 우리가 늘 안 보는 살림 폴더다.
+  const 건너뛴살림 = [];
   let 끊김 = false;
   let 본것 = 0;
   const stack = [{ dir: root, rel: '', 규칙: ignore ? 뿌리규칙읽기(root) : [] }];
@@ -315,7 +317,10 @@ export async function walk(root, { limit = 훑기상한(), skipDirs = SKIP_DIRS,
       const full = join(dir, e.name);
       const erel = rel ? `${rel}/${e.name}` : e.name;
       if (e.isDirectory()) {
-        if (skipDirs.has(e.name)) continue;
+        // 살림 폴더(node_modules·.git·dist…)는 안 훑는다. 다만 **몇 개를
+        // 안 봤는지는 센다** — Move 가 폴더를 통째로 옮길 때 이 수를 모르면
+        // 「폴더 12개 파일」 이라고 말해 놓고 3만 개를 옮기게 된다.
+        if (skipDirs.has(e.name)) { 건너뛴살림.push(erel); continue; }
         if (여기규칙.length && 걸리나(erel, true, 여기규칙)) { 건너뜀.폴더 += 1; continue; }
         stack.push({ dir: full, rel: erel, 규칙: 여기규칙 });
       } else if (e.isFile()) {
@@ -335,6 +340,7 @@ export async function walk(root, { limit = 훑기상한(), skipDirs = SKIP_DIRS,
     if (끊김) break;
   }
   Object.defineProperty(out, '건너뜀', { value: 건너뜀, enumerable: false });
+  Object.defineProperty(out, '건너뛴살림', { value: 건너뛴살림, enumerable: false });
   // 상한까지 찼으면 "여기서 멈췄다" 고 표시한다. 딱 맞아떨어져 끝난 경우까지
   // 잘렸다고 하게 되지만, 그쪽으로 틀리는 편이 낫다 — 덜 봤다고 말하는 것은
   // 사람을 한 번 더 보게 만들 뿐이고, 다 봤다고 말하는 것은 못 보게 만든다.