deel-local-cli 1.8.0 → 1.12.0

package/src/tools/index.js

@@ -7,7 +7,7 @@ import { globToRegex, walk, readText, readTextFull, 내부살림 } from './fsuti
 import { 건너뜀말 } from './ignore.js';
 import { encode, label as encLabel, decode as decodeBytes, consoleCodepage, looksBinary } from './encoding.js';
 import { checkCommand, checkPaths, isMutating } from '../safety/guard.js';
-import { 띄우기, JOBS_TOOL } from './jobs.js';
+import { 띄우기, 나무끊기, 무리끊기, JOBS_TOOL } from './jobs.js';
 import { 셸명령 } from './shell.js';
 import { findMatch, applySpans, reindent, TIER_LABELS } from './edit-match.js';
 import { loadSkill } from '../skills/discover.js';
@@ -20,7 +20,7 @@ import { DEF_TOOL, REFS_TOOL } from './lsp.js';
 import { 편집후진단, 붙이기 as 진단붙이기, 데우기 } from '../lsp/diag.js';
 import { 프로젝트갈래 } from '../lsp/servers.js';
 import { allow as allowedIn } from '../agent/modes.js';
-import { 도구정의, 이름풀기 } from '../backend/mcp.js';
+import { 도구정의, 이름풀기, 열쇠뺀환경 } from '../backend/mcp.js';
 import { isExcelPath, readExcel, toText as excelText, summarize as excelSummary } from './excel.js';
 import { isDocPath, readDoc, toText as docText, summarize as docSummary, looksOldHwp, 옛hwp안내, 문서는못고침 } from './docs.js';
 import { 바꿔볼까, 직접못읽나, 변환기찾기, 글로바꾸기, 못바꿈말 } from './convert.js';
@@ -41,6 +41,15 @@ import { 지시말, 말, 세말 } from '../i18n/index.js';
  * 그 자리를 부르는 쪽마다 살피게 두면 반드시 어딘가는 빠진다.
  */
 const 이어 = (...조각들) => 조각들.filter((x) => x != null && String(x) !== '').join(' · ');
+
+/**
+ * Bash 가 한 번에 받아 두는 출력의 상한.
+ *
+ * 넘으면 Node 가 자식을 죽이고 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER' 를 준다.
+ * 그때 무엇이 일어났는지를 사람 말로 적어 줘야 한다 — 그러지 않으면 모델은
+ * 같은 명령을 그대로 다시 부른다.
+ */
+const 출력상한 = 8 * 1024 * 1024;
 import { 표몇군데, 표막는말 } from '../safety/secrets.js';
 
 /*
@@ -514,6 +523,38 @@ function pdf읽기(abs, ctx) {
  * **손대지 않는다** — 옮겨진 자리에 그대로 남는다. 되돌아가지는 않지만
  * 없어지지도 않는다. 안전망이 파일을 지우는 것보다 이쪽이 낫다.
  */
