deel-local-cli 2.0.1 → 2.1.0

package/src/tools/docs.js

@@ -84,7 +84,7 @@ const 서명들 = [
 ];
 
 /** 앞 몇 바이트로 정체를 짚는다. 모르면 null. */
-export function 속내용(buf) {
+function 속내용(buf) {
   if (!Buffer.isBuffer(buf) || buf.length < 2) return null;
   for (const s of 서명들) {
     if (s.바이트.every((b, i) => buf[i] === b)) return s.이름;
@@ -103,7 +103,7 @@ export function 속내용(buf) {
  * @param {string} 갈래  겉으로 본 갈래 (pptx · docx · hwpx)
  * @param {string|null} 속  속내용() 이 짚은 것
  */
-export function 겉속다름말(갈래, 속) {
+function 겉속다름말(갈래, 속) {
   const 머리 = `겉은 ${갈래} 인데 속이 다릅니다`;
   if (!속) {
     return `${머리} — 무엇인지 알아보지 못했습니다 (zip 꾸러미가 아닙니다).\n`
@@ -182,7 +182,7 @@ const 끝이름 = (name) => {
  *   (tools/doc2md.js) — 마크다운 표는 칸이 몇 개인지 알아야 그릴 수 있고,
  *   이어 붙인 한 줄에서 그걸 되짚으면 글에 든 | 하나에 표가 어긋난다.
  */
-export function 문단뽑기(xml, 갈래, { 표를따로 = false } = {}) {
+function 문단뽑기(xml, 갈래, { 표를따로 = false } = {}) {
   const 표기 = 이름표[갈래];
   const 문단들 = [];
 

package/src/tools/edit-match.js

@@ -224,7 +224,7 @@ export function findMatch(text, needle, { replaceAll = false } = {}) {
 }
 
 // 못 찾았을 때, 모델이 스스로 고칠 수 있게 "가장 비슷한 줄"을 알려준다.
-export function nearest(text, needle) {
+function nearest(text, needle) {
   const key = String(needle).split(/\r?\n/).find((l) => l.trim()) ?? '';
   const probe = key.trim().replace(/\s+/g, ' ');
   if (probe.length < 4) return null;

package/src/tools/encoding.js

@@ -581,7 +581,7 @@ export function detect(buf, { fallback = null, system = null, 잘림 = false } =
 
 // 이 컴퓨터가 쓰는 옛 인코딩. 콘솔 코드페이지를 물어봐서 정한다.
 let _sys = null;
-export function systemLegacy() {
+function systemLegacy() {
   if (_sys) return _sys;
   const cp = consoleCodepage();
   _sys = LEGACY.find((x) => x.cp === cp)?.id ?? 'windows-1252';

package/src/tools/excel-com.js

@@ -53,6 +53,10 @@ $dst = $env:DEEL_XL_OUT
 # 그러면 맞는 암호를 넣은 사람이 「암호가 맞지 않습니다」 를 세 번 받고 끝난다. 나가는 쪽은
 # 이미 decode() 로 콘솔 인코딩을 풀고 있는데(아래 받은글), 들어오는 쪽만 빠져 있었다.
 try { [Console]::InputEncoding = New-Object System.Text.UTF8Encoding $false } catch { }
+# 나가는 쪽도 UTF-8 로 (2.0.2 · XL3). 콘솔 코드페이지로 두면 그 판에 없는 글자(일본어 엑셀의 「パスワード」,
+# 중국어 엑셀의 「密码」, 한글 판에 없는 시트 이름)가 「?」 가 되고, 받는 쪽 decode() 가 인코딩을 잘못 짚어
+# 한 줄이 통째로 딴 글자가 됐다 — 그러면 암호를 틀렸다는 말도 못 알아본다.
+try { [Console]::OutputEncoding = New-Object System.Text.UTF8Encoding $false } catch { }
 $pw  = [Console]::In.ReadLine()
 if ($null -eq $pw) { $pw = '' }
 
@@ -89,8 +93,8 @@ try {
 catch {
   $m = $_.Exception.Message
   # 작은따옴표는 PowerShell 에서 이스케이프를 안 푼다. 탭을 넣으려면 큰따옴표여야 한다.
-  if ($m -match 'password|암호|protected') { Write-Output "ERR\`tPASSWORD" }
-  elseif ($m -eq 'BUSY') { Write-Output "ERR\`tBUSY" }
+  # 「암호가 틀렸다」 는 말은 이 PC 언어로 온다 — 가르는 일은 JS 쪽 암호탓인가 가 한다 (2.0.2 · XL3).
+  if ($m -eq 'BUSY') { Write-Output "ERR\`tBUSY" }
   elseif ($m -eq 'OPENFAIL') { Write-Output "ERR\`tPASSWORD" }
   else { Write-Output ("ERR\`tOTHER\`t" + $m) }
 }
@@ -191,6 +195,53 @@ export async function excelToTables(경로, { password = '', timeout = 90000 } =
   }
 }
 
+/**
+ * 엑셀이 「암호가 틀렸다」 고 한 말인가 (2.0.2 · XL3).
+ *
+ * 그 말은 **이 컴퓨터 언어로** 온다. 여기가 파워셸 안의 `'password|암호|protected'` 였는데,
+ * 일본어 엑셀은 「パスワード」, 중국어는 「密码」, 독일어는 「Kennwort」 라고 말한다 — 그러면 암호를
+ * 틀린 사람이 「암호가 맞지 않습니다」 대신 「엑셀이 열지 못했습니다: …」 를 받고, 모델은 암호를
+ * 다시 물을 줄 모른다. 판정은 이쪽에서 한 번만 한다 — 엑셀 없는 판에서도 잴 수 있게.
+ */
+const 암호말 = /password|protected|암호|パスワード|密码|密碼|kennwort|mot de passe|contraseña|senha|palavra-passe|пароль|wachtwoord|hasło|parola|lösenord|adgangskode|passord|salasana|jelszó|heslo|mật khẩu/i;
+export function 암호탓인가(말) {
+  return 암호말.test(String(말 ?? ''));
+}
+
+/**
+ * 파워셸이 뱉은 글(이미 푼 것)을 답으로 (2.0.2 · XL3).
+ *
+ * 돌리기 의 close 안에 있던 것을 떼어 냈다. 그 자리는 엑셀이 깔린 PC 에서만 닿아서,
+ * 여기 갈래가 틀려도 잴 길이 없었다.
+ */
+export function 엑셀답읽기(out, err = '') {
+  const 줄들 = String(out ?? '').split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+  const 오류 = 줄들.find((l) => l.startsWith('ERR\t'));
+  if (오류) {
+    const [, 갈래, 말] = 오류.split('\t');
+    if (갈래 === 'PASSWORD' || 암호탓인가(말)) return { ok: false, reason: 'password', message: '암호가 맞지 않거나, 이 파일에는 암호가 필요합니다' };
+    if (갈래 === 'BUSY') return { ok: false, reason: 'busy', message: '엑셀이 계속 바쁘다고 합니다 — 열려 있는 엑셀 창을 닫고 다시 해보세요' };
+    // COM 클래스를 못 찾는다 = 이 컴퓨터에 엑셀이 없다.
+    // 이걸 그대로 내보내면 사용자는 알아볼 수 없는 오류 코드만 받는다.
+    if (없는엑셀(말)) {
+      return { ok: false, reason: 'no-excel', message: '이 컴퓨터에 엑셀이 설치되어 있지 않습니다 — 암호가 걸린 파일과 옛 .xls 는 엑셀이 있어야 읽을 수 있습니다' };
+    }
+    return { ok: false, reason: 'other', message: `엑셀이 열지 못했습니다: ${말 ?? ''}`.trim() };
+  }
+  if (!줄들.includes('OK')) {
+    const 첫줄 = String(err ?? '').split('\n')[0] ?? '';
+    if (없는엑셀(err)) {
+      return { ok: false, reason: 'no-excel', message: '이 컴퓨터에 엑셀이 설치되어 있지 않습니다' };
+    }
+    return { ok: false, reason: 'other', message: `엑셀이 끝내지 못했습니다${첫줄 ? ` — ${첫줄}` : ''}` };
+  }
+  const 시트들 = 줄들.filter((l) => l.startsWith('SHEET\t')).map((l) => {
+    const [, i, ...name] = l.split('\t');
+    return { i: Number(i), name: name.join('\t') || `시트${i}` };
+  });
+  return { ok: true, 시트들 };
+}
+
 function 돌리기(경로, 밖, password, timeout) {
   return new Promise((done) => {
     // 스크립트는 -EncodedCommand 로 넘긴다. 임시 .ps1 파일을 안 만들려는 것이다 —
@@ -202,7 +253,8 @@ function 돌리기(경로, 밖, password, timeout) {
       env: { ...process.env, DEEL_XL_IN: 경로, DEEL_XL_OUT: 밖 },
     });
 
-    // PowerShell 은 UTF-8 이 아니라 이 컴퓨터 콘솔 인코딩으로 뱉는다.
+    // PowerShell 은 UTF-8 이 아니라 이 컴퓨터 콘솔 인코딩으로 뱉는다(스크립트가 UTF-8 로 돌려
+    // 놓지만, 그게 안 먹는 판도 있다).
     // utf8 이라고 하고 받으면 오류 메시지가 통째로 깨져서, 무엇이 잘못됐는지
     // 알아볼 수 없는 글자가 사용자에게 그대로 간다. 바이트로 모아 뒤에 푼다.
     const 밖조각 = [];
@@ -232,33 +284,7 @@ function 돌리기(경로, 밖, password, timeout) {
       if (끝남) return;
       끝남 = true;
       clearTimeout(시계);
-      const out = 풀기(밖조각);
-      const err = 풀기(오류조각);
-      const 줄들 = out.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
-      const 오류 = 줄들.find((l) => l.startsWith('ERR\t'));
-      if (오류) {
-        const [, 갈래, 말] = 오류.split('\t');
-        if (갈래 === 'PASSWORD') return done({ ok: false, reason: 'password', message: '암호가 맞지 않거나, 이 파일에는 암호가 필요합니다' });
-        if (갈래 === 'BUSY') return done({ ok: false, reason: 'busy', message: '엑셀이 계속 바쁘다고 합니다 — 열려 있는 엑셀 창을 닫고 다시 해보세요' });
-        // COM 클래스를 못 찾는다 = 이 컴퓨터에 엑셀이 없다.
-        // 이걸 그대로 내보내면 사용자는 알아볼 수 없는 오류 코드만 받는다.
-        if (없는엑셀(말)) {
-          return done({ ok: false, reason: 'no-excel', message: '이 컴퓨터에 엑셀이 설치되어 있지 않습니다 — 암호가 걸린 파일과 옛 .xls 는 엑셀이 있어야 읽을 수 있습니다' });
-        }
-        return done({ ok: false, reason: 'other', message: `엑셀이 열지 못했습니다: ${말 ?? ''}`.trim() });
-      }
-      if (!줄들.includes('OK')) {
-        const 첫줄 = err.split('\n')[0] ?? '';
-        if (없는엑셀(err)) {
-          return done({ ok: false, reason: 'no-excel', message: '이 컴퓨터에 엑셀이 설치되어 있지 않습니다' });
-        }
-        return done({ ok: false, reason: 'other', message: `엑셀이 끝내지 못했습니다${첫줄 ? ` — ${첫줄}` : ''}` });
-      }
-      const 시트들 = 줄들.filter((l) => l.startsWith('SHEET\t')).map((l) => {
-        const [, i, ...name] = l.split('\t');
-        return { i: Number(i), name: name.join('\t') || `시트${i}` };
-      });
-      done({ ok: true, 시트들 });
+      done(엑셀답읽기(풀기(밖조각), 풀기(오류조각)));
     });
 
     // 암호는 여기로만 나간다. 줄바꿈까지 보내고 바로 닫는다.

package/src/tools/fastgrep.js

@@ -235,7 +235,7 @@ export function rg가못준까닭(r) {
  */
 const 이음 = '[\\x80-\\xBF]';
 const 이음아님 = '(?:[^\\x80-\\xBF]|$)';
-export const 못푸는바이트무늬 = '(?-u:'
+const 못푸는바이트무늬 = '(?-u:'
   + [
     '\\x00',
     '[\\xC0\\xC1\\xF5-\\xFF]',

package/src/tools/fsutil.js

@@ -109,10 +109,14 @@ export function 내부살림(abs) {
    *     Write .deel/config.json::$DATA     **설정 본체를 덮어썼다**
    *     cat   .deel/audit.jsonl::$DATA     checkPaths 통과
    *
-   * 드라이브 조각(`C:`)만 빼고 첫 `:` 뒤를 버린다. 유닉스에서 `:` 는 그냥 글자라 막는 쪽으로
-   * 넓어질 뿐이다(`history:x` 라는 살림 이름을 따로 쓸 까닭이 없다).
+   * 드라이브 조각(`C:`)만 빼고 첫 `:` 뒤를 버린다.
+   *
+   * **윈도에서만** 그렇게 한다 (2.0.2 · 480). 유닉스·맥에서 `:` 는 그냥 글자이고 스트림이 없다 —
+   * `.deel/config.json:v2` 는 설정 파일이 아니라 딴 파일이다. 모든 판에서 벗겼더니 리눅스에서 그런
+   * 이름을 살림으로 잘못 알고 막았다(안전 쪽이지만 까닭 없는 막힘이다).
    */
-  const 조각 = 편.split('/').map((x, 몇째) => (몇째 === 0 && /^[A-Za-z]:$/.test(x) ? x : x.replace(/:.*$/s, '')));
+  const 스트림꼴 = process.platform === 'win32';
+  const 조각 = 편.split('/').map((x, 몇째) => (!스트림꼴 || (몇째 === 0 && /^[A-Za-z]:$/.test(x)) ? x : x.replace(/:.*$/s, '')));
   const 이름 = (조각[조각.length - 1] ?? '').toLowerCase();
   /*
    * 살림 자리를 `.deel` 이라는 **글자**로 찾고 있었다.
@@ -405,7 +409,7 @@ export function 훑기상한(env = process.env) {
  * 자주 쉬면 훑기 자체가 느려지고, 드물게 쉬면 그만큼 귀를 닫는다. 200개면
  * 사내망 드라이브에서도 한 숨 사이가 10ms 언저리다.
  */
-export const 숨쉴간격 = 200;
+const 숨쉴간격 = 200;
 const 한숨 = () => new Promise((풀기) => setImmediate(풀기));
 
 /**

package/src/tools/ignore.js

@@ -30,11 +30,31 @@ export function 규칙읽기(text, 기준 = '') {
   return out;
 }
 
+/*
+ * ── 끝 빈칸 떼기는 git 과 **똑같이** (2.0.2 · G4) ─────────────────────────────
+ *
+ * 「역슬래시 바로 뒤 빈칸은 살린다」 로 쟀더니 `foo\\ ` 가 틀렸다. 앞의 `\\` 는 역슬래시 **글자**
+ * 하나이고 빈칸은 안 살린 것이라 git 은 `foo\` 로 읽는데, 우리는 빈칸까지 남겨 `foo\ ` 를 찾았다.
+ * git(dir.c 의 trim_trailing_spaces)을 그대로 옮긴다 — 역슬래시는 다음 글자 하나를 먹고, 떼는 것은
+ * 끝에 이어진 **빈칸**(' ')뿐이다. 탭은 git 도 안 뗀다.
+ */
+export function 끝빈칸떼기(줄) {
+  const p = String(줄 ?? '');
+  let 빈칸자리 = -1;
+  for (let i = 0; i < p.length; i++) {
+    const ch = p[i];
+    if (ch === ' ') { if (빈칸자리 < 0) 빈칸자리 = i; continue; }
+    if (ch === '\\') { i++; if (i >= p.length) return p; }
+    빈칸자리 = -1;
+  }
+  return 빈칸자리 >= 0 ? p.slice(0, 빈칸자리) : p;
+}
+
 /** 줄 하나 → 규칙. 빈 줄·주석이면 null. */
 export function 패턴규칙(줄, 기준 = '') {
   let p = String(줄 ?? '');
   // 끝의 빈칸은 뗀다 — 역슬래시로 살린 것만 남긴다.
-  p = p.replace(/(?<!\\)\s+$/, '');
+  p = 끝빈칸떼기(p);
   if (!p || p.startsWith('#')) return null;
   let 부정 = false;
   if (p.startsWith('!')) { 부정 = true; p = p.slice(1); }

package/src/tools/index.js

@@ -10,7 +10,7 @@ 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 { 셸명령 } from './shell.js';
+import { 셸명령, 셸한계넘나 } from './shell.js';
 import { findMatch, applySpans, reindent, TIER_LABELS, CRLF뿐인가, CRLF로, 꼴맞추기 } from './edit-match.js';
 import { loadSkill } from '../skills/discover.js';
 import { WEB_FETCH_TOOL } from './webfetch.js';
@@ -187,7 +187,7 @@ export function 붙박이그림줄이기(줄들) {
  * 줄을 통째로 지워 버리는 경우가 더 흔하고, 그때는 표시도 같이 사라진다.
  * 그래서 **개수를 견준다** — 있던 것보다 줄었으면 잃은 것이다.
  */
-export function 박힌그림수(글) {
+function 박힌그림수(글) {
   return (String(글 ?? '').match(그림자리) ?? []).length;
 }
 
@@ -274,6 +274,19 @@ function 파일크기(abs) {
   try { return statSync(abs).size; } catch { return -1; }
 }
 
+/*
+ * 쓴 자리에 **파일이 생겼나** (2.0.2 · 379). 안 생겼으면 그 말을 돌려준다.
+ *
+ * 윈도 10 까지는 `NUL`·`CON`·`aux.txt` 같은 이름이 파일이 아니라 장치다 — 쓰기는 성공하고
+ * 아무것도 안 남는다. 그런데 화면은 `새로 만듦: NUL (1줄)` 이었다. 윈도 11 은 진짜 파일을
+ * 만들어서 판마다 다르다 — 이름을 외우지 않고 **쓴 결과**를 본다. Write·Append·한글 문서가
+ * 같이 쓴다.
+ */
+export function 파일안생김(ctx, abs) {
+  try { if (statSync(abs).isFile()) return null; } catch { /* 없다 — 아래 말 */ }
+  return { error: `${ctx.scope.show(abs)} 에 썼는데 파일이 안 생겼습니다 — 윈도가 이 이름(NUL·CON·AUX·COM1 따위)을 장치로 읽습니다. 다른 이름을 쓰세요.` };
+}
+
 /*
  * ── 크기만으로는 「그 파일 그대로」 를 모른다 ─────────────────────────────
  *
@@ -1439,6 +1452,7 @@ function hwpx새로만들기(args, ctx, abs) {
     writeFileSync(abs, 만듦.buf);
   }, () => !existsSync(abs));
   if (못씀) return 못씀;
+  { const 탈 = 파일안생김(ctx, abs); if (탈) return 탈; }
   /*
    * `seen` 에 안 올린다.
    *
@@ -1608,6 +1622,7 @@ function 한파일쓰기(args, ctx) {
       writeFileSync(abs, 만든것.buf);
     }, () => (existed ? !!읽음 && readFileSync(abs).equals(읽음.buf) : !existsSync(abs)));
     if (못씀) return 못씀;
+    { const 탈 = 파일안생김(ctx, abs); if (탈) return 탈; }
     ctx.seen.add(abs);
     const n = args.content.split('\n').length;
     const 표기 = 원래 !== 'utf-8' ? ` · ${encLabel(원래)}${짐작이다 ? ' (짐작)' : ''}` : '';
@@ -1681,6 +1696,106 @@ function 여러파일쓰기(목록, ctx) {
  * 결과 모양을 바꾸면 안 된다. changed·diff·tier 를 보고 있는 자리가 셋이다:
  * loop.js 의 잘린 인자 살려쓰기, repl.js 의 바뀐 자리 그리기, 되돌리기 스냅샷.
  */
+/*
+ * old_string 을 찾아 new_string 으로 바꾼 **글**만 만든다. 파일은 안 건드린다.
+ *
+ * 고치기(한군데고치기)와 승인 미리보기(바뀔내용)가 이 셈 하나를 같이 쓴다. 둘이 따로
+ * 셈하면 사람이 승인 창에서 본 것과 실제로 쓰인 것이 갈린다 — 들여쓰기를 맞춘 자리,
+ * CRLF 로 바꾼 자리가 미리보기에만 없으면 「본 대로 허락했다」 가 거짓이 된다.
+ */
+function 새글만들기(text, args) {
+  const m = findMatch(text, args.old_string, { replaceAll: !!args.replace_all });
+  if (!m.ok) return { m, next: null };
+  // CRLF 만 쓰는 파일이면 넣는 글도 CRLF 로 (edit-match.js 의 CRLF뿐인가 머리말).
+  const 줄끝맞춤 = CRLF뿐인가(text) ? CRLF로 : (s) => s;
+  const next = applySpans(text, m.spans, (matched) => 줄끝맞춤(
+    m.tier === 'exact' ? args.new_string
+      // 정규화로 찾았으면 넣는 글도 파일의 꼴(NFC·NFD)로 (edit-match.js 의 꼴맞추기).
+      : m.tier === 'nfc' ? 꼴맞추기(args.new_string, matched)
+        : reindent(args.new_string, matched, args.old_string)));
+  return { m, next };
+}
+
+// 미리보기에 실을 만큼. 넘는 파일은 한 줄 물음으로 물러선다 — 승인 창에 몇 MB 를
+// 그리거나 편집기로 보내는 동안 사람은 멈춘 화면만 본다.
+const 미리보기상한 = 2_000_000;
+
+/**
+ * 이 도구 호출이 **실행되면** 무엇이 어떻게 바뀌는가. 승인을 묻기 전에 보여 줄 거리다.
+ *
+ * 사내 검토에서 나온 물음이 이것이었다 — 「고치기 전에 미리보기를 보여 주고 사람이
+ * 확인하는가」. 여태 승인 창은 `Edit src/a.js` 한 줄만 보여 줬다. 무엇이 바뀌는지
+ * 모르고 누르는 y 는 확인이 아니라 습관이다.
+ *
+ * 파일은 **읽기만** 한다. 못 만들면(경로 밖·없는 파일·못 찾는 old_string·문서 파일)
+ * 빈 배열이다 — 그 경우 도구가 어차피 실패로 끝나거나, 물음은 예전처럼 한 줄로 뜬다.
+ *
+ * @returns {Array<{경로:string, 보일경로:string, 전:string|null, 후:string}>}
+ */
+export function 바뀔내용(이름, 인자, ctx) {
+  const a = 인자 ?? {};
+  /*
+   * 실제 도구가 거절하는 자리는 미리보기도 안 읽는다. deel 자신의 살림(기록·설정·열쇠)은 Write·Edit 이
+   * 먼저 거절하는데(내부살림), 미리보기가 그걸 모르고 읽으면 승인 창에 「지금 내용」 으로 열쇠가 찍히고
+   * 편집기로까지 간다 — 도구는 안 돌았는데 읽기는 일어난 셈이다. 문서 파일은 글로 못 보인다.
+   */
+  const 글파일인가 = (abs) => !(isExcelPath(abs) || isDocPath(abs) || isPdfPath(abs) || isFigPath(abs) || 내부살림(abs));
+  const 읽기 = (abs) => (existsSync(abs) ? readTextFull(abs).text : null);
+  const 담기 = (abs, 전, 후) => ({ 경로: abs, 보일경로: ctx.scope.show(abs), 전, 후 });
+  try {
+    if (이름 === 'Write' || 이름 === 'Append') {
+      if (typeof a.file_path !== 'string' || typeof a.content !== 'string') return [];
+      const abs = ctx.scope.resolve(a.file_path);
+      // 실제 도구는 «가림:…» 표를 파일로 되돌리는 쓰기를 거절한다 — 안 일어날 변경은 안 그린다.
+      if (!글파일인가(abs) || 표몇군데(a.content)) return [];
+      const 전 = 읽기(abs);
+      /*
+       * Append 는 CRLF 만 쓰는 파일에 붙일 때 조각도 CRLF 로 바꿔 쓴다. 그 판정도 실제처럼
+       * **앞머리**로 한다(아래 Append 의 앞글). LF 로 이어 붙여 그리면 본 것과 쓰인 것이 다르다.
+       */
+      const 붙일글 = 이름 === 'Append' && 전 !== null && CRLF뿐인가(전.slice(0, 인코딩볼바이트)) ? CRLF로(a.content) : a.content;
+      const 후 = 이름 === 'Append' ? (전 ?? '') + 붙일글 : a.content;
+      if ((전?.length ?? 0) + 후.length > 미리보기상한) return [];
+      return [담기(abs, 전, 후)];
+    }
+    if (이름 === 'Edit') {
+      // 여러 군데면 실제 고치기처럼 적은 순서대로 차례로 대 보고, 못 찾은 것은 건너뛴다
+      // (여러군데고치기 가 그렇게 한다 — 된 것만 쓰고 안 된 것은 실패로 알린다).
+      const 목록 = Array.isArray(a.edits) ? a.edits.filter((x) => x && typeof x === 'object') : [a];
+      const 파일들 = new Map();
+      for (const x of 목록) {
+        if (typeof x.file_path !== 'string' || typeof x.old_string !== 'string' || typeof x.new_string !== 'string') continue;
+        if (x.old_string === x.new_string) continue;
+        let abs;
+        try { abs = ctx.scope.resolve(x.file_path); } catch { continue; }
+        // 아직 안 읽은 파일은 실제 Edit 이 거절한다(「먼저 Read 로」). 미리보기가 대신 읽어 보여 주면
+        // 모델이 안 본 파일의 내용이 승인 창에 먼저 뜬다 — 그 호출은 어차피 실패로 끝난다.
+        if (!글파일인가(abs) || !ctx.seen?.has(abs)) continue;
+        // 가린 표를 되돌리는 고침은 실제 Edit 이 거절한다(한군데고치기) — 그 한 군데는 안 일어난다.
+        if (표몇군데(x.new_string)) continue;
+        if (!파일들.has(abs)) {
+          const 글 = 읽기(abs);
+          if (글 === null) continue;
+          /*
+           * 너무 커서 못 그리는 파일이 **하나라도** 있으면 미리보기를 통째로 안 낸다. 그 파일만 빼고
+           * 그리면 사람은 작은 파일만 바뀌는 줄 알고 허락한다 — 반쪽 미리보기는 없는 것보다 나쁘다.
+           * 물음은 예전처럼 한 줄로 뜬다 (2차 눈 판정).
+           */
+          if (글.length > 미리보기상한) return [];
+          파일들.set(abs, { 전: 글, 후: 글 });
+        }
+        const 판 = 파일들.get(abs);
+        const { m, next } = 새글만들기(판.후, x);
+        if (m.ok) 판.후 = next;
+        // 고친 **뒤**도 잰다 — replace_all 한 번에 수십 MB 가 되면 동기 diff 가 승인 창을 붙잡는다.
+        if (판.후.length > 미리보기상한) return [];
+      }
+      return [...파일들].filter(([, 판]) => 판.후 !== 판.전).map(([abs, 판]) => 담기(abs, 판.전, 판.후));
+    }
+  } catch { /* 미리보기는 거드는 것이다 — 못 만들면 물음은 한 줄로 뜬다 */ }
+  return [];
+}
+
 function 한군데고치기(args, ctx) {
   /*
    * ── 글이 아닌 old_string·new_string 은 **받지 않는다** ──────────────────
@@ -1722,7 +1837,7 @@ function 한군데고치기(args, ctx) {
 
   const 읽음 = readTextFull(abs);
   const text = 읽음.text;
-  const m = findMatch(text, args.old_string, { replaceAll: !!args.replace_all });
+  const { m, next } = 새글만들기(text, args);
 
   if (!m.ok) {
     if (m.reason === 'ambiguous') {
@@ -1742,14 +1857,6 @@ function 한군데고치기(args, ctx) {
     return { error: `찾지 못했습니다.${hint}` };
   }
 
-  // CRLF 만 쓰는 파일이면 넣는 글도 CRLF 로 (edit-match.js 의 CRLF뿐인가 머리말).
-  const 줄끝맞춤 = CRLF뿐인가(text) ? CRLF로 : (s) => s;
-  const next = applySpans(text, m.spans, (matched) => 줄끝맞춤(
-    m.tier === 'exact' ? args.new_string
-      // 정규화로 찾았으면 넣는 글도 파일의 꼴(NFC·NFD)로 (edit-match.js 의 꼴맞추기).
-      : m.tier === 'nfc' ? 꼴맞추기(args.new_string, matched)
-        : reindent(args.new_string, matched, args.old_string)));
-
   // 읽은 그 인코딩으로 되돌려 쓴다. 안 바뀐 앞뒤는 읽은 바이트 그대로 (encoding.js 의 바꾼데만쓰기).
   const 만든것 = 바꾼데만쓰기(읽음.buf, text, next, 읽음.encoding);
   /*
@@ -2452,6 +2559,7 @@ export const TOOLS = {
         else writeFileSync(abs, 만든것.buf);
       }, () => (existed ? 파일크기(abs) === 지금크기 : !existsSync(abs)));
       if (못씀) return 못씀;
+      { const 탈 = 파일안생김(ctx, abs); if (탈) return 탈; }
       // 붙인 **뒤** 앞머리로 적어 둔다. 64KB 보다 작던 파일은 붙인 조각이 앞머리에 든다.
       잰것캐시.set(abs, {
         지문: 지금크기 >= 인코딩볼바이트 ? 앞지문 : 표본지문(앞머리(abs, 인코딩볼바이트)),
@@ -3055,6 +3163,9 @@ export const TOOLS = {
       // 어느 셸로 넘기나 — tools/shell.js 가 정한다. Jobs 와 같은 답이어야 하므로 한 군데다.
       // (윈도우 cmd 의 따옴표 문제와 그 해법도 거기 적혀 있다.)
       const shell = 셸명령(cmd);
+      // cmd 의 한 줄 한계를 넘으면 돌리기 전에 말한다 (tools/shell.js 셸한계넘나 · 2.0.2 S6).
+      const 한계 = 셸한계넘나(cmd, shell);
+      if (한계) return { error: 한계 };
 
       const 제한 = bash제한시간(args.timeout);
       // 무엇을 빼고 넘길지 여기서 한 번 정한다. 뺀 이름은 아래에서 명령이

package/src/tools/jobs.js

@@ -25,9 +25,10 @@
  */
 import { spawn } from 'node:child_process';
 import { decode as decodeBytes, consoleCodepage } from './encoding.js';
-import { 셸명령 } from './shell.js';
+import { 셸명령, 셸한계넘나 } from './shell.js';
 import { 셸환경 } from '../safety/shellenv.js';
 import { 말, 세말 } from '../i18n/index.js';
+import { 신호에거두기 } from '../reap.js';
 
 /* 결과 한 줄을 잇는다 — 빈 조각은 버린다(tools/index.js 의 이어 와 같은 것). */
 const 이어 = (...조각들) => 조각들.filter((x) => x != null && String(x) !== '').join(' · ');
@@ -319,7 +320,7 @@ export function 무리끊기(pid, { 곧장 = false, 늦게 = 800 } = {}) {
 export const 못재고기다릴최대 = 400;
 
 /** 무리끊기 의 **기다릴 수 있는** 판. 까닭은 바로 위 머리말에. */
-export async function 무리끊기기다려(pid, { 곧장 = false, 늦게 = 800 } = {}) {
+async function 무리끊기기다려(pid, { 곧장 = false, 늦게 = 800 } = {}) {
   if (process.platform === 'win32' || !pid) return;
   if (곧장) { 신호주기(pid, 'SIGKILL'); return; }
   신호주기(pid, 'SIGTERM');
@@ -350,6 +351,19 @@ export async function 무리끊기기다려(pid, { 곧장 = false, 늦게 = 800
 export function 나무죽이기(kid, { 파이프끊기: 끊을까 = true, 곧장 = false, 상한 = 1500, 뿌리살리기 = true } = {}) {
   if (!kid) return true;
   let 나무끊었나 = true;
+  /*
+   * ── 끝난 것으로 본 아이에게는 taskkill 을 안 보낸다 (2.0.2 · 28회차 flake) ──────────
+   *
+   * Node 는 아이가 끝났다고 알리는 그 자리에서 프로세스 손잡이를 닫는다. 손잡이가 닫히면 윈도는
+   * 그 번호를 **곧바로 딴 프로세스에게 준다.** 그 뒤의 `taskkill /pid N /t` 는 우리 아이가 아니라
+   * 그 번호를 새로 받은 **남의 나무**를 끊는다 — 윈도 CI 에서 옆 대조군이 말없이 멈춘 것(28회차)이
+   * 이 모양이다. 상한에 잘려 다시 오는 길(뿌리살리기)에서 특히 그렇다: 첫 taskkill 이 뿌리를
+   * 죽이고 나서 두 번째가 같은 번호로 간다.
+   *
+   * 잃는 것은 없다. 뿌리가 끝난 뒤에는 /t 가 어차피 그 아래를 못 훑는다(남은무리끊기 머리말).
+   * 아직 안 끝난 아이는 손잡이가 열려 있어 번호가 안 바뀐다 — 그때만 보낸다.
+   */
+  const 끝난아이 = typeof kid.exitCode === 'number' || typeof kid.signalCode === 'string';
   if (process.platform === 'win32' && kid.pid) {
     /*
      * 상한은 부르는 쪽이 정한다. 여기는 끝날 때도 지나가는 자리라
@@ -357,7 +371,7 @@ export function 나무죽이기(kid, { 파이프끊기: 끊을까 = true, 곧장
      * 그래서 기본은 짧다. 사람이 「끝내」 라고 시킨 자리에서는 길게 준다 —
      * 거기서는 몇백 ms 늦는 것보다 안 죽는 것이 훨씬 나쁘다.
      */
-    나무끊었나 = 나무끊기(kid.pid, 상한);
+    if (!끝난아이) 나무끊었나 = 나무끊기(kid.pid, 상한);
     /*
      * 나무를 다 못 훑었으면 뿌리를 살려 둔다. 부르는 쪽이 다시 온다.
      *
@@ -675,8 +689,11 @@ export async function 띄우기(명령, { cwd, 설명 = null, 기다림 = 1500,
     return { error: `뒤에서 도는 명령이 이미 ${도는것.length}개입니다. Jobs 로 안 쓰는 것을 끝내고 다시 하세요.` };
   }
 
-  const j = new 일감(다음번호++, 명령, 설명);
   const shell = 셸명령(명령);
+  // cmd 의 한 줄 한계를 넘으면 띄우기 전에 말한다 (tools/shell.js 셸한계넘나 · 2.0.2 S6). 번호를 받기 전이다.
+  const 한계 = 셸한계넘나(명령, shell);
+  if (한계) return { error: 한계 };
+  const j = new 일감(다음번호++, 명령, 설명);
   let kid;
   try {
     kid = spawn(shell.file, shell.args, {
@@ -918,6 +935,8 @@ export function 비우기() { 모두끝내기(); 다음번호 = 1; 치운것 = 0
 
 // 어떤 길로 끝나든 남기지 않는다. repl·oneshot 이 부르는 것과 겹쳐도 무해하다.
 process.once('exit', () => { try { 모두끝내기(); } catch { /* 끝나는 중이라 할 수 있는 게 없다 */ } });
+// 신호(SIGINT·SIGTERM)로 끝나면 'exit' 이 안 돈다 — 그 길도 거둔다 (reap.js 머리말 · 2.0.2 M3).
+신호에거두기(모두끝내기);
 
 /*
  * ── 도구 ──────────────────────────────────────────────────────────────

package/src/tools/shell.js

@@ -100,6 +100,33 @@ export function 정한셸() {
 /** 검사용 — 다음 정한셸() 이 다시 고르게. */
 export function 셸지우기() { 지금 = null; }
 
+/*
+ * ── cmd.exe 는 한 줄에 8,191자까지다 (2.0.2 · S6) ─────────────────────────────
+ *
+ * cmd 자체의 한계라 우리가 늘릴 수 없다. 넘기면 cmd 가 「The command line is too long.」 한 줄을
+ * 내고 **아무것도 안 돌린다** — 그런데 한국어 윈도에서는 그 줄이 코드페이지째 깨져 오고, 모델은
+ * 제 명령이 왜 안 돌았는지 모른 채 같은 긴 명령을 또 낸다. 넘길 것이면 넘기기 전에 사람 말로
+ * 멈추고, 어떻게 하면 되는지(파일로 써서 돌리기)를 같이 말한다. Git Bash·파워셸은 이 한계가 없다.
+ *
+ * 8,191자는 명령만이 아니라 **cmd 가 받은 한 줄 전체**다 — `"C:\WINDOWS\system32\cmd.exe" /d /s /c "…"`.
+ * 재 보니 이 PC 에서 명령에 쓸 수 있는 것은 8,152자였다(cmd 자리 27자 + 앞뒤 붙이는 것). 그래서 cmd 자리와
+ * 붙이는 글자만큼 빼고 잰다. 붙이는 것은 ` /d /s /c ` 10자 · 명령을 싸는 따옴표 2자에 2자를 더 둔다.
+ */
+const cmd한줄최대 = 8191;
+
+/** 이 cmd 로 명령에 쓸 수 있는 글자 수. */
+export function cmd명령최대(file = 'cmd.exe') { return cmd한줄최대 - (String(file).length + 14); }
+
+/** cmd 로 넘기면 한 줄 한계를 넘나. 넘으면 모델에게 줄 말, 아니면 null. */
+export function 셸한계넘나(cmd, { id, file } = 정한셸()) {
+  if (id !== 'cmd') return null;
+  const n = String(cmd ?? '').length;
+  const 최대 = cmd명령최대(file);
+  if (n <= 최대) return null;
+  return `명령이 ${n.toLocaleString('en-US')}자입니다 — cmd.exe 는 한 줄에 ${cmd한줄최대.toLocaleString('en-US')}자까지만 받습니다(cmd 자리를 빼면 명령에는 ${최대.toLocaleString('en-US')}자 · cmd 자체 한계라 돌리지 않았습니다).`
+    + ' 긴 내용은 Write 로 파일(.bat · .ps1 · .js 등)에 쓰고 그 파일을 돌리세요. Git Bash 를 깔면 이 한계가 없습니다.';
+}
+
 /** 명령 하나를 셸에 넘길 모양. Bash 도구와 Jobs 가 둘 다 이걸 쓴다. */
 export function 셸명령(cmd) {
   const s = 정한셸();

package/src/tools/todo.js

@@ -13,7 +13,7 @@ import { 말 } from '../i18n/index.js';
 
 /* 결과 한 줄을 잇는다 — 빈 조각은 버린다(tools/index.js 의 이어 와 같은 것). */
 const 이어 = (...조각들) => 조각들.filter((x) => x != null && String(x) !== '').join(' · ');
-export const STATES = ['todo', 'doing', 'done'];
+const STATES = ['todo', 'doing', 'done'];
 
 const 표시 = { todo: '☐', doing: '▶', done: '☑' };
 

package/src/tools/webfetch.js

@@ -303,7 +303,7 @@ export function 웹되돌림(다음, { allowPrivate = false } = {}) {
  * 첫 주소만 이름을 풀어 보면 소용이 없다. 공개 주소로 시작해 302 한 번으로
  * 사내로 들어가는 것이 가장 흔한 길이라, 홉마다 같은 것을 물어야 한다.
  */
-export async function 웹되돌림검사(다음, { allowPrivate = false } = {}) {
+async function 웹되돌림검사(다음, { allowPrivate = false } = {}) {
   웹되돌림(다음, { allowPrivate });
   if (allowPrivate) return;
   const 푼것 = await 사설로풀리나(다음.hostname);

package/src/tools/xlsx.js

@@ -232,12 +232,12 @@ function 날짜로(n) {
  * 이 밖을 가리키는 주소는 엑셀이 만든 파일에서 나올 수 없다. 나왔다면 누가
  * 손으로 적은 바이트다.
  */
-export const 엑셀최대행 = 1048576;
-export const 엑셀최대열 = 16384;
+const 엑셀최대행 = 1048576;
+const 엑셀최대열 = 16384;
 /** 빈 줄·빈 열이 이만큼 넘게 이어지면 자리를 안 지키고 건너뛰었다고 말한다. */
-export const 빈틈상한 = 1000;
+const 빈틈상한 = 1000;
 /** 펼친 표(줄 × 폭)의 칸 수 상한. 넘는 아래쪽 줄은 빼고 뺐다고 말한다. */
-export const 칸수상한 = 1_000_000;
+const 칸수상한 = 1_000_000;
 
 const 천단위 = (n) => String(n).replace(/\B(?=(\d{3})+(?!\d))/g, ',');