deel-local-cli 1.14.0 → 1.15.0

package/README.ko.md

@@ -94,7 +94,7 @@
 | [속도와 씀씀이](docs/ko/tuning.md) | 단계별 추론 강도 · 프리픽스 캐시 · 컨텍스트 길이 |
 | [안전망과 사내 반입](docs/ko/safety.md) | 되돌리기 · 작업 범위 · 감사기록 · 심사 서류 |
 | [설정](docs/ko/config.md) · [개발](docs/ko/develop.md) | 환경변수 · 실행 옵션 · 검사 돌리기 · 폴더 구조 |
-| [릴리스 노트](docs/ko/releases.md) | [1.14.x](docs/ko/releases/1.14.md) · [1.13.x](docs/ko/releases/1.13.md) · [1.12.x](docs/ko/releases/1.12.md) · [1.10.x](docs/ko/releases/1.10.md) · [1.9.x](docs/ko/releases/1.9.md) · [그 앞](docs/ko/releases.md) |
+| [릴리스 노트](docs/ko/releases.md) | [1.15.x](docs/ko/releases/1.15.md) · [1.14.x](docs/ko/releases/1.14.md) · [1.13.x](docs/ko/releases/1.13.md) · [1.12.x](docs/ko/releases/1.12.md) · [1.10.x](docs/ko/releases/1.10.md) · [1.9.x](docs/ko/releases/1.9.md) · [그 앞](docs/ko/releases.md) |
 
 ---
 
@@ -267,7 +267,7 @@ deel --offline
 무엇이 어디로 갈 수 있는지는 켤 때 화면 맨 위에 늘 적혀 있습니다.
 
 ```
- deel 1.14.0  ⌂ 이 안
+ deel 1.15.0  ⌂ 이 안
  보냄    이 컴퓨터 안 127.0.0.1:11434  ← 여기 말고는 어디로도 안 갑니다
 ```
 
@@ -1087,7 +1087,7 @@ deel sbom --only sbom         # SBOM 한 장만
 ## 개발
 
 ```bash
-npm test          전체 검증 (7,095항목 — 몇몇은 터미널에 따라 갈립니다)
+npm test          전체 검증 (7,144항목 — 몇몇은 터미널에 따라 갈립니다)
 npm run coverage  검사가 소스의 어디를 밟았는지
 npm run verify    반입·통신 검증만
 npm run bench     편집 성공률 측정
@@ -1133,18 +1133,18 @@ zip 은 진짜 `unzip` 으로, tar 는 진짜 `tar` 가 만든 것을 읽혀 교
 | `detect` | 85 | 주소 한 줄로 규격·인증을 짚어내는가 |
 | `modes` · `route` | 120 · 72 | 작업 모드 · 종합에서 알맞은 모드로 옮겨 가는가 |
 | `ctxsize` | 56 | 모델에 걸린 컨텍스트 길이를 긁어오는가 |
-| `commands` · `commands-more` | 214 · 93 | 슬래시 명령 전부 |
+| `commands` · `commands-more` | 221 · 93 | 슬래시 명령 전부 |
 | `ui` · `ui2` | 89 · 40 | 암호 가림·한글 폭·상태줄·대화 목록·엑셀→글 |
-| `encoding` · `xlsx` | 70 · 72 | 한글 인코딩 판별 · 엑셀 읽기 |
-| `compact` | 98 | 요약 압축·짝 안 깨짐·실패 시 물러섬 |
-| `stuck` · `undo` | 48 · 54 | 헛도는 것과 일이 되는 것을 가르는가 · 셸이 쓴 파일도 되돌려지는가 |
+| `encoding` · `xlsx` | 77 · 72 | 한글 인코딩 판별 · 엑셀 읽기 |
+| `compact` | 101 | 요약 압축·짝 안 깨짐·실패 시 물러섬 |
+| `stuck` · `undo` | 48 · 58 | 헛도는 것과 일이 되는 것을 가르는가 · 셸이 쓴 파일도 되돌려지는가 |
 | `store` | 75 | 대화 저장·이어하기·중간에 죽어도 복구 |
 | `scan` | 30 | 여러 런타임을 구분해 찾는가 |
 | `plugins` | 79 | 플러그인 받기·묶기·ZIP/TAR |
-| `exitcode` · `doorparity` | 7 · 7 | 화면에 적은 종료코드 표가 진짜인가 · 문 세 개가 같은 것을 주는가 |
+| `exitcode` · `doorparity` | 7 · 7 | 화면에 적은 종료코드 표가 진짜인가 · 문 **네 개**가 같은 것을 주는가 |
 | `no-bundle` | 21 | 배포 묶음에 남의 것이 안 섞였는가 · 검사 파일 위생 |
 | `edit-bench` | 20건 | 편집 성공률 |
-| `mutate` | 어긋 7개 | **검사가 정말 지키는가** — 지켜야 할 줄을 일부러 어긋내고 빨개지는지 본다 |
+| `mutate` | 어긋 10개 | **검사가 정말 지키는가** — 지켜야 할 줄을 일부러 어긋내고 빨개지는지 본다 |
 
 > **자세히** — 어디를 밟았는지 · 폴더 구조
 >
@@ -1156,6 +1156,7 @@ zip 은 진짜 `unzip` 으로, tar 는 진짜 `tar` 가 만든 것을 읽혀 교
 
 | 판 | 무엇이 바뀌었나 |
 |---|---|
+| **[1.15.0](docs/ko/releases/1.15.md#1150)** | 같은 것을 두 번 하지 않습니다 — 프리픽스 캐시를 깨던 조용히 비싼 아홉 자리 |
 | **[1.14.0](docs/ko/releases/1.14.md#1140)** | 적어 둔 것이 참인지 기계가 대신 봅니다 — 초록불과 「깨면 잡힌다」 는 다릅니다 |
 | [1.13.1](docs/ko/releases/1.13.md#1131) | 올라간 물건이 소스와 달랐습니다 — 148개 중 47개가 CRLF 로 나갔습니다 |
 | **[1.13.0](docs/ko/releases/1.13.md#1130)** | 바깥 창구와 붙는 자리를 전부 다시 봤습니다 — 서로 못 보는 검수자 셋, 셋이 같이 짚은 것 넷 |

package/README.md

@@ -119,7 +119,7 @@ This page is the **summary**. Each section links to the detail behind it.
 | [Speed and spend](docs/en/tuning.md) | Per-stage effort · the prefix cache · context length |
 | [Safety and corporate review](docs/en/safety.md) | Undo · working scope · audit log · the review package |
 | [Configuration](docs/en/config.md) · [Development](docs/en/develop.md) | Env vars · run flags · running the tests · folder layout |
-| [Release notes](docs/en/releases.md) | [1.14.x](docs/en/releases/1.14.md) · [1.13.x](docs/en/releases/1.13.md) · [1.12.x](docs/en/releases/1.12.md) · [1.10.x](docs/en/releases/1.10.md) · [1.9.x](docs/en/releases/1.9.md) · [older](docs/en/releases.md) |
+| [Release notes](docs/en/releases.md) | [1.15.x](docs/en/releases/1.15.md) · [1.14.x](docs/en/releases/1.14.md) · [1.13.x](docs/en/releases/1.13.md) · [1.12.x](docs/en/releases/1.12.md) · [1.10.x](docs/en/releases/1.10.md) · [1.9.x](docs/en/releases/1.9.md) · [older](docs/en/releases.md) |
 
 ---
 
@@ -338,7 +338,7 @@ deel --offline
 The destination is printed at the top of every session:
 
 ```
- deel 1.14.0  ⌂ inside
+ deel 1.15.0  ⌂ inside
  Sends to this machine 127.0.0.1:11434  ← nowhere else
 ```
 
@@ -1158,7 +1158,7 @@ Stored in `~/.deel/config.json`. A `.deel/config.json` in the project folder tak
 ## Development
 
 ```bash
-npm test          Full suite (7,095 checks; a few are TTY-dependent)
+npm test          Full suite (7,144 checks; a few are TTY-dependent)
 npm run coverage  Which lines the tests actually execute
 npm run verify    Import + network checks only
 npm run bench     Edit success rate