+/*
+ * ── 복사와 지우기를 한 try 로 묶으면 안 된다 ──────────────────────────────
+ *
+ * 드라이브가 다르면(EXDEV) rename 이 안 되니 복사하고 원본을 지운다. 그 둘을
+ * 한 try 에 묶어 두면 **복사는 다 됐는데 원본을 못 지운** 경우까지 「못
+ * 옮겼습니다」가 된다. 윈도우에서 아주 흔하다 — 원본 폴더 안의 파일 하나를
+ * 편집기나 탐색기가 잡고 있으면 EPERM/EBUSY 로 rmSync 만 깨진다.
+ * 그때 화면은 실패라고 말하는데 실제로는 **양쪽에 다 있다.** 사람은 실패로
+ * 알고 다시 옮기고, 원본은 계속 남는다.
+ *
+ * 세 결과는 서로 다른 말이므로 서로 다르게 돌려준다.
+ *   {}                  다 됐다
+ *   { 복사깨짐: 까닭 }   닿은 자리가 반쯤 됐다 — 실패다
+ *   { 원본남음: 까닭 }   닿은 자리는 다 됐고 원본이 남았다 — 실패가 아니다
+ *
+ * fs 를 밖에서 넣을 수 있게 해 둔 것은 검사 때문이다. 진짜 EXDEV 와 진짜
+ * '지우기만 깨짐' 은 어느 PC 에서나 똑같이 만들어 낼 수 없다.
+ */
+export function 복사해옮기기(앞, 뒤, { 복사 = cpSync, 지우기 = rmSync } = {}) {
+  try {
+    복사(앞, 뒤, { recursive: true });
+  } catch (err) {
+    return { 복사깨짐: err.message };
+  }
+  try {
+    지우기(앞, { recursive: true, force: true });
+  } catch (err) {
+    return { 원본남음: err.message };
+  }
+  return {};
+}
+
 function 한개옮기기({ from, to, overwrite = false }, ctx) {
   if (typeof from !== 'string' || !from) return { error: 'from 이 없습니다' };
   if (typeof to !== 'string' || !to) return { error: 'to 가 없습니다' };
@@ -573,6 +614,7 @@ function 한개옮기기({ from, to, overwrite = false }, ctx) {
   }
 
   mkdirSync(dirname(뒤), { recursive: true });
+  let 원본남음 = null;
   try {
     renameSync(앞, 뒤);
   } catch (err) {
@@ -582,19 +624,23 @@ function 한개옮기기({ from, to, overwrite = false }, ctx) {
      * 복사 도중에 끊기면 양쪽에 반씩 남기 때문이다.
      */
     if (err.code !== 'EXDEV') return { error: `못 옮겼습니다: ${err.message}` };
-    try {
-      cpSync(앞, 뒤, { recursive: true });
-      rmSync(앞, { recursive: true, force: true });
-    } catch (err2) {
-      return { error: `못 옮겼습니다: ${err2.message}` };
+    const 벌어진일 = 복사해옮기기(앞, 뒤);
+    if (벌어진일.복사깨짐) {
+      // 닿은 자리를 여기서 지우지 않는다 — 이미 있던 폴더로 옮기는 중이었으면
+      // 남의 파일까지 지운다. 어디에 반쯤 남았는지만 정확히 말한다.
+      return { error: `못 옮겼습니다: ${벌어진일.복사깨짐}\n(옮기다 만 것이 ${ctx.scope.show(뒤)} 에 남아 있을 수 있습니다 — 지우기 전에 확인하세요)` };
     }
+    원본남음 = 벌어진일.원본남음 ?? null;
   }
 
   for (const [, b] of 짝들) ctx.seen.add(b);
   const 무엇 = 폴더인가 ? `폴더 ${짝들.length}개 파일` : '';
-  const 경고 = 되돌리기반쪽
+  const 경고 = (되돌리기반쪽
     ? `\n(파일이 ${훑은것.상한.toLocaleString('en-US')}개를 넘어 되돌리기에는 앞부분만 떴습니다 — 옮기기는 전부 됐지만 /undo 는 다 못 되돌립니다)`
-    : '';
+    : '')
+    + (원본남음
+      ? `\n(닿은 자리에는 다 옮겼는데 원본을 못 지웠습니다 — 지금 ${ctx.scope.show(앞)} 에도 그대로 있습니다: ${원본남음})`
+      : '');
   return {
     content: `옮김: ${ctx.scope.show(앞)} → ${ctx.scope.show(뒤)}${무엇 ? ` (${무엇})` : ''}${경고}`,
     summary: `${ctx.scope.show(뒤)}`,
@@ -1042,14 +1088,39 @@ export const TOOLS = {
        */
       const 준줄수 = slice.length;
       const 다못줌 = start + count < lines.length || start > 0;
+      const 통째로 = body + more + 줄인것.알림;
+      const 실린것 = clip(통째로);
       return {
-        content: clip(body + more + 줄인것.알림),
+        content: 실린것,
+        /*
+         * 어느 파일을 읽었는지 알려 준다 — 대화에 실을 때 앞서 읽은 것과
+         * 견주려면 열쇠가 있어야 한다(agent/filemem.js).
+         *
+         * `부분인가` 는 **우리가 들고 있는 것이 파일 전부가 아니다** 는 뜻이다.
+         * 줄로 잘렸든(offset·limit·창 상한), 그림을 줄였든, clip 에 걸렸든
+         * 마찬가지다. 조각을 기억해 두고 나중에 「그대로입니다」 라고 하면
+         * 모델은 안 본 데를 봤다고 여긴다 — 줄이려다 잃는 자리다.
+         */
+        읽은것: abs,
+        부분인가: 다못줌 || 줄인것.줄인바이트 > 0 || 실린것.length < 통째로.length,
         summary: 이어(
           다못줌
             ? `${말('sum.linesOf', { 준: 준줄수, 전체: lines.length })} (${말('sum.partial')})`
             : 세말('lines', lines.length),
           줄인것.줄인바이트 ? 말('sum.imageDropped', { 크기: 몇KB(줄인것.줄인바이트) }) : '',
-          별난인코딩 ? encLabel(읽음.encoding) : '',
+          /*
+           * 짐작한 인코딩은 짐작이라고 적는다.
+           *
+           * 앞머리 표식(BOM)이 없고 UTF-8 규칙에도 안 맞으면 남은 길은 내용을
+           * 보고 점수를 매기는 것뿐이다 (encoding.js 의 detect). CP949 와
+           * CP932 는 바이트 범위가 겹쳐서 짧은 파일일수록 자주 뒤집힌다.
+           * 여태 그 확신도(sure)를 재 놓고 아무 데서도 안 읽어서, 화면에는
+           * 짐작이 사실처럼 `CP949` 한 낱말로 떴다. 사람은 잘 읽힌 줄 알고
+           * 그 위에서 고치고, 그때 원본이 상한다.
+           */
+          읽음.sure
+            ? (별난인코딩 ? encLabel(읽음.encoding) : '')
+            : 말('sum.encGuess', { 인코딩: encLabel(읽음.encoding) }),
         ),
       };
     },
@@ -1617,9 +1688,29 @@ export const TOOLS = {
         // '�Ľ� ����' 이 된다. 바이트로 받아 이 컴퓨터가 쓰는 것으로 해독한다.
         const kid = execFile(shell.file, shell.args, {
           cwd: ctx.scope.root,
-          timeout: 제한,
-          maxBuffer: 8 * 1024 * 1024,
+          // 열쇠만 빼고 나머지는 그대로 물려준다 (backend/mcp.js 열쇠뺀환경 머리말).
+          // 안 빼면 `env` 한 줄이 열쇠를 화면과 대화 기록에 그대로 싣는다.
+          env: 열쇠뺀환경(),
+          // 우리 시계(아래 뒷북)가 제한에서 먼저 나무를 끊는다. 이건 그것마저
+          // 못 돌았을 때 서는 마지막 그물이라 뒤에 세운다.
+          timeout: 제한 + 3000,
+          maxBuffer: 출력상한,
           windowsHide: true,
+          /*
+           * 유닉스에서는 **무리를 만들어 둔다.**
+           *
+           * 나중에 만들어 줄 방법이 없어서 띄우는 순간에 정해야 한다. 안 만들면
+           * 나중에 손자를 가리킬 길이 아예 없다 — `sh -c "cd app && npm start"`
+           * 처럼 복합 명령이면 sh 가 exec 로 갈아치우지 않고 fork 하므로,
+           * kid.kill() 은 sh 만 죽이고 npm·node·vite 는 포트를 문 채로 남는다.
+           * 화면에는 「시간 초과로 중단됨」 이 뜬다. 이 도구가 없애려던 바로 그
+           * 상태다.
+           *
+           * 윈도우에서는 반대로 안 만든다 — 거기서 detached 는 새 콘솔 창을
+           * 띄우는 쪽으로 작동해서, 조용히 돌아야 할 것이 화면에 튀어나온다.
+           * 윈도우는 taskkill /t 가 나무를 훑는다. (jobs.js 띄우기옵션 과 같은 판단)
+           */
+          detached: process.platform !== 'win32',
           windowsVerbatimArguments: shell.verbatim === true,
           encoding: 'buffer',
         }, (err, stdoutBuf, stderrBuf) => {
@@ -1636,7 +1727,9 @@ export const TOOLS = {
           const out = [stdout, stderr].filter(Boolean).join('\n').trim();
 
           if (끊겼나) return done({ error: '사용자가 중단했습니다', content: clip(out) });
-          if (err && err.killed) return done({ error: `시간 초과로 중단됨 (${제한}ms)`, content: clip(out) });
+          if (시간초과 || (err && err.killed)) {
+            return done({ error: `시간 초과로 중단됨 (${제한}ms)`, content: clip(out) });
+          }
 
           /*
            * 결과를 사실대로 말한다.
@@ -1648,15 +1741,39 @@ export const TOOLS = {
            * 종료코드도 모델에게 준다. 전에는 화면에만 적고 대화에는 안 실었다.
            * 그러면 모델은 명령이 실패한 줄 모른 채 다음 단계로 넘어간다.
            */
+          /*
+           * err.code 가 **늘 종료코드인 것은 아니다.**
+           *
+           * 프로세스가 0 이 아닌 값으로 끝나면 숫자가 온다. 그런데 Node 자신이
+           * 못 견뎌서 끝낸 경우에는 글자가 온다 —
+           * 출력이 maxBuffer 를 넘으면 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER',
+           * 명령을 못 찾으면 'ENOENT'.
+           *
+           * 그걸 그대로 종료코드로 썼다. 그래서 12MB 를 뱉는 명령을 부르면
+           * 화면과 모델이 「종료코드 ERR_CHILD_PROCESS_STDIO_MAXBUFFER」 라는
+           * 뜻 모를 말을 받았다. exitCode 가 숫자가 아니라 글자로 나가는 것도
+           * 규격 위반이고, 무엇보다 **무엇을 고쳐야 하는지가 어디에도 없어서**
+           * 모델이 같은 명령을 그대로 다시 부른다.
+           */
           const 시그널 = err?.signal ?? null;
-          const code = 시그널 ? null : (err?.code ?? 0);
-          const 잘됨 = !시그널 && code === 0;
-          const 꼬리 = 잘됨 ? '' : 시그널 ? `\n\n[${시그널} 시그널로 죽었습니다 — 정상 종료가 아닙니다]` : `\n\n[종료코드 ${code}]`;
+          const 넘침 = err?.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER';
+          const 숫자코드 = typeof err?.code === 'number' ? err.code : null;
+          const 글자코드 = typeof err?.code === 'string' ? err.code : null;
+          const code = (시그널 || (err && 숫자코드 === null)) ? null : (숫자코드 ?? 0);
+          const 잘됨 = !err && !시그널;
+          const 꼬리 = 잘됨 ? ''
+            : 시그널 ? `\n\n[${시그널} 시그널로 죽었습니다 — 정상 종료가 아닙니다]`
+              : 넘침 ? `\n\n[출력이 ${출력상한 / (1024 * 1024)}MB 를 넘어 받다 말았습니다 — 명령을 끝까지 못 봤습니다.`
+                + ' `| head -n 200` 처럼 줄이거나 파일로 받아서 다시 부르세요]'
+                : 숫자코드 === null ? `\n\n[${글자코드} — 명령을 아예 못 돌렸습니다]`
+                  : `\n\n[종료코드 ${code}]`;
           done({
             content: clip(out || '(출력 없음)') + 꼬리,
             summary: 잘됨 ? 말('sum.ok')
               : 시그널 ? 말('sum.killedBy', { 시그널 })
-                : 말('sum.exitCode', { code }),
+                : 넘침 ? 말('sum.tooMuchOut')
+                  : 숫자코드 === null ? 말('sum.cantRun', { 왜: 글자코드 })
+                    : 말('sum.exitCode', { code }),
             failed: !잘됨,
             exitCode: code,
             signal: 시그널,
@@ -1672,23 +1789,71 @@ export const TOOLS = {
          * Ctrl+C 는 다음 요청에나 반영됐다. 터미널을 닫는 수밖에 없었다.
          */
         let 끊겼나 = false;
-        const 죽이기 = () => {
-          // 윈도우에서는 자식만 죽이면 손자가 남는다. 트리째 끝내야 한다.
-          // 그리고 **트리 죽이기를 먼저** 한다 — cmd 를 먼저 죽이면 트리의 뿌리가
-          // 없어져서 taskkill 이 손자를 못 찾는다. 그러면 손자가 그대로 남아 돈다.
+        let 시간초과 = false;
+        const 죽이기 = ({ 파이프끊기 = true, 더줄까 = 0 } = {}) => {
+          /*
+           * 윈도우에서는 자식만 죽이면 손자가 남는다. 트리째 끝내야 한다.
+           *
+           * 그리고 **기다린다.** 전에는 execFile(비동기)로 불렀는데, 그러면
+           * 바로 아래 kid.kill() 이 먼저 돌아 cmd 를 죽인다. 나무의 뿌리가
+           * 없어진 뒤에 taskkill 이 뜨므로 손자 — `npm run dev` 의 진짜
+           * 서버 — 를 못 찾고, 그놈은 그대로 남아 포트를 문다. 「먼저 부른다」
+           * 는 비동기에서는 「먼저 돈다」 가 아니다.
+           *
+           * jobs.js 의 나무죽이기() 가 이미 같은 자리에서 같은 결론에 닿았다.
+           * 여기만 그 교훈 밖에 있었다.
+           *
+           * ── 판단은 베끼지 않고 **가져다 쓴다** ─────────────────────────
+           *
+           * 전에는 여기서 taskkill 오류를 통째로 삼켰다. 잘린 것과 이미 죽은
+           * 것을 안 가른 채 곧장 뿌리(cmd.exe)를 죽였으니, 컴퓨터가 바쁘면
+           * 손자가 남고 화면에는 「중단됨」 이 떴다. jobs.js 는 그 구분을
+           * 갖고 있었는데 여기만 없었다 — 같은 판단이 두 벌로 있으면 늘
+           * 한쪽만 고쳐진다. 그래서 이제 그 함수 하나를 같이 쓴다.
+           *
+           * 여기는 jobs.js 와 달리 **다시 올 자리가 없다.** 이 부름은 지금
+           * 끝난다. 그러니 못 훑었으면 한 번 더 준 다음 뿌리를 죽인다.
+           * 뿌리를 그냥 살려 두면 이번에는 cmd.exe 까지 남는다.
+           *
+           * 더 줄 시간은 **부르는 쪽이 정한다.** 여기는 동기라 기다리는 동안
+           * 화면이 멈춘다. 시간 초과는 어차피 기다리던 자리라 넉넉히 줘도
+           * 되지만, Ctrl+C 는 사람이 지금 당장 돌려받고 싶어 누른 것이다.
+           * 거기서 몇 초를 더 얼리면 「안 멈춘다」 고 또 누르게 된다 —
+           * 손자를 살리려다 사람을 붙잡는 셈이라, 그 자리는 짧게 준다.
+           */
           if (process.platform === 'win32' && kid.pid) {
-            try { execFile('taskkill', ['/pid', String(kid.pid), '/t', '/f'], { windowsHide: true }, () => {}); } catch {}
+            if (!나무끊기(kid.pid, 1500) && 더줄까 > 0) 나무끊기(kid.pid, 더줄까);
+          } else if (kid.pid) {
+            /*
+             * 유닉스는 무리째 끊는다. 위 detached 와 짝이다.
+             *
+             * 한동안 이 갈래가 통째로 없었다. 윈도우 쪽만 고쳐 놓고 「중단하면
+             * 진짜 멈춘다」 를 판 소개에 적었는데, 유닉스에서는 sh 만 죽고
+             * 그 아래가 그대로 남아 있었다. 검사가 초록이었던 것도 까닭이
+             * 있다 — 검사가 쓰는 명령이 `node ticker.cjs` 하나뿐이라
+             * 유닉스 sh 가 그걸 exec 로 갈아치웠고, 애초에 손자가 안 생겼다.
+             */
+            무리끊기(kid.pid);
           }
           try { kid.kill(); } catch {}
           // 죽이라고 시켰다고 곧바로 죽는 것은 아니다. 그동안 이 프로세스가
           // 그 손을 붙들고 있으면 deel 을 끝내도 안 끝난다 — 실제로 검사가
           // 60초를 더 기다렸다. 놓아 주고 우리 갈 길을 간다.
           try { kid.unref(); } catch {}
-          try { kid.stdout?.destroy(); kid.stderr?.destroy(); } catch {}
+          /*
+           * 파이프는 부르는 쪽이 고른다.
+           *
+           * 끊으면 이벤트 루프를 안 붙잡아서 좋은데, 그 순간 아직 안 읽힌
+           * 것이 통째로 사라진다. 하필 그게 제일 중요한 몇 줄이다 — 서버가
+           * 뻗으며 남긴 스택 트레이스가 거기 있다. 시간 초과에서는 그 몇
+           * 줄을 받아야 하므로 안 끊는다. (jobs.js 의 끝내기() 와 같은 판단)
+           */
+          if (파이프끊기) { try { kid.stdout?.destroy(); kid.stderr?.destroy(); } catch {} }
         };
         const 끊기 = () => {
           끊겼나 = true;
-          죽이기();
+          // Ctrl+C 는 짧게 — 사람이 지금 돌려받으려고 누른 것이다.
+          죽이기({ 더줄까: 1200 });
           clearTimeout(뒷북);
           // 콜백을 기다리지 않는다. 손자가 파이프를 물고 있으면 안 불릴 수도 있다.
           done({ error: '사용자가 중단했습니다' });
@@ -1697,17 +1862,35 @@ export const TOOLS = {
         else ctx.signal?.addEventListener?.('abort', 끊기, { once: true });
 
         /*
-         * execFile 의 timeout 을 못 믿는 자리가 있다.
+         * ── 시간 초과는 **우리가** 끊는다 ───────────────────────────────
+         *
+         * execFile 의 timeout 은 바로 아래 자식(윈도우면 cmd.exe)에게만
+         * 시그널을 보낸다. 손자는 안 건드린다. 그래서 오래 이랬다 —
+         *
+         *   Bash(npm run dev)  → 시간 초과로 중단됨 (120000ms)
+         *   실제로는           → 서버가 그대로 돌면서 포트를 물고 있다
+         *
+         * 화면에는 「중단됨」 이 뜨는데 프로세스는 살아 있다. 무엇이 포트를
+         * 물고 있는지 알 길이 없는, 이 프로그램이 없애려던 바로 그 상태다.
          *
-         * 손자 프로세스가 파이프를 물고 있으면 부모를 죽여도 stdout 이 안 닫혀서
-         * 콜백이 안 불린다. 그러면 제 시간 제한이 있는데도 영영 안 끝난다.
-         * 그래서 우리 쪽에서도 시계를 하나 걸고, 넘으면 트리째 끝낸다.
+         * 그렇다고 콜백에서 뒤늦게 나무를 끊어도 소용없다. 그때는 cmd 가
+         * 이미 죽어 나무의 뿌리가 없어서 taskkill 이 손자를 못 찾는다.
+         * **cmd 가 살아 있는 동안** 끊어야 한다. 그래서 우리 시계를 제한에
+         * 두고, execFile 의 timeout 은 그 뒤에 서는 마지막 그물로 남긴다.
+         *
+         * 끊고 나서 곧장 끝맺지 않는다. 나무가 끊기면 대개 곧바로 콜백이
+         * 오는데, 그때라야 죽기 직전에 나온 몇 줄을 같이 실어 줄 수 있다.
+         * 그것마저 안 오면 아래 그물이 대신 끝맺는다.
          */
         const 뒷북 = setTimeout(() => {
           if (끝났나 || 끊겼나) return;
-          죽이기();
-          done({ error: `시간 초과로 중단됨 (${제한}ms) — 자식 프로세스가 안 끝나 강제로 끝냈습니다` });
-        }, 제한 + 2000);
+          시간초과 = true;
+          죽이기({ 파이프끊기: false, 더줄까: 4000 });
+          const 그물 = setTimeout(() => {
+            done({ error: `시간 초과로 중단됨 (${제한}ms) — 자식 프로세스가 안 끝나 강제로 끝냈습니다` });
+          }, 1000);
+          그물.unref?.();
+        }, 제한);
         // 이 시계 때문에 프로그램이 안 끝나면 안 된다.
         뒷북.unref?.();
       });
@@ -2269,8 +2452,28 @@ export async function runTool(name, args, ctx) {
      * 그러면 같은 편집이 두 번 들어가거나, 되돌리기 기록과 어긋난다.
      * 읽기만 한 것은 버려도 잃을 것이 없으니 중단으로 끝낸다.
      */
+    /*
+     * 바꿔 놨는지는 **도구가 무엇을 돌려줬나**로 판단한다. 이름으로 짐작하면 안 된다.
+     *
+     * 전에는 `isMutating(name)` 이었다. isMutating 은 **셸 명령줄**을 받아
+     * `mv|cp|rm|git commit…` 을 찾는 함수인데(safety/guard.js), 거기에 도구
+     * 이름을 넣고 있었다. 그래서 `Move` 만 우연히 참이 되고 Write·Edit·
+     * Append·Bash 는 전부 거짓이었다 — 바로 위 주석이 지키겠다고 적은
+     * 도구들이 통째로 빠져 있었다.
+     *
+     * 그 결과가 이렇다. 파일을 다 쓰고 난 뒤 ESC 를 누르면 화면과 모델은
+     * 「중단했습니다」 만 받는다. changed 가 같이 떨어져 나가서 턴 끝의 파일
+     * 목록에도, /diff 에도 안 잡힌다. 그런데 디스크는 이미 바뀌어 있고
+     * 되돌리기 기록에도 올라가 있다. 모델은 안 고쳐진 줄 알고 또 고친다.
+     *
+     * 결과를 보면 짐작할 것이 없다. changed 가 있으면 한 파일을 바꾼 것이고,
+     * 바뀐것들·여럿 이 있으면 여러 개를 바꾼 것이다.
+     */
     if (ctx.signal?.aborted) {
-      if (!isMutating(name) || r.error) {
+      const 바꿔놨나 = !!(r.changed
+        || r.바뀐것들?.length
+        || (Array.isArray(r.여럿) && r.여럿.some((x) => x?.ok && x.path)));
+      if (!바꿔놨나 || r.error) {
         return { error: '중단했습니다.', 끝났다: true, 중단됨: true };
       }
       return { ...r, 중단됨: true, 중단전에끝남: true };
@@ -2301,7 +2504,9 @@ async function runMcpTool(name, args, ctx) {
     if (!서버) return { error: `${갈린것.서버} 서버가 붙어 있지 않습니다 — /mcp 로 확인하세요` };
     if (!서버.살아있나()) return { error: `${갈린것.서버} 서버가 죽었습니다: ${서버.죽음 ?? '이유 모름'}` };
     try {
-      const out = await 서버.부르기(갈린것.도구, args);
+      // 사람이 누른 ESC 를 남의 프로그램에까지 데려간다. 안 넘기면 도구 한 번에
+      // 60초(부르기제한)를 꼬박 기다리는데, 그 사이 ESC 는 아무 일도 안 한다.
+      const out = await 서버.부르기(갈린것.도구, args, { signal: ctx?.signal ?? null });
       if (out.isError) return { error: out.text || '도구가 오류를 냈습니다' };
       const 글 = out.text ?? '';
       const 줄 = 글 ? 글.split(/\r?\n/).length : 0;