deel-local-cli 1.6.1 → 1.6.3

package/src/tools/desc.en.js

@@ -134,12 +134,16 @@ export const 도구설명EN = {
     },
   },
   Ask: {
-    desc: 'Ask the person one question at a genuine fork. Never write "let me know" and stop;'
-      + ' asking in prose ends the turn and throws away everything you have looked at.'
-      + ' Give 2-4 options and they answer with a single number.'
+    desc: 'Ask the person one question at a genuine fork. **First fill in `이해` with what you'
+      + ' understood this request to be**, and only ask if something is genuinely left to decide.'
+      + ' Never write "let me know" and stop; asking in prose ends the turn and throws away'
+      + ' everything you have looked at. Give 2-4 options and they answer with a single number.'
       + ' **Never ask back something the user already said.** "Tidy up the files" is the answer —'
       + ' go and do it. Deciding how is your job, not theirs.',
     params: {
+      이해: 'one line: what you understood this request to be. The person reads this line to judge'
+        + ' whether you actually read them. "I understand your request" is not an understanding —'
+        + ' name the actual work',
       question: 'one sentence. Make it clear what has to be decided',
       options: '2-4 choices, one line each, so the difference is visible',
     },

package/src/tools/fastgrep.js

@@ -24,6 +24,7 @@
 //      결과가 없는 것이 아니라 우리가 못 물어본 것이다. 그때 '일치 없음' 을
 //      돌려주면 사람은 없는 줄 안다. 그래서 실패는 실패로 두고 JS 로 다시 찾는다.
 import { spawnSync } from 'node:child_process';
+import { 돌려보기 } from './spawn.js';
 import { join } from 'node:path';
 
 /*
@@ -99,7 +100,7 @@ export function 저장소인가(폴더) {
  *
  * @returns {{ok:true, 줄들:string[], 잘림:boolean} | {ok:false, 왜:string}}
  */
-export function rg로찾기({ 무늬, 자리, glob = null, 대소문자무시 = false, 무시파일 = null, 최대 = 5000, timeout = 20000 }) {
+export async function rg로찾기({ 무늬, 자리, glob = null, 대소문자무시 = false, 무시파일 = null, 최대 = 5000, timeout = 20000, signal = null }) {
   const 인자 = [
     '--line-number',
     '--no-heading',
@@ -132,9 +133,7 @@ export function rg로찾기({ 무늬, 자리, glob = null, 대소문자무시 =
   // `--` 뒤로 넘겨서 무늬가 옵션으로 안 읽히게 한다. `-foo` 같은 무늬가 실제로 있다.
   인자.push('--regexp', 무늬, '--', 자리);
 
-  const r = spawnSync('rg', 인자, {
-    encoding: 'utf8', timeout, windowsHide: true, maxBuffer: 32 * 1024 * 1024,
-  });
+  const r = await 돌려보기('rg', 인자, { timeout, signal });
   // rg 는 못 찾으면 1, 진짜 탈이 나면 2 를 준다. 1 은 성공(빈 결과)이다.
   if (r.error) return { ok: false, 왜: r.error.message };
   if (r.status === 2) return { ok: false, 왜: (r.stderr ?? '').split('\n')[0] || 'rg 가 무늬를 못 읽었습니다' };
@@ -143,14 +142,12 @@ export function rg로찾기({ 무늬, 자리, glob = null, 대소문자무시 =
 }
 
 /** `git grep` 으로 찾는다. rg 가 없고 여기가 저장소일 때. */
-export function git로찾기({ 무늬, 자리, 대소문자무시 = false, 최대 = 5000, timeout = 20000 }) {
+export async function git로찾기({ 무늬, 자리, 대소문자무시 = false, 최대 = 5000, timeout = 20000, signal = null }) {
   const 인자 = ['-C', 자리, '--no-pager', 'grep', '--line-number', '--no-color', '-I', '-E'];
   if (대소문자무시) 인자.push('-i');
   // 여기도 같은 목록으로 뺀다. git 은 경로무늬 앞머리에 마법을 붙여 빼낸다.
   인자.push('-e', 무늬, '--', '.', ...안볼확장자.map((x) => `:(exclude,icase)*.${x}`));
-  const r = spawnSync('git', 인자, {
-    encoding: 'utf8', timeout, windowsHide: true, maxBuffer: 32 * 1024 * 1024,
-  });
+  const r = await 돌려보기('git', 인자, { timeout, signal });
   if (r.error) return { ok: false, 왜: r.error.message };
   if (r.status !== 0 && r.status !== 1) {
     return { ok: false, 왜: (r.stderr ?? '').split('\n')[0] || 'git grep 이 무늬를 못 읽었습니다' };
@@ -191,10 +188,10 @@ export function 줄가르기(줄) {
  *
  * @returns {{엔진:string, 줄들:Array<{파일,줄,내용}>, 잘림:boolean} | null}
  */
-export function 빠르게찾기({ 무늬, 자리, glob = null, 대소문자무시 = false, 무시파일 = null, 최대 = 5000 }) {
+export async function 빠르게찾기({ 무늬, 자리, glob = null, 대소문자무시 = false, 무시파일 = null, 최대 = 5000, signal = null }) {
   const 것 = 엔진찾기();
   if (것.rg) {
-    const r = rg로찾기({ 무늬, 자리, glob, 대소문자무시, 무시파일, 최대 });
+    const r = await rg로찾기({ 무늬, 자리, glob, 대소문자무시, 무시파일, 최대, signal });
     if (r.ok) return { 엔진: 'rg', 줄들: r.줄들.map(줄가르기).filter(Boolean), 잘림: r.잘림 };
     // rg 가 무늬를 못 읽은 것일 수 있다(Rust regex 에는 되돌아보기가 없다).
     // 그건 '없다' 가 아니라 '못 물어봤다' 이므로 예전 길로 내려간다.
@@ -203,7 +200,7 @@ export function 빠르게찾기({ 무늬, 자리, glob = null, 대소문자무
   // git grep 은 .deelignore 를 시킬 방법이 없다. 그 파일이 있으면 예전 길로 간다 —
   // 사람이 "deel 은 여기 보지 마라" 고 적어 둔 것을 못 지키면 빠른 것이 뜻이 없다.
   if (것.gitgrep && !무시파일 && 저장소인가(자리)) {
-    const r = git로찾기({ 무늬, 자리, 대소문자무시, 최대 });
+    const r = await git로찾기({ 무늬, 자리, 대소문자무시, 최대, signal });
     if (r.ok) return { 엔진: 'git grep', 줄들: r.줄들.map(줄가르기).filter(Boolean), 잘림: r.잘림 };
     return null;
   }

package/src/tools/fsutil.js

@@ -175,11 +175,22 @@ export function 훑기상한(env = process.env) {
   return Math.floor(n);
 }
 
-export function walk(root, { limit = 훑기상한(), skipDirs = SKIP_DIRS, ignore = true } = {}) {
+/**
+ * 폴더를 훑는다.
+ *
+ * @param {AbortSignal|null} signal 멈추라면 훑다 말고 나온다.
+ *   사내망 드라이브에서는 파일 20,000개 훑기가 몇 초다. 그 사이에
+ *   ESC 를 눌렀는데 끝까지 다 훑고 나서 멈추면, 사람 눈에는 멈추지
+ *   않는 것으로 보인다. 나온 것에 `끊김` 을 달아 부르는 쪽이 알게 한다 —
+ *   조용히 적게 돌려주면 「그런 파일이 없다」가 되어 버린다.
+ */
+export function walk(root, { limit = 훑기상한(), skipDirs = SKIP_DIRS, ignore = true, signal = null } = {}) {
   const out = [];
   const 건너뜀 = { 폴더: 0, 파일: 0 };
+  let 끊김 = false;
   const stack = [{ dir: root, rel: '', 규칙: ignore ? 뿌리규칙읽기(root) : [] }];
   while (stack.length && out.length < limit) {
+    if (signal?.aborted) { 끊김 = true; break; }
     const { dir, rel, 규칙 } = stack.pop();
     let entries;
     try { entries = readdirSync(dir, { withFileTypes: true }); } catch { continue; }
@@ -211,6 +222,7 @@ export function walk(root, { limit = 훑기상한(), skipDirs = SKIP_DIRS, ignor
   // 사람을 한 번 더 보게 만들 뿐이고, 다 봤다고 말하는 것은 못 보게 만든다.
   Object.defineProperty(out, '잘림', { value: out.length >= limit, enumerable: false });
   Object.defineProperty(out, '상한', { value: limit, enumerable: false });
+  Object.defineProperty(out, '끊김', { value: 끊김, enumerable: false });
   return out;
 }
 

package/src/tools/index.js

@@ -24,6 +24,7 @@ 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';
+import { 물음검사 } from '../agent/askcheck.js';
 import { isPdfPath, readPdf, toText as pdfText, summarize as pdfSummary, 못읽은말, pdf는못고침, 한쪽도못읽음말 } from './pdf.js';
 import { diffLines } from '../ui/diff.js';
 import { 읽을줄수, 찾을개수, 찾을줄수, 설명길이 } from '../agent/budget.js';
@@ -337,7 +338,7 @@ async function 엑셀읽기(abs, args, ctx) {
      * LibreOffice 가 있으면 그것이 곧 길이다. 표는 아니고 글이지만,
      * 아무것도 못 읽는 것보다 낫다.
      */
-    const 빌린것 = 빌려읽기(abs, ctx, r.error);
+    const 빌린것 = await 빌려읽기(abs, ctx, r.error);
     if (빌린것) return 빌린것;
     if (직접못읽나(abs)) return { error: 못바꿈말(ctx.scope.show(abs), extname(abs)), 끝났다: true };
     return { error: r.error };
@@ -376,7 +377,7 @@ async function 엑셀읽기(abs, args, ctx) {
  *
  * @returns {object|null} 읽어냈으면 도구 결과. 못 하면 null (부르는 쪽이 원래 오류를 낸다)
  */
-function 빌려읽기(abs, ctx, 원래오류) {
+async function 빌려읽기(abs, ctx, 원래오류) {
   if (!바꿔볼까(abs)) return null;
   const root = ctx.scope?.root;
   if (!root) return null;
@@ -386,7 +387,9 @@ function 빌려읽기(abs, ctx, 원래오류) {
   const 있는것 = ctx.변환기 ?? 변환기찾기();
   if (!있는것.soffice && !있는것.textutil) return null;
 
-  const r = 글로바꾸기(abs, root, { 찾은것: 있는것 });
+  // signal 을 같이 넘긴다. 멈추라고 하면 soffice 를 죽여야 한다 — 안 그러면
+  // ESC 를 듣고도 남은 90초를 그대로 기다린다.
+  const r = await 글로바꾸기(abs, root, { 찾은것: 있는것, signal: ctx.signal ?? null });
   if (!r.ok || !r.text.trim()) return null;
 
   const 줄수 = r.text.split('\n').length;
@@ -400,11 +403,11 @@ function 빌려읽기(abs, ctx, 원래오류) {
   };
 }
 
-function 문서읽기(abs, ctx) {
+async function 문서읽기(abs, ctx) {
   const r = readDoc(abs);
   if (!r.ok) {
     // 우리가 못 읽는다고 끝이 아니다. 이 PC 에 변환기가 있으면 빌려 본다.
-    const 빌린것 = 빌려읽기(abs, ctx, r.error);
+    const 빌린것 = await 빌려읽기(abs, ctx, r.error);
     if (빌린것) return 빌린것;
     // 끝났다 를 그대로 넘긴다. 여기서 떨구면 docs.js 가 「다시 열어도 같다」고
     // 판정해 놓은 것이 루프까지 못 가서, 되풀이 억제가 안 걸린다.
@@ -585,10 +588,24 @@ function 한개옮기기({ from, to, overwrite = false }, ctx) {
 function 여러개옮기기(목록, ctx) {
   const 된것 = [];
   const 안된것 = [];
+  /*
+   * ── 무엇이 움직였는지 모아서 돌려준다 ──────────────────────────────
+   *
+   * 여기서 한 개짜리 결과의 `changed` 를 버리고 있었다. 그래서 스물두
+   * 개를 옮기면 화면에는 `22개 옮김` 이 뜨는데, **턴이 아는 「손댄
+   * 파일」 은 0개**였다. 그 값은 여러 군데가 본다 — 턴 끝의 만든 파일
+   * 목록, `/commit`, 그리고 헛도는지 재는 자리. 그 자리들이 전부
+   * "아무 일도 안 일어났다" 로 알고 있었다.
+   *
+   * 한 개씩 옮길 때는 멀쩡했다. 배열로 부를 때만 새던 자리다.
+   */
+  const 바뀐것들 = [];
   for (const 하나 of 목록) {
     const r = 한개옮기기(하나, ctx);
-    if (r.error) 안된것.push(`${하나.from ?? '?'} → ${하나.to ?? '?'}: ${r.error}`);
-    else 된것.push(r.content);
+    if (r.error) { 안된것.push(`${하나.from ?? '?'} → ${하나.to ?? '?'}: ${r.error}`); continue; }
+    된것.push(r.content);
+    // 폴더를 옮겼으면 그 안의 파일 하나하나가, 아니면 옮겨 간 자리가 답이다.
+    for (const f of r.바뀐것들 ?? (r.changed ? [r.changed] : [])) 바뀐것들.push(f);
   }
   /*
    * 하나도 못 옮겼으면 오류로 돌려준다. 그래야 모델이 '됐다' 고 넘어가지
@@ -602,6 +619,7 @@ function 여러개옮기기(목록, ctx) {
       + (안된것.length ? `\n${안된것.map((e) => `  ✗ ${e.split('\n')[0]}`).join('\n')}` : '')
       + (안된것.length ? '\n\n실패한 것만 다시 보내세요. 된 것은 다시 안 보내도 됩니다.' : ''),
     summary: `${된것.length}개 옮김${안된것.length ? ` · ${안된것.length}개 실패` : ''}`,
+    바뀐것들,
   };
 }
 
@@ -895,7 +913,7 @@ export const TOOLS = {
         required: ['file_path'],
       },
     },
-    run(args, ctx) {
+    async run(args, ctx) {
       const abs = ctx.scope.resolve(args.file_path);
       if (!existsSync(abs)) return { error: `파일이 없습니다: ${args.file_path}` };
       if (statSync(abs).isDirectory()) return { error: `폴더입니다. Glob 을 쓰세요: ${args.file_path}` };
@@ -923,7 +941,9 @@ export const TOOLS = {
           if (looksOldHwp(abs, 머리)) {
             // 여기도 먼저 빌려 본다. 이 PC 에 변환기가 있으면 안내문보다 글이 낫다.
             const 안내 = 옛hwp안내(ctx.scope.show(abs));
-            return 빌려읽기(abs, ctx, 안내) ?? { error: 안내 };
+            // 괄호가 있어야 한다. await 를 빼면 `??` 가 **약속(Promise)** 을
+            // 보고 "값이 있다" 고 판단해서, 안내문이 영영 안 나간다.
+            return (await 빌려읽기(abs, ctx, 안내)) ?? { error: 안내 };
           }
         } catch { /* 아래 일반 읽기가 제 오류를 낸다 */ }
       }
@@ -941,7 +961,7 @@ export const TOOLS = {
        */
       if (직접못읽나(abs)) {
         const 보인이름 = ctx.scope.show(abs);
-        const 빌린것 = 빌려읽기(abs, ctx, `${보인이름} 을 deel 이 직접 못 읽습니다.`);
+        const 빌린것 = await 빌려읽기(abs, ctx, `${보인이름} 을 deel 이 직접 못 읽습니다.`);
         if (빌린것) return 빌린것;
         return { error: 못바꿈말(보인이름, extname(abs)), 끝났다: true };
       }
@@ -1215,7 +1235,9 @@ export const TOOLS = {
     run(args, ctx) {
       const root = args.path ? ctx.scope.resolve(args.path) : ctx.scope.root;
       const re = globToRegex(args.pattern);
-      const 전부 = walk(root);
+      const 전부 = walk(root, { signal: ctx.signal });
+      // 훑다 말고 나왔으면 그렇다고 말한다. 조용히 적게 주면 「그런 파일이 없다」가 된다.
+      if (전부.끊김) return { error: '중단했습니다. 폴더를 끝까지 안 훑었습니다.', 끝났다: true, 중단됨: true };
       // .gitignore 로 건너뛴 것은 수를 말한다 — 조용히 빼면 '그 파일이 없다' 로 읽힌다 (tools/ignore.js).
       const 건너뜀 = 건너뜀말(전부.건너뜀, 전부.잘림, 전부.상한);
       const 맞는것 = 전부
@@ -1259,7 +1281,9 @@ export const TOOLS = {
         required: ['pattern'],
       },
     },
-    run(args, ctx) {
+    // async 인 까닭: 아래 빠르게찾기() 가 rg·git grep 을 **비동기로** 부른다.
+    // 큰 저장소에서 20초를 도는 동안에도 ESC 가 들려야 하기 때문이다.
+    async run(args, ctx) {
       let re;
       try { re = new RegExp(args.pattern, args['-i'] ? 'i' : ''); }
       catch (err) { return { error: `정규식이 잘못됐습니다: ${err.message}` }; }
@@ -1282,13 +1306,15 @@ export const TOOLS = {
        * 다르게 나왔을 때 무엇으로 찾은 것인지 모르면 사람은 코드를 의심한다.
        */
       const 무시파일 = join(ctx.scope.root, '.deelignore');
-      const 빠른것 = isFile ? null : 빠르게찾기({
+      const 빠른것 = isFile ? null : await 빠르게찾기({
         무늬: args.pattern,
         자리: root,
         glob: args.glob ?? null,
         대소문자무시: !!args['-i'],
         무시파일: existsSync(무시파일) ? 무시파일 : null,
         최대: Math.max(limit * 4, 2000),
+        // 멈추라고 하면 rg 를 죽인다. 이게 없으면 ESC 를 듣고도 20초를 더 기다린다.
+        signal: ctx.signal ?? null,
       });
       if (빠른것) {
         const 파일별 = new Map();
@@ -1339,7 +1365,8 @@ export const TOOLS = {
        */
       let files = isFile
         ? [{ path: root, rel: ctx.scope.show(root) }]
-        : walk(root);
+        : walk(root, { signal: ctx.signal });
+      if (files.끊김) return { error: '중단했습니다. 폴더를 끝까지 안 훑었습니다.', 끝났다: true, 중단됨: true };
       const 안본것 = isFile ? '' : 건너뜀말(files.건너뜀, files.잘림, files.상한).trim();   // .gitignore 로 건너뛴 수 — 꼬리에 적는다
       // 훑기 상한에 걸렸으면 "일치 없음" 이라고 잘라 말하면 안 된다. 안 본 것이다.
       const 다못봄 = !isFile && !!files.잘림;
@@ -1662,13 +1689,21 @@ export const TOOLS = {
        * 첫 문장에 제일 중요한 것을 둔다 — 좁은 창에서는 설명줄이기가
        * **뒤에서부터 문장째로** 잘라 낸다. 8k 에서 남는 것은 앞 90자다.
        */
-      description: '갈림길에서 사람에게 하나 묻는다. 글로 "알려주세요" 하고 끝내지 마라 —'
-        + ' 턴이 끝나서 여태 본 것이 버려진다. options 에 2~4개를 주면 숫자로 답한다.'
+      description: '갈림길에서 사람에게 하나 묻는다. **먼저 `이해` 에 이번 요청을 무엇으로'
+        + ' 알아들었는지 한 줄로 적고**, 그러고도 정말 정할 것이 남았을 때만 묻는다.'
+        + ' 글로 "알려주세요" 하고 끝내지 마라 — 턴이 끝나서 여태 본 것이 버려진다.'
+        + ' options 에 2~4개를 주면 숫자로 답한다.'
         + ' **이미 사용자가 말한 것을 다시 묻지 마라.** "파일 정리해 줘" 라고 했으면'
         + ' 그게 답이다 — 그대로 하면 된다. 어떻게 할지 정하는 것은 네 일이다.',
       parameters: {
         type: 'object',
         properties: {
+          이해: {
+            type: 'string',
+            description: '이번 요청을 무엇으로 알아들었는지 한 줄. 사람은 이 줄을 보고 네가'
+              + ' 제대로 읽었는지 판단한다. "요청을 이해했습니다" 같은 인사말은 안 된다 —'
+              + ' 그 일의 내용이 들어가야 한다',
+          },
           question: { type: 'string', description: '한 문장짜리 질문. 무엇을 정해야 하는지 분명하게' },
           options: {
             type: 'array',
@@ -1676,7 +1711,7 @@ export const TOOLS = {
             description: '고를 것 2~4개. 각각 한 줄로, 무엇이 달라지는지 알 수 있게',
           },
         },
-        required: ['question'],
+        required: ['이해', 'question'],
       },
     },
     async run(args, ctx) {
@@ -1685,11 +1720,16 @@ export const TOOLS = {
 
       const 고를것 = (Array.isArray(args.options) ? args.options : [])
         .map((x) => String(x ?? '').trim()).filter(Boolean).slice(0, 4);
+      const 이해 = String(args.이해 ?? '').trim();
 
       /*
        * 물어볼 자리가 없는 데서도 안 죽어야 한다 — `deel -p` 한 방 실행, 파이프,
        * 하위 작업. 거기서는 **막히지 말고** 스스로 판단하라고 돌려준다.
        * 답을 기다리며 서 있으면 그 실행은 영영 안 끝난다.
+       *
+       * 아래 관문보다 **먼저** 본다. 어차피 아무도 못 듣는 자리에서 "이해를
+       * 채워서 다시 물어라" 라고 돌려주면, 고쳐서 다시 불러도 결과가 같다 —
+       * 왕복만 한 번 늘고 그 실행은 그만큼 늦어진다.
        */
       /*
        * 결과는 반드시 `content` 로 돌려준다.
@@ -1706,7 +1746,28 @@ export const TOOLS = {
         };
       }
 
-      const 답 = await ctx.ask물음(물음, 고를것);
+      /*
+       * 사람에게 내보내기 전에 한 번 거른다 (agent/askcheck.js).
+       *
+       * 막힌 물음은 **오류로** 돌려준다. content 로 돌려주면 모델은 그것을
+       * 사람의 답으로 읽고 그대로 이어 간다 — 묻지도 않은 답을 받은 셈이 된다.
+       * 오류여야 되풀이 감지에도 걸리고, 같은 물음을 또 던지지 않는다.
+       */
+      const 관문 = 물음검사({
+        물음, 고를것, 이해, 요청: ctx.요청 ?? '', 이미물은것: ctx.물은것 ?? [],
+      });
+      if (!관문.ok) return { error: 관문.할말, 끝났다: true, 물음막힘: 관문.왜 };
+
+      const 답 = await ctx.ask물음(물음, 고를것, 이해);
+
+      /*
+       * 물어본 것을 적어 둔다.
+       *
+       * 관문이 "이미 물었나" 를 보려면 기억할 자리가 있어야 한다. 답까지 같이
+       * 적는 것은, 또 물으려 할 때 **앞의 답을 그대로 돌려주기** 위해서다 —
+       * "이미 물었습니다" 만 말하면 모델은 그 답이 무엇이었는지 못 찾는다.
+       */
+      (ctx.물은것 ??= []).push({ 물음, 고를것, 답: 답 == null ? '' : String(답) });
       if (답 === null || 답 === undefined || String(답).trim() === '') {
         return { content: '사람이 답하지 않았습니다. 되묻지 말고 스스로 판단해 이어가세요.' };
       }
@@ -1745,7 +1806,24 @@ export const TOOLS = {
         const 왜 = r.예산초과
           ? `지난 대화 ${r.전체파일}개 중 ${r.본파일}개까지만 뒤졌습니다(양이 많아 멈춤). 못 찾았습니다`
           : `지난 대화 ${r.본파일}개를 다 뒤졌지만 없습니다`;
-        return { summary: `${왜}: ${q}`, hits: [], searched: r.본파일, total: r.전체파일, partial: r.예산초과 };
+        /*
+         * content 를 반드시 채운다.
+         *
+         * 대화에 실리는 것은 content 다. 여태 여기는 summary 만 돌려줬고,
+         * 그래서 **모델에게는 빈 글이 갔다.** 사람 화면에는 「없습니다」가
+         * 멀쩡히 찍히니 아무도 못 알아챘다. 모델은 못 찾은 줄도 모르고
+         * 찾아본 줄도 몰라서, 그 자리에서 엉뚱한 선택지를 들이밀었다.
+         *
+         * 「없다」는 것도 알아낸 것이다. 알아낸 것은 반드시 전한다.
+         */
+        const 없다는말 = `${왜}: ${q}\n`
+          + '이 대화 밖에는 단서가 없습니다. 없는 것을 지어내지 말고,'
+          + ' 지금 대화에 있는 것으로 판단하거나 무엇이 없는지 밝히세요.';
+        return {
+          content: 없다는말,
+          summary: `${왜}: ${q}`,
+          hits: [], searched: r.본파일, total: r.전체파일, partial: r.예산초과,
+        };
       }
 
       const 줄들 = r.맞은것.map((h) => {
@@ -2069,9 +2147,39 @@ export async function runTool(name, args, ctx) {
 
   const t = TOOLS[name];
   if (!t) return { error: `모르는 도구: ${name}` };
+
+  /*
+   * ── 멈추라고 했으면 시작도 안 한다 ──────────────────────────────────
+   *
+   * 여럿을 함께 돌릴 때(loop.js 의 Promise.all) 앞엣것이 도는 사이 사람이
+   * ESC 를 누르면, 뒤엣것들은 **아직 아무 일도 안 했는데** 그대로 돌았다.
+   * 여기서 한 번 보면 그 자리가 막힌다.
+   *
+   * 중단은 **실패가 아니다.** 그래서 중단됨 을 따로 단다 — 이걸 실패로
+   * 세면 되풀이 감지가 엉뚱하게 걸려서, 다음에 같은 도구를 부르는 것까지
+   * "또 그러네" 로 막아 버린다. 사람이 멈춘 것은 도구 잘못이 아니다.
+   */
+  if (ctx.signal?.aborted) {
+    return { error: '중단했습니다. 실행하지 않았습니다.', 끝났다: true, 중단됨: true };
+  }
+
   try {
     const r = await t.run(args ?? {}, ctx);
     ctx.audit.tool(name, args, r);
+    /*
+     * 도는 중에 멈췄다면 결과를 안 쓴다.
+     *
+     * 다만 **이미 바꿔 놓은 것은 사실대로 말한다.** 파일을 고친 뒤에
+     * "중단했습니다" 만 돌려주면 모델은 안 고쳐진 줄 알고 또 고친다 —
+     * 그러면 같은 편집이 두 번 들어가거나, 되돌리기 기록과 어긋난다.
+     * 읽기만 한 것은 버려도 잃을 것이 없으니 중단으로 끝낸다.
+     */
+    if (ctx.signal?.aborted) {
+      if (!isMutating(name) || r.error) {
+        return { error: '중단했습니다.', 끝났다: true, 중단됨: true };
+      }
+      return { ...r, 중단됨: true, 중단전에끝남: true };
+    }
     return await 고친뒤진단(name, r, ctx);
   } catch (err) {
     const r = { error: err.message };

package/src/tools/outline.js

@@ -232,7 +232,8 @@ export const OUTLINE_TOOL = {
     const 하나인가 = statSync(시작).isFile();
     let 파일들 = 하나인가
       ? [{ path: 시작, rel: ctx.scope.show(시작), mtime: statSync(시작).mtimeMs }]
-      : walk(시작, { skipDirs: SKIP_DIRS });
+      : walk(시작, { skipDirs: SKIP_DIRS, signal: ctx.signal });
+    if (파일들.끊김) return { error: '중단했습니다. 폴더를 끝까지 안 훑었습니다.', 끝났다: true, 중단됨: true };
     const 건너뜀 = 하나인가 ? '' : 건너뜀말(파일들.건너뜀, 파일들.잘림, 파일들.상한);   // .gitignore 로 건너뛴 수 (tools/ignore.js)
 
     // 좁히는 방식은 Glob 도구와 **같은 것**을 쓴다. 두 도구가 같은 패턴에

package/src/tools/spawn.js

@@ -0,0 +1,99 @@
+// 바깥 프로그램을 부른다 — **기다리는 동안 귀를 열어 둔 채로.**
+//
+// ── 왜 이 파일이 따로 있나 ─────────────────────────────────────────────
+//
+// 전에는 찾기(fastgrep.js)도 변환(convert.js)도 각자 spawnSync 를 썼다.
+// 쓰기는 편하다. 그런데 그 호출이 도는 동안 Node 는 이벤트 루프를 통째로
+// 멈춘다. 그 사이에는 키 입력이 배달되지 않는다 — 사람이 ESC 를 몇 번을
+// 눌러도, 그 키는 버퍼에만 쌓여 있다가 **일이 다 끝난 뒤에야** 들어온다.
+//
+//   rg 로 큰 저장소 찾기      최대 20초
+//   soffice 로 문서 바꾸기    최대 90초
+//
+// 그동안 프로그램은 귀머거리다. "ESC 를 눌러도 안 멈춘다" 는 제보의 뿌리가
+// 여기였다. 화면에는 여전히 돌아가는 그림이 보이니 사람은 더 답답하다.
+//
+// 두 군데에 따로 적어 두면 언젠가 한쪽만 고쳐지고, 그때부터 "검색은 멈추는데
+// 문서 변환은 안 멈추는" 프로그램이 된다. 그건 고장보다 설명하기 어렵다.
+// 그래서 한 벌만 둔다.
+//
+// ── 돌려주는 모양 ──────────────────────────────────────────────────────
+//
+// 일부러 spawnSync 와 **똑같이** 맞췄다 — {error, status, stdout, stderr}.
+// 부르는 쪽의 판단 코드(`status === 2 면 실패` 같은 것)를 한 줄도 안 건드리고
+// 바꾸려는 것이다. 바꾼 자리가 적을수록 조용히 달라지는 것도 적다.
+import { spawn } from 'node:child_process';
+
+/**
+ * 자식 프로그램을 부르고, 끝날 때까지 기다린다 — 루프는 계속 돈다.
+ *
+ * @param {string} 이름 실행할 것
+ * @param {string[]} 인자 인자들. 셸을 안 거치므로 여기 든 따옴표·세미콜론은 글자다.
+ * @param {object} [옵션]
+ * @param {number} [옵션.timeout] 이 시간을 넘기면 죽이고 실패로 돌려준다
+ * @param {number} [옵션.maxBuffer] 나온 글이 이보다 커지면 죽인다
+ * @param {AbortSignal|null} [옵션.signal] 눌리면 자식을 죽인다
+ * @param {object} [옵션.덤] spawn 에 그대로 넘길 것 (windowsVerbatimArguments 같은)
+ * @returns {Promise<{error:Error|null, status:number|null, stdout:string, stderr:string}>}
+ */
+export function 돌려보기(이름, 인자, { timeout = 20000, maxBuffer = 32 * 1024 * 1024, signal = null, 덤 = {} } = {}) {
+  return new Promise((resolve) => {
+    // 이미 눌렸으면 띄우지도 않는다. 여럿을 함께 돌릴 때 뒤엣것이 여기로 온다.
+    if (signal?.aborted) { resolve({ error: new Error('중단했습니다'), status: null, stdout: '', stderr: '' }); return; }
+
+    let 아이;
+    try {
+      아이 = spawn(이름, 인자, { windowsHide: true, ...덤 });
+    } catch (탈난것) {
+      resolve({ error: 탈난것, status: null, stdout: '', stderr: '' });
+      return;
+    }
+
+    let 밖 = ''; let 탈 = ''; let 끝났나 = false;
+    const 끝내기 = (것) => {
+      if (끝났나) return;
+      끝났나 = true;
+      clearTimeout(시계);
+      signal?.removeEventListener?.('abort', 중단하기);
+      resolve(것);
+    };
+
+    /*
+     * 멈추라고 하면 **자식을 죽인다.**
+     *
+     * 여기가 없으면 반쪽짜리다. 비동기로 바꾼 덕에 ESC 는 들리지만, 정작
+     * soffice 는 남은 시간을 마저 돈다 — 사람 눈에는 여전히 "눌렀는데 안
+     * 멈춘다". 듣는 것과 멈추는 것은 다른 일이라, 둘 다 해야 한 가지가 끝난다.
+     */
+    const 중단하기 = () => {
+      try { 아이.kill(); } catch { /* 이미 죽었다 */ }
+      끝내기({ error: new Error('중단했습니다'), status: null, stdout: '', stderr: '' });
+    };
+    signal?.addEventListener?.('abort', 중단하기, { once: true });
+
+    const 시계 = setTimeout(() => {
+      try { 아이.kill(); } catch { /* 이미 죽었다 */ }
+      끝내기({ error: new Error(`${이름} 가 ${timeout}ms 안에 안 끝났습니다`), status: null, stdout: 밖, stderr: 탈 });
+    }, timeout);
+    // 이 타이머가 프로그램을 붙들면 안 된다. 자식의 파이프가 이미 루프를 붙들고 있다.
+    시계.unref?.();
+
+    아이.stdout?.setEncoding('utf8');
+    아이.stderr?.setEncoding('utf8');
+    아이.stdout?.on('data', (조각) => {
+      밖 += 조각;
+      /*
+       * spawnSync 는 이 자리에서 ENOBUFS 를 냈다. 조용히 잘라 버리면 사람
+       * 눈에는 '결과가 적다' 로만 보인다 — 오류도 안 나고 아무도 눈치 못 챈다.
+       * 같은 자리에서 같은 실패를 내야 부르는 쪽이 예전 길로 내려간다.
+       */
+      if (밖.length > maxBuffer) {
+        try { 아이.kill(); } catch { /* 이미 죽었다 */ }
+        끝내기({ error: new Error('결과가 너무 많습니다'), status: null, stdout: '', stderr: 탈 });
+      }
+    });
+    아이.stderr?.on('data', (조각) => { if (탈.length < 65536) 탈 += 조각; });
+    아이.on('error', (탈난것) => 끝내기({ error: 탈난것, status: null, stdout: 밖, stderr: 탈 }));
+    아이.on('close', (코드) => 끝내기({ error: null, status: 코드, stdout: 밖, stderr: 탈 }));
+  });
+}

package/src/tools/todo.js

@@ -95,6 +95,34 @@ export const TODO_TOOL = {
     const 이전 = ctx.todos ?? [];
     ctx.todos = items;
 
+    /*
+     * ── 똑같은 목록을 또 보냈으면 그렇다고 말한다 ────────────────────────
+     *
+     * 「폴더 정리 해줘」 에서 이 자리가 걸렸다. 모델이 파일을 옮긴 뒤
+     * 목록을 갱신하려 했는데, 끝난 줄을 done 으로 안 바꾸고 **글자 하나
+     * 안 틀린 같은 목록**을 다시 보냈다. 그러면 여기서는 성공으로 돌려주고
+     * 「3개 중 1개 완료」 라는 앞과 똑같은 글이 나간다. 모델 쪽에서 보면
+     * 갱신이 된 것이므로, 다음 걸음에 또 같은 것을 보낸다. 그렇게 세 번이면
+     * 헛돈다고 판정돼 턴이 죽었다.
+     *
+     * 오류로 만들지는 않는다. 목록은 실제로 저장됐고, 틀린 것을 한 것도
+     * 아니다. 다만 **아무 일도 안 일어났다는 사실**과 그럴 때 무엇을 해야
+     * 하는지를 그 자리에서 알려 준다.
+     */
+    const 같은목록 = 이전.length === items.length
+      && items.every((x, i) => 이전[i]?.text === x.text && 이전[i]?.state === x.state);
+    if (같은목록) {
+      return {
+        content: `${render(items)}\n\n`
+          + '이 목록은 앞에 보낸 것과 글자 하나까지 같습니다 — 바뀐 것이 없습니다.\n'
+          + '방금 끝낸 일이 있으면 그 줄을 done 으로 바꿔서 보내고,'
+          + ' 없으면 목록을 다시 보내지 말고 다음 일을 하세요.',
+        summary: '그대로 (바뀐 것 없음)',
+        todos: items,
+        안바뀜: true,
+      };
+    }
+
     const 끝난것 = items.filter((x) => x.state === 'done').length;
     const 새로끝난 = items.filter((x) =>
       x.state === 'done' && !이전.some((y) => y.text === x.text && y.state === 'done'));

package/src/ui/inputbox.js

@@ -444,7 +444,15 @@ export class InputBox {
     // 답이 흘러나오는 동안 상자가 답 줄에 얹히는 것을 여기서 막는다.
     if (!this.일감 || this.줄중간) return;
     const 지난 = Date.now() - this.일감.시작;
-    const 갈래 = 지난 >= 느긋해질때 ? '느긋' : this.일감.갈래;
+    /*
+     * '멈춤' 은 '느긋' 을 이긴다.
+     *
+     * 45초가 넘으면 갈래를 느긋으로 갈아 주는데, 사람이 ESC 를 누르는 때가
+     * 하필 딱 그때다 — 오래 걸려서 누르는 것이다. 순서를 안 정해 두면
+     * 「멈추는 중」이 화면에 영영 안 뜨고, 사람은 안 먹었다고 여겨 또 누른다.
+     */
+    const 멈추나 = this.일감.갈래 === '멈춤';
+    const 갈래 = (!멈추나 && 지난 >= 느긋해질때) ? '느긋' : this.일감.갈래;
     const 회차 = Math.floor((this.틱 * 돌림주기) / 문구주기);
     this.그리기(this.session, '', 0, {
       // 갈래에 맞는 작은 그림. 무엇을 하는 중인지 글자와 그림이 같이 말한다.
@@ -459,7 +467,8 @@ export class InputBox {
         this.일감.예약수 ? `${this.일감.예약수}건 예약됨` : '',
         // 도는 동안 보이는 자리라 여기서는 ESC 만 말한다. Ctrl+C 도 되지만
         // 두 번 누르면 끝나 버려서, 급히 멈추려는 사람에게 권할 것이 못 된다.
-        'ESC 중단',
+        // 이미 멈추는 중이면 안 권한다 — 또 누르라는 말로 읽힌다.
+        멈추나 ? '' : 'ESC 중단',
       ].filter(Boolean).join(' · '),
       대기: this.일감.대기,
     });

package/src/ui/motion.js

@@ -163,6 +163,20 @@ export const 그림들 = {
     ['......', '....##', '....##', '......'],
   ],
 
+  /*
+   * 멈춤 — ESC 를 눌렀을 때. **조여든다.**
+   *
+   * 지나가지도 왕복하지도 않는다. 둘 다 '아직 하는 중' 으로 읽히기 때문이다.
+   * 여기서 말해야 하는 것은 하나다 — 눌린 것이 닿았고, 지금 거두는 중이다.
+   * 그렇다고 멈춰 세우면 화면이 얼어붙은 것과 구별이 안 된다.
+   */
+  멈춤: [
+    ['......', '######', '######', '......'],
+    ['......', '.####.', '.####.', '......'],
+    ['......', '..##..', '..##..', '......'],
+    ['......', '.####.', '.####.', '......'],
+  ],
+
   /*
    * 느긋 — 오래 걸릴 때. 왕복한다.
    *
@@ -307,6 +321,14 @@ const 기사그림들 = {
     ['...##.......', '..####......', '..####......', '..#..#......'],
   ],
 
+  // 멈춤 — 걸음을 멈추고 팔을 든다. "그만" 이라는 손짓이다.
+  멈춤: [
+    ['.##.........', '####........', '####........', '#..#........'],
+    ['.##.#.......', '#####.......', '####........', '#..#........'],
+    ['.##.#.......', '#####.......', '####........', '#..#........'],
+    ['.##.........', '####........', '####........', '#..#........'],
+  ],
+
   /*
    * 느긋 — **넘어진다.** 45초가 넘어가면 이 그림으로 갈린다.
    *
@@ -417,6 +439,14 @@ const 동물그림들 = {
     ['..#..#......', '..####......', '.######.....', '..#..#......'],
   ],
 
+  // 멈춤 — 가던 걸음을 멈추고 다리를 모은다. 앉기 직전이다.
+  멈춤: [
+    ['.#..#.......', '.####.......', '######......', '.#..#.......'],
+    ['.#..#.......', '.####.......', '######......', '..##........'],
+    ['.#..#.......', '.####.......', '######......', '..##........'],
+    ['.#..#.......', '.####.......', '######......', '.#..#.......'],
+  ],
+
   /*
    * 느긋 — 드러누워 잔다. 숨만 오르내린다.
    *