@@ -1190,18 +1190,18 @@ so one run tells you everything.
 | `detect` | 85 | Identifying shape and auth from one address |
 | `modes` · `route` | 120 · 72 | Work modes; auto-switching from Auto |
 | `ctxsize` | 56 | Reading context length off the model |
-| `commands` · `commands-more` | 214 · 93 | Every slash command |
+| `commands` · `commands-more` | 221 · 93 | Every slash command |
 | `ui` · `ui2` | 89 · 40 | Password masking, CJK width, status line, session list, Excel→text |
-| `encoding` · `xlsx` | 70 · 72 | Legacy-encoding detection; Excel reading |
-| `compact` | 98 | Summary folding, pairing intact, graceful fallback |
-| `stuck` · `undo` | 48 · 54 | Telling spinning apart from real progress · shell-written files are undoable too |
+| `encoding` · `xlsx` | 77 · 72 | Legacy-encoding detection; Excel reading |
+| `compact` | 101 | Summary folding, pairing intact, graceful fallback |
+| `stuck` · `undo` | 48 · 58 | Telling spinning apart from real progress · shell-written files are undoable too |
 | `store` | 75 | Session persistence, resume, crash recovery |
 | `scan` | 30 | Distinguishing multiple runtimes |
 | `plugins` | 79 | Plugin fetch/pack, ZIP/TAR |
-| `exitcode` · `doorparity` | 7 · 7 | The printed exit-code table is real · all three doors hand out the same thing |
+| `exitcode` · `doorparity` | 7 · 7 | The printed exit-code table is real · all **four** doors hand out the same thing |
 | `no-bundle` | 21 | Nothing foreign in the published package; test-file hygiene |
 | `edit-bench` | 20 cases | Edit success rate |
-| `mutate` | 7 mutants | **Whether the tests actually guard** — break the line on purpose, check it turns red |
+| `mutate` | 10 mutants | **Whether the tests actually guard** — break the line on purpose, check it turns red |
 
 > **More** — Coverage · Layout
 >
@@ -1213,6 +1213,7 @@ so one run tells you everything.
 
 | Version | What changed |
 |---|---|
+| **[1.15.0](docs/en/releases/1.15.md#1150)** | Stop doing the same thing twice — nine quietly expensive places that broke the prefix cache |
 | **[1.14.0](docs/en/releases/1.14.md#1140)** | A machine now checks that what we wrote down is true — green does not mean guarded |
 | [1.13.1](docs/en/releases/1.13.md#1131) | What shipped was not what the source said — 47 of 148 files went out with CRLF line endings |
 | **[1.13.0](docs/en/releases/1.13.md#1130)** | Every place deel touches someone else's endpoint, re-examined — three independent reviewers, four findings they shared |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deel-local-cli",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "description": "A coding-agent CLI that runs on local models and private gateways. Zero dependencies, Node 20+.",
   "type": "module",
   "license": "MIT",

package/src/acp/serve.js

@@ -28,7 +28,7 @@
 // 하나하나 찾아 막는 방법도 있지만, 그건 앞으로 새로 쓰는 코드까지 계속
 // 조심해야 한다는 뜻이다 — 언젠가 반드시 한 군데를 빠뜨린다.
 import { existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { VERSION } from '../version.js';
 import { 규칙모으기, 늘허락, 정책읽기 } from '../safety/policy.js';
 import { 받기설정 } from '../safety/authcmd.js';
@@ -89,6 +89,26 @@ export async function acp(opts = {}) {
 
   /** 세션 하나. 에디터의 탭 하나에 해당한다. */
   const 방들 = new Map();
+
+  /*
+   * 폴더 → MCP 붙임. **폴더 하나에 한 벌**이다.
+   *
+   * 에디터에서 `session/new` 는 탭 하나다. 사람은 한 프로젝트를 열어 놓고 탭을
+   * 서너 개 띄운다 — 그게 에디터를 쓰는 이유다. 그런데 방마다 다붙이기() 를
+   * 새로 부르면 같은 `.deel/mcp.json` 을 보고 같은 서버를 탭 수만큼 띄운다.
+   *
+   * MCP 서버는 남의 프로그램이라 무엇을 들고 뜨는지 우리는 모른다 — 인덱스를
+   * 통째로 메모리에 올리는 것도 있고, 뜰 때마다 원격에 붙는 것도 있다. 탭
+   * 하나 여는 값도 두 번 치른다: 붙기는 왕복 두 번(initialize + tools/list)이고
+   * 그동안 그 탭은 멈춰 있다.
+   *
+   * 값으로 **약속(Promise)** 을 넣는다. 에디터가 탭 셋을 한꺼번에 열면
+   * session/new 셋이 겹쳐 도는데, 다 붙은 뒤에 넣으면 셋 다 빈 칸을 보고
+   * 셋 다 띄운다 — 고치려던 것이 그대로 남는다.
+   *
+   * 폴더가 다르면 따로 띄운다. 옆 프로젝트의 도구가 딸려 오면 안 된다.
+   */
+  const mcp캐시 = new Map();
   let 클라이언트 = null;      // initialize 로 받은 저쪽 소개
   let 시작했나 = false;
 
@@ -235,10 +255,29 @@ export async function acp(opts = {}) {
      * 그래서 deel 은 늘 제 폴더의 .deel/mcp.json 만 본다. 사람이 직접 적은 것만
      * 띄운다는 규칙이 대화 화면과 여기서 똑같이 유지된다.
      */
-    const mcp붙임 = await 다붙이기(root, {
-      offline: !!(opts.offline ?? prof.offline),
-      audit: null,
-    });
+    const 캐시열쇠 = resolve(root);
+    if (!mcp캐시.has(캐시열쇠)) {
+      mcp캐시.set(캐시열쇠, 다붙이기(root, {
+        offline: !!(opts.offline ?? prof.offline),
+        audit: null,
+      }).then((붙임) => {
+        /*
+         * 못 붙은 것은 **못 붙었다고 말한다.**
+         *
+         * 대화 화면은 이걸 적어 준다(repl.js 의 경고 줄). 여기만 안 적고
+         * 있었다. 그러면 에디터 안에서는 도구가 그냥 없다 — 왜 없는지는
+         * 어디에도 안 남는다. 사람은 모델이 게을러진 줄 안다.
+         */
+        for (const m of 붙임.못한것 ?? []) 로그(`MCP ${m.이름} 을 못 붙였습니다 — ${m.왜}`);
+        if (붙임.서버들.length) 로그(`MCP ${붙임.서버들.length}대에 붙었습니다 (${캐시열쇠}) — 이 폴더의 다른 탭도 같이 씁니다.`);
+        return 붙임;
+      }).catch((err) => {
+        // 붙이다 터져도 탭은 열려야 한다. 도구가 없는 채로 대화는 된다.
+        로그(`MCP 를 붙이다 실패했습니다 — ${err?.message ?? err}`);
+        return { 서버들: [], 못한것: [], 설정: null };
+      }));
+    }
+    const mcp붙임 = await mcp캐시.get(캐시열쇠);
     session.mcp = mcp붙임.서버들;
     if (Array.isArray(요청?.mcpServers) && 요청.mcpServers.length) {
       로그(`에디터가 MCP 서버 ${요청.mcpServers.length}대를 넘겼지만 띄우지 않습니다 — deel 은 .deel/mcp.json 에 적힌 것만 띄웁니다.`);
@@ -818,8 +857,12 @@ export async function acp(opts = {}) {
    */
   const 껐다 = 일감모두끝내기();
   if (껐다) 로그(`뒤에서 돌던 명령 ${껐다}개를 껐습니다.`);
-  for (const 방 of 방들.values()) {
-    for (const s of 방.mcp ?? []) { try { s.닫기(); } catch { /* 이미 죽은 것 */ } }
+  // 방이 아니라 **캐시**를 돈다. 방 여럿이 한 벌을 나눠 쓰므로 방을 돌면
+  // 같은 서버에 닫기() 를 여러 번 부르게 된다.
+  for (const 약속 of mcp캐시.values()) {
+    let 붙임 = null;
+    try { 붙임 = await 약속; } catch { /* 붙다 만 것은 닫을 것도 없다 */ }
+    for (const s of 붙임?.서버들 ?? []) { try { s.닫기(); } catch { /* 이미 죽은 것 */ } }
   }
   if (!시작했나) 로그('initialize 를 못 받고 끝났습니다 — 이 명령은 에디터가 자식 프로세스로 띄우는 자리입니다.');
   return 0;

package/src/agent/compact.js

@@ -184,10 +184,33 @@ export function foldToolResults(session, { keep = KEEP_RECENT, min = FOLD_MIN,
    * 한 줄 아끼자고 앞머리를 깨면 그 걸음에 대화가 통째로 다시 나간다.
    * 모아 두었다가 한 번에 접는 편이 눈에 띄게 싸다. 자리가 정말 모자라면
    * 80% 에서 요약 압축이 받아 준다 — 안전망은 그쪽에 있다.
+   *
+   * ── 토큰만 세는 것으로는 묶음이 안 된다 ──────────────────────────────
+   *
+   * 이 머리말은 「접기는 묶음으로 한다」 고 적어 두고, 걸음마다 하나씩 접던
+   * 것을 고쳤다고 말한다. 그런데 막는 자가 이득문턱(2,000토큰) 하나뿐이라
+   * **평범한 Read 결과 하나가 혼자서 그 문턱을 넘는다.** 60줄짜리 결과 하나가
+   * 3천 토큰이다. 그래서 55% 를 넘긴 뒤로는 실제로 **걸음마다 한 개씩** 접혔다
+   * — 고쳤다고 적어 둔 바로 그 모양 그대로. 재 보니 접을 만한 20걸음에서
+   * 20번 접었다.
+   *
+   * 값이 어떻게 되나: 한 걸음에 3천 토큰 아끼려고, 접힌 자리 뒤 전부(1만
+   * 2천 토큰쯤)를 캐시 읽기가 아니라 정가 입력으로 다시 보낸다. 그걸 걸음마다
+   * 한다. 로컬이면 그 걸음마다 프리필을 통째로 다시 돈다.
+   *
+   * 그래서 **개수도 같이 본다.** 최근 keep 개는 어차피 남기므로, 새로 밀려난
+   * 것이 keep 개 모일 때까지 기다렸다가 한 번에 접는다. 접는 횟수가 1/keep 로
+   * 줄고, 한 번 깰 때 아끼는 양은 그만큼 커진다 — 깨는 값은 같은데.
+   *
+   * 이미 접힌 것은 여기 안 셈해진다(위 filter 의 min 이 걸러낸다 — 접힌 자국은
+   * 100자도 안 된다). 그래서 이 수는 언제나 **새로 접을 것**의 수다.
    */
   const 예상이득 = 접을것.reduce((a, x) => a + estimateTokens(x.글), 0);
-  if (예상이득 < 이득문턱) {
-    return { 접은것: 0, 아낀토큰: 0, 접은것들: [], 미룸: true, 모인것: 예상이득 };
+  if (예상이득 < 이득문턱 || 접을것.length < keep) {
+    return {
+      접은것: 0, 아낀토큰: 0, 접은것들: [], 미룸: true,
+      모인것: 예상이득, 모인개수: 접을것.length,
+    };
   }
 
   let 아낀토큰 = 0;

package/src/agent/filemem.js

@@ -49,6 +49,23 @@ export class 파일기억 {
     this.것들 = new Map();
   }
 
+  /**
+   * 이 기억을 그대로 베낀 새것.
+   *
+   * 갈래를 **갈라낼 때**(agent/threads.js 의 갈라내기) 쓴다. 그때 대화는
+   * 사본이 되는데 기억을 같이 쓰면, 한쪽에서 파일을 다시 읽은 것이 다른 쪽의
+   * 답을 바꾼다 — 갈라낸 쪽에서 v3 을 읽으면 본줄기가 「안 바뀌었다」 고
+   * 답하기 시작한다. 본줄기 대화에 실려 있는 것은 v1 인데도.
+   *
+   * 얕은 사본이면 된다. 담긴 값 { 글, 언제 } 는 갈아 끼우기만 하고 안에서
+   * 고치는 자리가 없다(실을것 은 언제나 set 으로 통째로 덮는다).
+   */
+  베끼기() {
+    const 새것 = new 파일기억();
+    새것.것들 = new Map(this.것들);
+    return 새것;
+  }
+
   /**
    * 요약해서 접었다 = 앞엣것이 대화에서 사라졌다. 기억도 같이 버린다.
    *

package/src/agent/session.js

@@ -382,8 +382,41 @@ export class Session {
     return this.routed ?? this.work;
   }
 
+  /*
+   * ── 급은 **턴마다 한 번**만 매긴다 ──────────────────────────────────────
+   *
+   * 이 값은 시스템 글의 **굳은 부분**에 들어간다(아래 시스템조각 의 급말).
+   * 그런데 매김() 은 살아 있는 사고 카운터를 본다 — 인자 잘림 한 번, 편집
+   * 실패 한 번이면 **걸음 사이에** '보통' → '작음' 으로 뒤집힌다.
+   *
+   * 뒤집히는 자리가 프롬프트 맨 앞이라 그 뒤 전부가 캐시에서 빠진다 — 도구
+   * 정의 + 시스템 글 + 대화 전체. 그것도 턴 사이가 아니라 **한 턴의 걸음
+   * 사이**에서다. 대화가 꼬리만 자라서 앞머리가 가장 안정적이어야 할 바로
+   * 그 자리다. 게이트웨이면 캐시 읽기(0.1배)로 나갔을 것이 정가로 다시 나가고,
+   * 로컬이면 그 한 걸음에 프리필을 통째로 다시 돈다. 화면에는 왜 갑자기
+   * 느려졌는지 한 줄도 안 뜬다.
+   *
+   * 그래서 빗장을 건다. 새로 배운 것을 버리는 것이 아니라 **적용을 다음 턴으로
+   * 미루는 것**이다 — 턴시작() 이 빗장을 푼다. 사람이 /grade 로 정하거나
+   * /model 로 갈아타면 급다시재기() 로 그 자리에서 다시 맨다. 그때는 사람이
+   * 프롬프트가 바뀐 것을 알고 한 일이다.
+   */
+  #급빗장 = null;
+
   /** 지금 매겨진 모델 급. 화면과 프롬프트가 같은 것을 봐야 한다. */
-  급() { return 매김(this.conn, this.본것, this.급정한것); }
+  급() {
+    if (!this.#급빗장) this.#급빗장 = 매김(this.conn, this.본것, this.급정한것);
+    return this.#급빗장;
+  }
+
+  /**
+   * 빗장을 풀어 다음에 물을 때 다시 매기게 한다.
+   *
+   * 부르는 자리는 셋이다 — 턴 시작(아래 턴시작), `/grade`, `/model`
+   * (commands.js 의 연결적용). 앞의 둘은 사람이 그러라고 한 것이고, 마지막은
+   * 모델 자체가 바뀐 것이라 앞의 매김이 뜻을 잃는다.
+   */
+  급다시재기() { this.#급빗장 = null; }
 
   /** 이 급에서 쓸 손잡이 값들 (한 번에 만들 파일 수 같은 것). */
   급값() { return 급값(this.급().급); }
@@ -553,6 +586,8 @@ export class Session {
   /** 새 턴을 연다. 바로 다음에 push 되는 말이 이 턴의 첫 말이 된다. */
   턴시작(턴) {
     if (턴 == null) return this;
+    // 급은 턴마다 한 번 매긴다 — 까닭은 급() 머리말에.
+    this.급다시재기();
     // 접혀 없어진 표는 여기서 턴다 — 안 그러면 긴 대화에서 끝없이 쌓인다.
     this.#턴표 = this.#턴표.filter((x) => this.messages.includes(x.표));
     if (this.#턴표.length > Session.#표최대) this.#턴표 = this.#턴표.slice(-Session.#표최대);

package/src/agent/threads.js

@@ -27,6 +27,8 @@
 // 한 줄기로 읽어서, 서로 상관없는 대화가 한 덩어리가 된다.
 
 /** 이름이 없을 때 붙여 줄 이름. 사람이 목록에서 알아볼 수 있으면 된다. */
+import { 파일기억 } from './filemem.js';
+
 function 기본이름(n) { return `갈래 ${n}`; }
 
 export class Threads {
@@ -49,9 +51,20 @@ export class Threads {
      * 돌아오는데 남은 할 일은 안 돌아왔다.
      */
     첫store?.살림따라가기?.(session);
+    /*
+     * 파일기억·filesRead 도 **갈래 것**이다.
+     *
+     * 이 둘은 「messages 안에 무엇이 살아 있나」 의 그림자다. messages 를
+     * 갈래마다 따로 두면서 이것만 세션에 하나로 두면 반드시 어긋나고, 어긋나면
+     * 「앞에서 읽은 그대로입니다」 가 **그 글이 없는 갈래에서** 나온다 —
+     * 모델은 대화 어디에도 없는 글을 가리키는 쪽지를 받고, 다시 읽어도 파일이
+     * 안 바뀌었으니 같은 쪽지를 받는다. 세 번째에 헛돈다고 턴이 죽는다.
+     * (agent/filemem.js 머리말의 「통째로 다시 싣는 것보다 훨씬 나쁘다」)
+     */
     this.갈래들 = [{
       이름: '본줄기', messages: session.messages, usage: session.usage, todos: ctx?.todos ?? null,
       할일: session.할일, 이번요청: session.이번요청, store: 첫store,
+      파일기억: session.파일기억, filesRead: session.filesRead,
     }];
     this.자리 = 0;
     this.센것 = 1;
@@ -72,6 +85,9 @@ export class Threads {
     // 적어 버린다 — 이어받을 때 하지도 않은 일이 본줄기에 남는다.
     g.할일 = this.session.할일;
     g.이번요청 = this.session.이번요청;
+    // 읽은 파일 기억도 같이 — 까닭은 생성자에 적어 뒀다.
+    g.파일기억 = this.session.파일기억;
+    g.filesRead = this.session.filesRead;
   }
 
   /** 갈래 하나를 화면으로 꺼낸다. */
@@ -83,6 +99,15 @@ export class Threads {
     if (this.ctx) this.ctx.todos = g.todos;
     this.session.할일 = g.할일 ?? [];
     this.session.이번요청 = g.이번요청 ?? '';
+    /*
+     * 여기서 session.파일기억 을 통째로 갈아 끼운다.
+     *
+     * 이미 잊기() 를 부르는 자리들(compact.js · loop.js · session.js)은 전부
+     * session.파일기억 을 거치므로 손댈 것이 없다 — 그때그때 지금 갈래의 것을
+     * 잊는다. 문이 하나로 남는다.
+     */
+    if (g.파일기억) this.session.파일기억 = g.파일기억;
+    if (g.filesRead) this.session.filesRead = g.filesRead;
     // 적는 자리도 지금 갈래의 파일로 옮긴다 (agent/store.js 의 살림따라가기).
     g.store?.살림따라가기?.(this.session);
     // 상태줄이 지금 어느 갈래인지 보여 줄 수 있게 남긴다.
@@ -110,6 +135,14 @@ export class Threads {
       할일: [],
       이번요청: '',
       store,
+      /*
+       * 갈라낸 것이면 지금 기억을 **베껴** 물려준다. 같이 쓰면 한쪽에서 파일을
+       * 다시 읽은 것이 다른 쪽 답을 바꾼다 — 갈라낸 쪽에서 v3 을 읽으면
+       * 본줄기가 「안 바뀌었다」 고 답하기 시작한다. 본줄기에 실린 것은 v1 인데도.
+       * 빈 갈래면 빈 기억이다. 대화가 비었으니 기억할 것도 없다.
+       */
+      파일기억: 물려줄것 ? (this.session.파일기억?.베끼기?.() ?? new 파일기억()) : new 파일기억(),
+      filesRead: 물려줄것 ? new Map(this.session.filesRead ?? []) : new Map(),
     };
     this.갈래들.push(g);
     // 갈라낸 것은 지금까지 오간 말을 새 파일에도 적어 둔다. 안 적으면 그 갈래를

package/src/commands.js

@@ -13,7 +13,9 @@ import { 지금모드, 바깥인가, 나갈수있나 } from './safety/runmode.js
 import { 주소가리기 } from './safety/secrets.js';
 import { pick, confirm } from './ui/prompt.js';
 import { load, save, 저장시도, resolveKey, upsert, 열쇠보관, configPath } from './config.js';
-import { 지금상태 as 지금열쇠상태 } from './safety/authcmd.js';
+import { 지금상태 as 지금열쇠상태, 받기설정, 잊기 as 받은열쇠잊기 } from './safety/authcmd.js';
+// 열쇠받기 명령을 정책이 못박아 뒀을 수 있다 — 받기설정 이 그 값을 같이 본다.
+import { 정책읽기 } from './safety/policy.js';
 import { 제공자고르기 } from './providers/index.js';
 import { 종, 알릴만한초 } from './ui/notify.js';
 /*
@@ -431,7 +433,7 @@ export async function handle(line, session, ctx) {
       }
 
       const { 있는것, 없는것 } = 둘러보기();
-      const 뿌리것 = ctx?.scope?.root ? 프로젝트갈래(ctx.scope.root) : null;
+      const 뿌리것 = ctx?.scope?.root ? await 프로젝트갈래(ctx.scope.root) : null;
       const 떠있는것 = 지금것들();
       say('');
       if (있는것.length) {
@@ -2616,6 +2618,9 @@ function 모델급(session, arg = '') {
 
   if (값 === 'auto' || 값 === '자동') {
     session.급정한것 = null;
+    // 급은 턴마다 한 번만 맨다(session.js 의 급 머리말). 사람이 여기서 정한
+    // 것은 다음 턴이 아니라 **지금** 먹어야 하니 빗장을 풀어 준다.
+    session.급다시재기?.();
     const g = session.급();
     say('');
     say(`  ${c.cyan('◈')} 모델 급을 다시 ${c.bold('스스로 잡게')} 했습니다 — 지금은 ${c.white(g.급)}`);
@@ -2625,6 +2630,7 @@ function 모델급(session, arg = '') {
 
   if (값 && 별명[값]) {
     session.급정한것 = 별명[값];
+    session.급다시재기?.();
     const v = session.급값();
     say('');
     say(`  ${c.cyan('◈')} 모델 급을 ${c.bold(별명[값])} 으로 정했습니다.`);
@@ -2785,7 +2791,47 @@ function 연결적용(session, p, ctx = null) {
     kind: p.kind, base: p.baseUrl, auth: p.auth, key: resolveKey(p), model: p.model,
     ctx: p.ctx, maxTokens: p.maxTokens ?? null,
     streaming: p.streaming, tools: p.tools, json: p.json, think: p.think,
+    /*
+     * ── 이 두 줄이 없어서 회사 토큰이 남의 창구로 나갔다 ────────────────
+     *
+     * conn 을 짓는 자리는 넷이다 — repl.js · oneshot.js · acp/serve.js, 그리고
+     * 여기. 앞의 셋은 이 둘을 넣는데 여기만 빠져 있었다. 그래서 `/model` 로
+     * 갈아타면 **옛 프로필의 것이 그대로 남았다.**
+     *
+     *   회사 프로필(열쇠받기로 SSO 토큰을 받아 온다) → /model 남의창구
+     *     · 살아 있는 회사 토큰이 `Authorization` 에 실려 남의 host 로 간다
+     *     · 새 프로필의 제 열쇠(conn.key)는 **쓰이지도 않는다** —
+     *       adapter.js 의 머리말짓기 는 열쇠받기가 있으면 그쪽을 쓴다
+     *     · 남의 창구는 그 토큰을 모르니 401, 그러면 로그인 명령을 다시 돌린다
+     *
+     * 반대쪽도 같다. 맨 프로필에서 회사 프로필로 옮기면 열쇠받기가 null 로
+     * 남아 401 뒤에 열쇠를 다시 받는 길이 잠긴다(adapter.js 의 열쇠다시받을까).
+     *
+     * vision 도 같은 값이다 — 안 옮기면 그림을 못 보는 모델에 그림을 보낸다.
+     */
+    열쇠받기: 받기설정(p, { 정책값: 정책읽기().값 }),
+    vision: p.vision ?? false,
   });
+  /*
+   * 들고 있던 토큰도 버린다.
+   *
+   * 열쇠받기 설정을 새것으로 갈아도, authcmd.js 가 **모듈 전역 하나**에
+   * 받은 토큰을 들고 있다(받은것). 어느 프로필 것인지는 안 적혀 있다. 그래서
+   * 안 버리면 새 창구의 첫 요청에 옛 회사 토큰이 그대로 실려 나간다 — 위에서
+   * 고친 것을 캐시가 도로 되돌리는 셈이다.
+   *
+   * 이 함수의 머리말이 「검사와 `/model` 갈아타기가 부른다」 라고 적혀 있었는데
+   * 부르는 곳이 검사밖에 없었다. 이제 적힌 대로가 된다.
+   */
+  받은열쇠잊기();
+  /*
+   * 급도 다시 맨다.
+   *
+   * 급은 conn 을 보고 매긴다(agent/grade.js 의 매김). 모델을 갈아탔는데 앞
+   * 모델로 매긴 급을 턴 끝까지 들고 있으면, 화면에 적힌 급과 프롬프트에 실린
+   * 급이 서로 다른 모델 이야기가 된다.
+   */
+  session.급다시재기?.();
   // 자물쇠도 같이 옮긴다. 이걸 빼먹으면 옛 주소가 열린 채로 남고 새 주소는 막혀
   // 다음 한마디에서 바로 "허용되지 않은 주소" 가 난다.
   allowEndpoint(p.baseUrl);

package/src/lsp/servers.js

@@ -193,13 +193,17 @@ export function 둘러보기(env = process.env) {
  *
  * 뿌리마다 한 번만 센다. 폴더 훑기는 값이 있고, 세션 중에 언어가 바뀌지 않는다.
  */
-export function 프로젝트갈래(뿌리, env = process.env) {
+export async function 프로젝트갈래(뿌리, env = process.env) {
+  // 센 것이 아니라 **세는 약속**을 담아 둔다. 훑기가 비동기라, 다 세고 나서
+  // 담으면 겹쳐 부른 쪽이 둘 다 빈 칸을 보고 둘 다 훑는다 — 에디터에서 탭을
+  // 한꺼번에 열면 실제로 그렇게 된다.
   if (_센것.has(뿌리)) return _센것.get(뿌리);
+  const 약속 = (async () => {
   let 답 = null;
   try {
     const 셈 = new Map();
     const 첫파일 = new Map();
-    for (const f of walk(뿌리, { limit: 4000 })) {
+    for (const f of await walk(뿌리, { limit: 4000 })) {
       const g = 갈래(f.path);
       if (!g) continue;
       셈.set(g, (셈.get(g) ?? 0) + 1);
@@ -210,8 +214,10 @@ export function 프로젝트갈래(뿌리, env = process.env) {
       if (고르기(g, env)) { 답 = { 갈래: g, 대표파일: 첫파일.get(g), 개수: 셈.get(g) }; break; }
     }
   } catch { 답 = null; }
-  _센것.set(뿌리, 답);
   return 답;
+  })();
+  _센것.set(뿌리, 약속);
+  return 약속;
 }
 
 /** 시험이 쓴다 — 폴더를 새로 만들고 다시 셀 때. */

package/src/repl.js

@@ -411,7 +411,7 @@ export async function chatLoop(opts = {}) {
    * 답이 바뀌지 않는다. 아무것도 안 깔아 준다 — 있으면 쓰고 없으면 없는 대로
    * Grep·Outline 으로 간다 (lsp/servers.js 머리말).
    */
-  session.lsp = 언어서버있나(root);
+  session.lsp = await 언어서버있나(root);
   // 지난 대화에서 정해 둔 것을 들고 시작한다.
   // 기억은 Session 이 켤 때 직접 읽는다 (session.js 생성자) — deel run 도 같은 것을 들고 시작하게.
 

package/src/safety/undo.js

@@ -1,7 +1,7 @@
 // 되돌리기. 승인 프롬프트를 안 쓰는 대신 이게 안전망이다.
 // 파일을 고치기 전에 항상 이전 내용을 떠 놓고, /undo 로 턴 단위로 되돌린다.
 import { join, dirname } from 'node:path';
-import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync, appendFileSync, statSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync, appendFileSync, statSync, chmodSync } from 'node:fs';
 import { looksBinary } from '../tools/encoding.js';
 import { 말 } from '../i18n/index.js';
 
@@ -12,9 +12,40 @@ const KEEP_TURNS = 50;
 export class History {
   constructor(root) {
     this.dir = join(root, '.deel', 'history');
-    mkdirSync(this.dir, { recursive: true });
+    // 폴더부터 본인 것으로. 파일만 잠그고 폴더가 0755 면 이름은 다 보인다.
+    mkdirSync(this.dir, { recursive: true, mode: 0o700 });
     this.file = join(this.dir, 'edits.jsonl');
     this.turn = 0;
+    /** 잠근 결과. 밖에서 볼 수 있어야 「잠갔다」 는 말이 뜻을 갖는다. */
+    this.잠금 = null;
+  }
+
+  /*
+   * ── 이 파일은 남의 파일 **원문**을 담는다 ───────────────────────────────
+   *
+   * 되돌리려면 고치기 전 내용을 그대로 들고 있어야 한다. 그래서 여기에는
+   * `.env` · `id_rsa` · `.npmrc` · kubeconfig 가 **평문으로** 들어온다.
+   * 가리지도 않는다 — 가리면 되돌릴 때 사람의 진짜 열쇠가 표로 덮여 없어진다.
+   * 즉 이 자리에서 지키는 방법은 파일 권한 하나뿐인데, 그것이 없었다.
+   *
+   * umask 022 인 리눅스·맥에서 이 파일은 0644 로 만들어진다. 같은 PC 의 다른
+   * 계정, 데몬, 공유 홈(NFS)의 아무나가 deel 이 손댄 모든 파일의 원문을 읽는다
+   * — 주인이 일부러 0600 으로 잠가 둔 파일까지. `.deel` 아래 다른 기록
+   * (agent/store.js · safety/audit.js)은 전부 잠그는데 여기만 안 잠갔다.
+   *
+   * 1.14.0 에서 셸 쓰기(`sed -i` · `echo >` · `tee`)까지 스냅샷을 뜨게 하면서
+   * 들어오는 파일이 더 늘었다. 고친 것이 이 구멍을 넓힌 셈이라 같이 막는다.
+   *
+   * 윈도우(NTFS)에서는 chmod 가 아무 일도 안 한다. 거기서는 못 잠근 것이지
+   * 잠근 척하지 않는다 — 그래서 결과를 `잠금` 에 있는 그대로 남긴다.
+   * (safety/audit.js · agent/store.js 와 같은 모양이다)
+   */
+  #잠갔나 = false;
+  #잠그기() {
+    if (this.#잠갔나) return;
+    this.#잠갔나 = true;
+    try { chmodSync(this.file, 0o600); this.잠금 = { 모드: 0o600 }; }
+    catch (err) { this.잠금 = { 못함: err?.code ?? String(err) }; }
   }
 
   /**
@@ -73,6 +104,7 @@ export class History {
     if (뜬것.enc) rec.enc = 뜬것.enc;
     if (뜬것.skipped) rec.skipped = 뜬것.skipped;
     appendFileSync(this.file, JSON.stringify(rec) + '\n', 'utf8');
+    this.#잠그기();
     this.#이번턴.set(absPath, rec);
     this.#maybePrune();
     return rec;
@@ -109,6 +141,8 @@ export class History {
     if (!버린수) return 0;
     try {
       writeFileSync(this.file, 남길것.map((r) => JSON.stringify(r)).join('\n') + (남길것.length ? '\n' : ''), 'utf8');
+      // 통째로 다시 쓰면 새 파일일 수 있다 — 빗장을 다시 건다 (agent/store.js 도 같다).
+      this.#잠갔나 = false; this.#잠그기();
     } catch { return 0; }
     return 버린수;
   }
@@ -199,6 +233,7 @@ 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.#잠그기();
     return {
       restored,
       // 화면·감사기록이 쓰는 수. **진짜로 되돌아간 것만** 센다.

package/src/tools/fsutil.js

@@ -240,16 +240,44 @@ export function 훑기상한(env = process.env) {
 /**
  * 폴더를 훑는다.
  *
+/*
+ * ── 몇 개마다 한 번 숨을 쉴까 ───────────────────────────────────────────
+ *
+ * 숨 한 번은 setImmediate 한 번이고, 그 사이에 이벤트 루프가 한 바퀴 돈다.
+ * 그 한 바퀴가 이 파일에서 제일 중요한 줄이다 — 그동안에만 키보드가 배달되고,
+ * 그동안에만 signal.aborted 가 참으로 바뀔 수 있다.
+ *
+ * 자주 쉬면 훑기 자체가 느려지고, 드물게 쉬면 그만큼 귀를 닫는다. 200개면
+ * 사내망 드라이브에서도 한 숨 사이가 10ms 언저리다.
+ */
+export const 숨쉴간격 = 200;
+const 한숨 = () => new Promise((풀기) => setImmediate(풀기));
+
+/**
+ * 폴더를 훑는다. **비동기다** — 부르는 쪽은 반드시 await 한다.
+ *
  * @param {AbortSignal|null} signal 멈추라면 훑다 말고 나온다.
  *   사내망 드라이브에서는 파일 20,000개 훑기가 몇 초다. 그 사이에
  *   ESC 를 눌렀는데 끝까지 다 훑고 나서 멈추면, 사람 눈에는 멈추지
  *   않는 것으로 보인다. 나온 것에 `끊김` 을 달아 부르는 쪽이 알게 한다 —
  *   조용히 적게 돌려주면 「그런 파일이 없다」가 되어 버린다.
+ *
+ *   ── 왜 비동기여야 하나 ───────────────────────────────────────────────
+ *
+ *   여기 `signal?.aborted` 를 보는 줄은 오래 있었다. 그런데 훑기가 동기면
+ *   그 줄은 **부르기 전에 이미 켜져 있던 깃발**만 볼 수 있다. 깃발을 켜는
+ *   것은 이벤트 루프에 걸린 콜백인데, 동기 반복문이 도는 동안 이벤트 루프는
+ *   한 칸도 안 돈다.
+ *
+ *   그래서 「누르고 나서 시킨」 것은 멈추고 「시켜 놓고 누른」 것은 안 멈췄다.
+ *   사람이 실제로 하는 것은 뒤쪽인데. 지키는 것처럼 생겼는데 아무것도 안
+ *   지키는 줄이었다 (검사: test/abort-tools.test.js 의 4-2).
  */
-export function walk(root, { limit = 훑기상한(), skipDirs = SKIP_DIRS, ignore = true, signal = null } = {}) {
+export async function walk(root, { limit = 훑기상한(), skipDirs = SKIP_DIRS, ignore = true, signal = null } = {}) {
   const out = [];
   const 건너뜀 = { 폴더: 0, 파일: 0 };
   let 끊김 = false;
+  let 본것 = 0;
   const stack = [{ dir: root, rel: '', 규칙: ignore ? 뿌리규칙읽기(root) : [] }];
   while (stack.length && out.length < limit) {
     if (signal?.aborted) { 끊김 = true; break; }
@@ -276,7 +304,14 @@ export function walk(root, { limit = 훑기상한(), skipDirs = SKIP_DIRS, ignor
         out.push({ path: full, rel: erel, mtime: st.mtimeMs, size: st.size });
         if (out.length >= limit) break;
       }
+      // 본 것을 다 센다 — 걸러낸 것도 readdirSync·걸리나 값을 이미 치렀다.
+      본것 += 1;
+      if (본것 % 숨쉴간격 === 0) {
+        await 한숨();
+        if (signal?.aborted) { 끊김 = true; break; }
+      }
     }
+    if (끊김) break;
   }
   Object.defineProperty(out, '건너뜀', { value: 건너뜀, enumerable: false });
   // 상한까지 찼으면 "여기서 멈췄다" 고 표시한다. 딱 맞아떨어져 끝난 경우까지

package/src/tools/index.js

@@ -1,6 +1,7 @@
 // 도구. 이름과 인자를 Claude Code 와 같게 맞춘다 —
 // 그래야 그 관례로 쓰인 스킬·명령이 그대로 먹는다.
-import { writeFileSync, appendFileSync, readFileSync, existsSync, mkdirSync, statSync, renameSync, cpSync, rmSync } from 'node:fs';
+import { writeFileSync, appendFileSync, readFileSync, existsSync, mkdirSync, statSync, renameSync, cpSync, rmSync,
+  openSync, readSync, closeSync } from 'node:fs';
 import { dirname, extname, join, relative, sep } from 'node:path';
 import { 무리로돌리기 } from './spawn.js';
 import { globToRegex, walk, readText, readTextFull, 내부살림 } from './fsutil.js';
@@ -226,10 +227,37 @@ function 가린표되돌리나(보인이름, 새내용) {
   return 몇 ? 표막는말(보인이름, 몇) : null;
 }
 
+/**
+ * 파일 앞머리만 읽는다.
+ *
+ * 「글이 아닌 파일인가」 를 가리는 데 30MB 를 다 읽을 이유가 없다. 실제로
+ * looksBinary() 자체가 **앞 8000바이트만** 본다(encoding.js) — 그 뒤를 읽는
+ * 것은 답에 아무 영향이 없는 순수한 낭비다.
+ */
+function 앞머리(abs, 만큼) {
+  let fd = null;
+  try {
+    fd = openSync(abs, 'r');
+    const buf = Buffer.allocUnsafe(만큼);
+    const 읽은 = readSync(fd, buf, 0, 만큼, 0);
+    return buf.subarray(0, 읽은);
+  } catch { return null; } finally {
+    if (fd != null) { try { closeSync(fd); } catch { /* 이미 닫혔다 */ } }
+  }
+}
+
+// looksBinary 가 보는 만큼. 두 수가 어긋나면 답이 달라지므로 같이 움직여야 한다.
+const 냄새맡을바이트 = 8000;
+
+/** 파일이 몇 바이트인가. 못 재면 -1 — 그러면 들고 있던 수와 절대 안 맞는다. */
+function 파일크기(abs) {
+  try { return statSync(abs).size; } catch { return -1; }
+}
+
 function 바이너리인가(abs) {
   if (!existsSync(abs)) return null;
-  let buf;
-  try { buf = readFileSync(abs); } catch { return null; }
+  const buf = 앞머리(abs, 냄새맡을바이트);
+  if (!buf) return null;
   if (!looksBinary(buf)) return null;
   return `글이 아닌 파일입니다 — 덮어쓰면 되살릴 수 없습니다.\n`
     + '  그림·hwp·pdf·압축파일 같은 것을 글로 덮어쓰면 그 파일은 그대로 끝납니다.\n'
@@ -352,13 +380,44 @@ function 바꾸기전스냅샷(cmd, ctx) {
 }
 
 /** 지금 파일이 몇 줄인가. 붙인 뒤 '얼마나 찼는지' 를 사실로 말해 주려고 센다. */
-function 줄수(abs, 인코딩) {
+function 줄수(abs, 인코딩) { return 줄재기(abs, 인코딩).줄; }
+
+/**
+ * 줄 수와 「끝이 줄바꿈인가」 를 한 번에.
+ *
+ * 둘을 따로 재면 파일을 두 번 읽는다. 그리고 이어 붙일 때는 둘 다 필요하다 —
+ * 끝이 줄바꿈이 아니면 붙이는 첫 줄이 **마지막 줄에 이어지므로** 한 줄 덜 는다.
+ */
+function 줄재기(abs, 인코딩) {
   try {
     const buf = readFileSync(abs);
-    if (looksBinary(buf)) return 0;
+    if (looksBinary(buf)) return { 줄: 0, 끝줄바꿈: true };
     const t = 인코딩 && 인코딩 !== 'utf-8' ? decodeBytes(buf).text : buf.toString('utf8');
-    return t.split('\n').length - (t.endsWith('\n') ? 1 : 0);
-  } catch { return 0; }
+    const 끝줄바꿈 = t.length === 0 || t.endsWith('\n');
+    return { 줄: t.split('\n').length - (t.endsWith('\n') ? 1 : 0), 끝줄바꿈 };
+  } catch { return { 줄: 0, 끝줄바꿈: true }; }
+}
+
+/*
+ * ── 이어 붙일 때 줄 수를 다시 안 세려고 들고 있는 것 ─────────────────────
+ *
+ * Append 는 **한 파일에 여러 번** 불리는 것이 정상이다 — 도구 설명문이 그렇게
+ * 시킨다. 그런데 부를 때마다 「지금 전체 몇 줄」 을 대려고 파일을 통째로 읽고
+ * 해독하고 split 했다. 30MB 로그에 다섯 줄 붙이는 데 그 짓을 다섯 번 한다.
+ *
+ * 붙인 줄 수는 우리가 안다. 그러니 앞의 수에 더하면 된다.
+ *
+ * 그 수가 아직 참인지는 **바이트 수**로 가린다. 우리가 붙인 만큼만 커졌으면
+ * 우리가 아는 그 파일이다. 사람이 편집기로 갈아엎었거나 다른 도구가 건드렸으면
+ * 크기가 안 맞고, 그때는 두말없이 다시 센다. 틀린 수를 빠르게 대는 것보다
+ * 맞는 수를 느리게 대는 편이 낫다.
+ */
+const 줄기억 = new Map();
+// 파일이 수천 개씩 쌓이지는 않지만, 오래 도는 대화에서 무한정 크지도 않게 한다.
+const 줄기억최대 = 512;
+function 줄기억넣기(abs, 것) {
+  if (줄기억.size >= 줄기억최대) 줄기억.delete(줄기억.keys().next().value);
+  줄기억.set(abs, 것);
 }
 
 /**
@@ -585,7 +644,7 @@ export function 복사해옮기기(앞, 뒤, { 복사 = cpSync, 지우기 = rmSy
   return {};
 }
 
-function 한개옮기기({ from, to, overwrite = false }, ctx) {
+async function 한개옮기기({ from, to, overwrite = false }, ctx) {
   if (typeof from !== 'string' || !from) return { error: 'from 이 없습니다' };
   if (typeof to !== 'string' || !to) return { error: 'to 가 없습니다' };
 
@@ -626,7 +685,7 @@ function 한개옮기기({ from, to, overwrite = false }, ctx) {
    * 뜨는 쪽이 훨씬 나쁘다.
    */
   // 옮길 때는 .gitignore 를 안 본다 — 옮겨지는 것은 전부이고, 되돌리기도 전부를 떠야 한다.
-  const 훑은것 = 폴더인가 ? walk(앞, { ignore: false }) : null;
+  const 훑은것 = 폴더인가 ? await walk(앞, { ignore: false }) : null;
   const 짝들 = 폴더인가
     ? 훑은것.map((f) => [f.path, join(뒤, relative(앞, f.path))])
     : [[앞, 뒤]];
@@ -688,7 +747,7 @@ function 한개옮기기({ from, to, overwrite = false }, ctx) {
 }
 
 /** 여러 개를 한 번에. 하나가 막혀도 나머지는 옮기고, 무엇이 막혔는지 다 알린다. */
-function 여러개옮기기(목록, ctx) {
+async function 여러개옮기기(목록, ctx) {
   const 된것 = [];
   const 안된것 = [];
   /*
@@ -704,7 +763,7 @@ function 여러개옮기기(목록, ctx) {
    */
   const 바뀐것들 = [];
   for (const 하나 of 목록) {
-    const r = 한개옮기기(하나, ctx);
+    const r = await 한개옮기기(하나, ctx);
     if (r.error) { 안된것.push(`${하나.from ?? '?'} → ${하나.to ?? '?'}: ${r.error}`); continue; }
     된것.push(r.content);
     // 폴더를 옮겼으면 그 안의 파일 하나하나가, 아니면 옮겨 간 자리가 답이다.
@@ -755,13 +814,38 @@ function 한파일쓰기(args, ctx) {
     const existed = existsSync(abs);
     // 덮어쓰기 전 내용. 바뀐 자리를 보여주려면 지금 떠 놔야 한다.
     // 읽다 터지는 파일(바이너리 등)이면 그냥 없던 셈 친다 — 쓰는 것 자체는 막지 않는다.
-    let 이전 = null;
-    if (existed) { try { 이전 = readTextFull(abs).text; } catch { 이전 = null; } }
+    /*
+     * 읽은 것을 **통째로** 들고 있는다 — 글만 뽑고 버리지 않는다.
+     *
+     * 여기가 `.text` 만 꺼내 쓰고 `.encoding` 을 버리고 있었다. 그래서 바로
+     * 아래에서 인코딩을 다시 정할 때 볼 것이 캐시밖에 없었고, 캐시는 이
+     * 파일을 **Read 로 한 번이라도 연 적이 있을 때만** 차 있다.
+     *
+     *   「이 파일 전체를 다시 써 줘」 → 모델은 Read 없이 Write 로 간다
+     *     → 캐시가 비어 있다 → utf-8 로 때운다
+     *     → 사내 CP949 문서가 조용히 UTF-8 이 된다
+     *
+     * 화면에는 `덮어씀: 사내문서.txt (4줄)` 만 뜬다. 인코딩 표기는 「원래가
+     * utf-8 이 아닐 때」 붙는데 그 원래가 이미 틀렸으니 한 글자도 안 뜬다.
+     * 사내 뷰어에서 한글이 깨지고 .bat 이 안 도는데, 사람은 「한 줄 고쳐
+     * 달라」 고 했을 뿐이라 원인을 인코딩으로 이을 길이 없다.
+     */
+    let 읽음 = null;
+    if (existed) { try { 읽음 = readTextFull(abs); } catch { 읽음 = null; } }
+    // 덮어쓰기 전 내용. 바뀐 자리를 보여주려면 지금 떠 놔야 한다.
+    const 이전 = 읽음?.text ?? null;
     mkdirSync(dirname(abs), { recursive: true });
 
-    // 원래 있던 파일이면 그 파일이 쓰던 인코딩으로 되돌려 쓴다.
-    // 새 파일이면 UTF-8 이다 — 요즘 만드는 파일까지 옛 인코딩으로 둘 이유가 없다.
-    const 원래 = existed ? (ctx.enc?.get(abs) ?? 'utf-8') : 'utf-8';
+    /*
+     * 원래 있던 파일이면 그 파일이 **지금** 쓰는 인코딩으로 되돌려 쓴다.
+     * 새 파일이면 UTF-8 이다 — 요즘 만드는 파일까지 옛 인코딩으로 둘 이유가 없다.
+     *
+     * 캐시(ctx.enc)는 여기서 안 본다. 방금 잰 값이 있는데 캐시를 보면 두 가지가
+     * 어긋난다 — 캐시가 비면 UTF-8 로 때우고(위), 캐시가 낡으면 남이 이미
+     * UTF-8 로 바꿔 둔 파일을 CP949 라고 우기며 이모지를 거절한다. 재는 값이
+     * 있는 자리에서는 잰 값이 이긴다. Edit 도 이미 그렇게 한다.
+     */
+    const 원래 = 읽음?.encoding ?? 'utf-8';
     const 만든것 = encode(args.content, 원래);
     if (만든것.lost.length) {
       return {
@@ -1242,6 +1326,9 @@ export const TOOLS = {
       // 이어 붙이는 조각에는 앞머리 표식(BOM)이 들어가면 안 된다 — 파일 한가운데에
       // BOM 이 박히면 그 자리가 이상한 글자로 보인다. 그래서 표식 없는 이름으로 바꾼다.
       const 원래 = existed ? (ctx.enc?.get(abs) ?? 재는인코딩(abs)) : 'utf-8';
+      // 잰 것은 적어 둔다 — Read 가 하는 것과 같은 자리다. 안 적어 두면 이 파일에
+      // 붙일 때마다 인코딩을 다시 재느라 파일을 통째로 또 읽는다.
+      ctx.enc?.set?.(abs, 원래);
       const 조각인코딩 = 원래 === 'utf-8-bom' ? 'utf-8' : 원래;
       const 만든것 = encode(args.content, 조각인코딩);
       if (만든것.lost.length) {
@@ -1252,13 +1339,30 @@ export const TOOLS = {
         };
       }
 
+      /*
+       * 붙이기 **전에** 앞의 줄 수를 잡아 둔다.
+       *
+       * 들고 있던 것이 있고 크기가 그대로면 그걸 쓴다. 아니면 여기서 한 번
+       * 세고, 다음 번부터는 더하기만 한다. 없던 파일이면 앞이 0줄이다.
+       */
+      const 앞것 = !existed
+        ? { 줄: 0, 끝줄바꿈: true }
+        : (() => {
+          const 크기 = 파일크기(abs);
+          const 든것 = 줄기억.get(abs);
+          if (든것 && 든것.바이트 === 크기) return 든것;
+          const 잰것 = 줄재기(abs, 원래);
+          return { 바이트: 크기, ...잰것 };
+        })();
+
       mkdirSync(dirname(abs), { recursive: true });
       if (existed) appendFileSync(abs, 만든것.buf);
       else writeFileSync(abs, 만든것.buf);
       ctx.seen.add(abs);
 
       const 붙인줄 = args.content.split('\n').length - (args.content.endsWith('\n') ? 1 : 0);
-      const 전체줄 = 줄수(abs, 원래);
+      const 전체줄 = 앞것 ? 앞것.줄 + 붙인줄 - (앞것.끝줄바꿈 ? 0 : 1) : 줄수(abs, 원래);
+      줄기억넣기(abs, { 바이트: 파일크기(abs), 줄: 전체줄, 끝줄바꿈: args.content.endsWith('\n') });
       const 표기 = 원래 !== 'utf-8' ? ` · ${encLabel(원래)}` : '';
       return {
         content: `${existed ? '이어 붙임' : '새로 만듦'}: ${ctx.scope.show(abs)}`
@@ -1366,15 +1470,15 @@ export const TOOLS = {
         required: [],
       },
     },
-    run(args, ctx) {
+    async run(args, ctx) {
       const 목록 = Array.isArray(args.moves) ? args.moves.filter((x) => x && typeof x === 'object') : [];
       if (목록.length) {
-        return 여러개옮기기(목록.map((m) => ({ ...m, overwrite: m.overwrite ?? args.overwrite })), ctx);
+        return await 여러개옮기기(목록.map((m) => ({ ...m, overwrite: m.overwrite ?? args.overwrite })), ctx);
       }
       if (typeof args.from !== 'string' || !args.from) {
         return { error: 'from 이 없습니다. 한 개면 from·to 를, 여러 개면 moves 배열을 주세요.' };
       }
-      return 한개옮기기(args, ctx);
+      return await 한개옮기기(args, ctx);
     },
   },
 
@@ -1391,10 +1495,10 @@ export const TOOLS = {
         required: ['pattern'],
       },
     },
-    run(args, ctx) {
+    async run(args, ctx) {
       const root = args.path ? ctx.scope.resolve(args.path) : ctx.scope.root;
       const re = globToRegex(args.pattern);
-      const 전부 = walk(root, { signal: ctx.signal });
+      const 전부 = await walk(root, { signal: ctx.signal });
       // 훑다 말고 나왔으면 그렇다고 말한다. 조용히 적게 주면 「그런 파일이 없다」가 된다.
       if (전부.끊김) return { error: '중단했습니다. 폴더를 끝까지 안 훑었습니다.', 끝났다: true, 중단됨: true };
       // .gitignore 로 건너뛴 것은 수를 말한다 — 조용히 빼면 '그 파일이 없다' 로 읽힌다 (tools/ignore.js).
@@ -1526,7 +1630,7 @@ export const TOOLS = {
        */
       let files = isFile
         ? [{ path: root, rel: ctx.scope.show(root) }]
-        : walk(root, { signal: ctx.signal });
+        : await walk(root, { signal: ctx.signal });
       if (files.끊김) return { error: '중단했습니다. 폴더를 끝까지 안 훑었습니다.', 끝났다: true, 중단됨: true };
       const 안본것 = isFile ? '' : 건너뜀말(files.건너뜀, files.잘림, files.상한).trim();   // .gitignore 로 건너뛴 수 — 꼬리에 적는다
       // 훑기 상한에 걸렸으면 "일치 없음" 이라고 잘라 말하면 안 된다. 안 본 것이다.
@@ -2478,8 +2582,8 @@ async function 고친뒤진단(name, r, ctx) {
 }
 
 /** 이 폴더에서 언어 서버를 쓸 수 있나. repl 이 켤 때 한 번 물어본다. */
-export function 언어서버있나(뿌리) {
-  try { return !!프로젝트갈래(뿌리); } catch { return false; }
+export async function 언어서버있나(뿌리) {
+  try { return !!(await 프로젝트갈래(뿌리)); } catch { return false; }
 }
 
 export async function runTool(name, args, ctx) {

package/src/tools/lsp.js

@@ -179,7 +179,7 @@ async function 채비(args, ctx) {
    * 간다 — 모델은 `handleClick 어디 있어` 처럼 이름만 알고 부르는 것이 보통이라,
    * 매번 파일을 요구하면 이 도구를 쓰는 값이 사라진다.
    */
-  const 볼것 = 파일 ?? 프로젝트갈래(ctx.scope.root)?.대표파일 ?? null;
+  const 볼것 = 파일 ?? (await 프로젝트갈래(ctx.scope.root))?.대표파일 ?? null;
   if (!볼것) return { 오류: '이 폴더에서 쓸 수 있는 언어 서버가 없습니다. Grep · Outline 을 쓰세요.' };
   if (!갈래(볼것)) return { 오류: `언어 서버가 없는 갈래입니다: ${볼것}` };
 

package/src/tools/outline.js

@@ -229,14 +229,14 @@ export const OUTLINE_TOOL = {
     },
   },
 
-  run(args, ctx) {
+  async run(args, ctx) {
     const 시작 = args.path ? ctx.scope.resolve(args.path) : ctx.scope.root;
     if (!existsSync(시작)) return { error: `없는 경로입니다: ${args.path ?? '.'}` };
 
     const 하나인가 = statSync(시작).isFile();
     let 파일들 = 하나인가
       ? [{ path: 시작, rel: ctx.scope.show(시작), mtime: statSync(시작).mtimeMs }]
-      : walk(시작, { skipDirs: SKIP_DIRS, signal: ctx.signal });
+      : await walk(시작, { skipDirs: SKIP_DIRS, signal: ctx.signal });
     if (파일들.끊김) return { error: '중단했습니다. 폴더를 끝까지 안 훑었습니다.', 끝났다: true, 중단됨: true };
     const 건너뜀 = 하나인가 ? '' : 건너뜀말(파일들.건너뜀, 파일들.잘림, 파일들.상한);   // .gitignore 로 건너뛴 수 (tools/ignore.js)
 

package/src/tools/verify.js

@@ -194,13 +194,13 @@ export const VERIFY_TOOL = {
         try { abs = ctx.scope.resolve(p); } catch (e) { 볼것.push({ 없음: p, 왜: e.message }); continue; }
         if (!existsSync(abs)) { 볼것.push({ 없음: p, 왜: '파일이 없습니다' }); continue; }
         if (statSync(abs).isDirectory()) {
-          const 안것 = walk(abs, { skipDirs: SKIP_DIRS });
+          const 안것 = await walk(abs, { skipDirs: SKIP_DIRS });
           셈더하기(안것);
           for (const f of 안것) 볼것.push({ path: f.path });
         } else 볼것.push({ path: abs });      // 짚어 준 파일은 규칙과 상관없이 본다
       }
     } else {
-      const 전부 = walk(뿌리, { skipDirs: SKIP_DIRS });
+      const 전부 = await walk(뿌리, { skipDirs: SKIP_DIRS });
       셈더하기(전부);
       const 볼만한것 = 전부
         .filter((f) => ['.html', '.htm', '.css', '.json', '.js', '.mjs', '.cjs', '.py'].includes(extname(f.path).toLowerCase()));