deel-local-cli 2.0.0 → 2.0.3

package/src/skills/discover.js

@@ -38,7 +38,7 @@ export const 내장자리 = join(dirname(fileURLToPath(import.meta.url)), 'built
  * 앞머리가 몇 백 줄일 까닭은 없어서 찾는 줄 수에도 상한을 둔다. 같은 열쇠가 두 번 오면
  * 첫 것을 둔다 — 뒤엣것은 대개 본문이 새어 들어온 것이다.
  */
-export const 앞머리최대줄 = 200;
+const 앞머리최대줄 = 200;
 const 금인가 = (줄) => /^---[ \t]*\r?$/.test(줄);
 // YAML 앞머리에 설 수 있는 줄 꼴 — 빈 줄 · 들여 쓴 줄 · 주석 · 목록 · `열쇠:` 줄.
 const 앞머리줄인가 = (줄) => {

package/src/tools/doc2md.js

@@ -50,12 +50,34 @@ const 최대글자 = 60000;
 // 이보다 칸이 많으면 마크다운 표로 안 그린다 — 가로로 흐르는 벽이 된다.
 const 최대칸 = 12;
 
-/** 마크다운 표 칸 하나. `|` 와 줄바꿈은 표를 부수므로 바꿔 준다. */
+/**
+ * 마크다운 표 칸 하나. `|` 와 줄바꿈은 표를 부수므로 바꿔 준다.
+ *
+ * 백슬래시는 **끝엣것만** 짝을 맞춘다. 칸이 백슬래시로 끝나면 그것이 뒤따르는
+ * 칸 가름표(`|`)를 먹어 버려 표가 그 줄부터 통째로 어긋난다 — 윈도우 경로가
+ * 든 표에서 바로 나온다.
+ *
+ * 모든 백슬래시를 벗기려다 한 번 되돌렸다(2차 눈). 그러면 칸 안의
+ * `` `\d+` `` 같은 글이 `` `\\d+` `` 로 **불어난다.** 가운데 백슬래시는
+ * 표를 안 부수니 건드릴 까닭이 없다. 부수는 것은 끝엣것뿐이다.
+ *
+ * ── `|` 바로 앞의 백슬래시도 짝을 맞춘다 (20회차 CodeQL #140) ────────────
+ *
+ * `.replace(/\|/g, '\\|')` 하나만으로는 모자랐다. 칸에 `a\|b` 가 들어오면
+ * 우리가 백슬래시를 하나 더해 `a\\|b` 가 되는데, 마크다운은 그것을
+ * **「백슬래시 하나」 + 살아 있는 칸 가름표**로 읽는다. 막으려던 바로 그
+ * 일이 우리 손으로 일어난다 — 가름표 앞에 백슬래시가 홀수 개면 언제나 그렇다.
+ *
+ * 그래서 `|` 앞에 붙은 백슬래시 묶음을 먼저 두 배로 늘리고 나서 `|` 를
+ * 벗긴다. 그러면 가름표 앞 백슬래시 수가 늘 짝수라 벗김표가 살아남는다.
+ * `|` 가 없는 자리의 백슬래시는 그대로 두므로 위의 `` `\d+` `` 도 안 는다.
+ */
 function 칸(v) {
   return String(v ?? '')
-    .replace(/\|/g, '\\|')
+    .replace(/(\\*)\|/g, (m, 앞) => 앞 + 앞 + '\\|')
     .replace(/\r?\n/g, '<br>')
-    .trim();
+    .trim()
+    .replace(/\\+$/, (m) => m + m);
 }
 
 /** 이 행들이 다 비었나. 빈 표를 그리면 머리글만 있는 유령 표가 남는다. */

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

@@ -52,8 +52,15 @@ export const 안볼확장자 = [
   'map', 'min.js', 'min.css', 'lock',
 ];
 
-/** 위 목록으로 만든 정규식. 자바스크립트 길이 쓴다. */
-export const 안볼정규식 = new RegExp(`\\.(${안볼확장자.map((x) => x.replace(/\./g, '\\.')).join('|')})$`, 'i');
+/**
+ * 위 목록으로 만든 정규식. 자바스크립트 길이 쓴다.
+ *
+ * 점만 벗기고 있었다. 지금 목록에는 점 말고 특수한 글자가 없어서 탈이 안 났지만,
+ * `c++` 같은 갈래 이름을 한 줄 더하는 날 그 줄이 조용히 **다른 무늬**가 된다.
+ * 목록은 사람이 늘리는 자리니 벗기는 쪽을 온전하게 둔다.
+ */
+const 정규식글자벗기기 = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+export const 안볼정규식 = new RegExp(`\\.(${안볼확장자.map(정규식글자벗기기).join('|')})$`, 'i');
 
 /** 위 목록으로 만든 rg 옵션. 대소문자를 안 가린다(정규식의 `i` 와 맞춘다). */
 export function 안볼글로브() {
@@ -135,7 +142,7 @@ export function 저장소인가(폴더) {
  *
  * @returns {{ok:true, 줄들:string[], 잘림:boolean} | {ok:false, 왜:string}}
  */
-export async function rg로찾기({ 무늬, 자리, 뿌리 = null, glob = null, 대소문자무시 = false, 무시파일 = null, 최대 = 5000, timeout = 20000, signal = null }) {
+export async function rg로찾기({ 무늬, 자리, 뿌리 = null, glob = null, 대소문자무시 = false, 무시파일 = null, 최대 = 5000, timeout = 20000, signal = null, 부르기 = 돌려보기 }) {
   const 인자 = [
     '--line-number',
     '--no-heading',
@@ -155,12 +162,18 @@ export async function rg로찾기({ 무늬, 자리, 뿌리 = null, glob = null,
   ];
   if (대소문자무시) 인자.push('--ignore-case');
   // `--` 뒤로 넘겨서 무늬가 옵션으로 안 읽히게 한다. `-foo` 같은 무늬가 실제로 있다.
-  인자.push('--regexp', 무늬, '--', 자리);
+  const 덤 = rg작업폴더(뿌리, { glob, 무시파일 });
+  const { 찾을, 되붙이기 } = rg찾을자리(뿌리, 자리, 덤);
+  인자.push('--regexp', 무늬, '--', 찾을);
 
-  const r = await 돌려보기('rg', 인자, { timeout, signal, 덤: rg작업폴더(뿌리, { glob, 무시파일 }) });
+  const r = await 부르기('rg', 인자, { timeout, signal, 덤 });
   const 못준까닭 = rg가못준까닭(r);
   if (못준까닭) return { ok: false, 왜: 못준까닭 };
-  const 줄들 = String(r.stdout ?? '').split('\n').filter(Boolean);
+  // 경로는 첫 NUL 앞이다(--null). 그 앞만 원래 뿌리에 되붙인다.
+  const 줄들 = String(r.stdout ?? '').split('\n').filter(Boolean).map((줄) => {
+    const 경로끝 = 줄.indexOf('\0');
+    return 경로끝 < 0 ? 줄 : 되붙이기(줄.slice(0, 경로끝)) + 줄.slice(경로끝);
+  });
   return { ok: true, 줄들: 줄들.slice(0, 최대), 잘림: 줄들.length > 최대 };
 }
 
@@ -222,7 +235,7 @@ export function rg가못준까닭(r) {
  */
 const 이음 = '[\\x80-\\xBF]';
 const 이음아님 = '(?:[^\\x80-\\xBF]|$)';
-export const 못푸는바이트무늬 = '(?-u:'
+const 못푸는바이트무늬 = '(?-u:'
   + [
     '\\x00',
     '[\\xC0\\xC1\\xF5-\\xFF]',
@@ -251,9 +264,11 @@ export async function rg못푸는파일({ 자리, 뿌리 = null, glob = null,
     // NUL 이 든 파일도 끝까지 본다. 안 그러면 rg 가 그 파일을 버려서 이름도 안 나온다.
     '--text',
     ...rg거르는인자({ glob, 무시파일, 자리, 뿌리 }),
-    '--regexp', 못푸는바이트무늬, '--', 자리,
   ];
-  const r = await 부르기('rg', 인자, { timeout, signal, 덤: rg작업폴더(뿌리, { glob, 무시파일 }) });
+  const 덤 = rg작업폴더(뿌리, { glob, 무시파일 });
+  const { 찾을, 되붙이기 } = rg찾을자리(뿌리, 자리, 덤);
+  인자.push('--regexp', 못푸는바이트무늬, '--', 찾을);
+  const r = await 부르기('rg', 인자, { timeout, signal, 덤 });
   /*
    * 실패는 **rg가못준까닭 한 자로** 가른다. 여기는 `error` 와 `status === 2` 두 줄뿐이라,
    * 신호로 죽거나(`status === null`) 2 가 아닌 값으로 끝나면 **빈 목록이 `ok:true`** 로
@@ -264,7 +279,7 @@ export async function rg못푸는파일({ 자리, 뿌리 = null, glob = null,
    */
   const 못준까닭 = rg가못준까닭(r);
   if (못준까닭) return { ok: false, 왜: 못준까닭 };
-  const 파일들 = String(r.stdout ?? '').split('\n').map((l) => l.replace(/\r$/, '')).filter(Boolean);
+  const 파일들 = String(r.stdout ?? '').split('\n').map((l) => l.replace(/\r$/, '')).filter(Boolean).map(되붙이기);
   return { ok: true, 파일들 };
 }
 
@@ -293,6 +308,46 @@ function rg작업폴더(뿌리, { glob = null, 무시파일 = null } = {}) {
   return 뿌리 && (glob || 무시파일) ? { cwd: 뿌리 } : {};
 }
 
+/*
+ * ── 작업 폴더를 정했으면 찾을 자리도 **그 기준 상대경로로** 넘긴다 (2.0.1) ──
+ *
+ * rg 는 glob 을 작업 폴더 기준으로 맞춘다. 그러려면 찾을 자리가 작업 폴더
+ * **밑으로 보여야** 한다 — 그 판단은 글자로 한다. 그런데 윈도우에서는 같은
+ * 폴더를 두 가지로 적을 수 있다:
+ *
+ *   C:\Users\RUNNER~1\AppData\Local\Temp       (8.3 짧은 이름 — os.tmpdir() 가 준다)
+ *   C:\Users\runneradmin\AppData\Local\Temp    (긴 이름 — 같은 폴더)
+ *
+ * Chocolatey·Scoop 은 rg 를 **심(shim)** 으로 깐다. 재 보니 심을 거치면 작업
+ * 폴더가 긴 이름으로 바뀌어 진짜 rg 가 뜬다. 우리는 찾을 자리를 짧은 이름으로
+ * 넘겼으니 rg 눈에는 그 자리가 작업 폴더 밑이 아니고, 빗금 든 glob 이 한 파일에도
+ * 안 맞았다 — 오류 없이 「일치 없음」, `!` 빼기는 아무것도 안 뺐다.
+ *
+ * 둘 중 하나만 있어서는 안 깨진다(윈도 러너에서 갈라 봤다):
+ *
+ *   심 + 짧은 이름     → 5개 빨강
+ *   진짜 rg.exe + 짧은 이름 → 121 통과
+ *   심 + 긴 이름       → 121 통과
+ *
+ * 윈도우에서 rg 는 대개 choco·scoop 으로 깔고, 짧은 이름은 사용자 이름이 여덟
+ * 글자를 넘거나 빈칸이 들면 %TEMP% 에 그대로 온다. 흔한 짝이다.
+ *
+ * 그래서 이름 적는 방식에 기대지 않는다. 찾을 자리를 **뿌리 기준 상대경로**로
+ * 넘기면 rg 는 제 작업 폴더에서부터 걸어 들어가고, 작업 폴더를 어떻게 적었든
+ * 상관이 없다. 나온 경로는 **원래 뿌리에 되붙여** 돌려준다 — 아래로 흐르는
+ * 경로 꼴은 예전과 똑같다.
+ *
+ * 작업 폴더를 안 정하는 판(glob·무시파일 없음)과, 찾을 자리가 뿌리 밖인 판은
+ * 예전대로 절대경로를 넘긴다.
+ */
+function rg찾을자리(뿌리, 자리, 덤) {
+  const 그대로 = { 찾을: 자리, 되붙이기: (f) => f };
+  if (!덤?.cwd || !뿌리 || !자리) return 그대로;
+  const 상대 = relative(뿌리, 자리);
+  if (isAbsolute(상대) || 상대 === '..' || 상대.startsWith(`..${sep}`)) return 그대로;
+  return { 찾을: 상대 || '.', 되붙이기: (f) => (isAbsolute(f) ? f : join(뿌리, f)) };
+}
+
 /*
  * glob 하나를 rg 인자로. 규칙은 fsutil.js 의 glob거르개 와 **같다**.
  *

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

@@ -1,16 +1,16 @@
 // 도구. 이름과 인자를 Claude Code 와 같게 맞춘다 —
 // 그래야 그 관례로 쓰인 스킬·명령이 그대로 먹는다.
-import { writeFileSync, appendFileSync, readFileSync, existsSync, mkdirSync, statSync, lstatSync, renameSync, cpSync, rmSync,
+import { writeFileSync, appendFileSync, readFileSync, existsSync, mkdirSync, statSync, lstatSync, renameSync, copyFileSync, rmSync,
   openSync, readSync, closeSync } from 'node:fs';
 import { dirname, extname, isAbsolute, join, relative, sep } from 'node:path';
 import { createHash } from 'node:crypto';
 import { 무리로돌리기 } from './spawn.js';
-import { walk, readText, readTextFull, 내부살림, glob거르개 } from './fsutil.js';
+import { walk, readText, readTextFull, 내부살림, glob거르개, copyDir } from './fsutil.js';
 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 따위)을 장치로 읽습니다. 다른 이름을 쓰세요.` };
+}
+
 /*
  * ── 크기만으로는 「그 파일 그대로」 를 모른다 ─────────────────────────────
  *
@@ -1034,15 +1047,59 @@ function pdf읽기(abs, ctx) {
  *   { 복사깨짐: 까닭 }   닿은 자리가 반쯤 됐다 — 실패다
  *   { 원본남음: 까닭 }   닿은 자리는 다 됐고 원본이 남았다 — 실패가 아니다
  *
+ * 안 베낀 것이 있으면 `건너뜀` 이 같이 온다. 그때는 언제나 `원본남음` 과 함께다
+ * (바로 아래 머리말).
+ *
  * fs 를 밖에서 넣을 수 있게 해 둔 것은 검사 때문이다. 진짜 EXDEV 와 진짜
  * '지우기만 깨짐' 은 어느 PC 에서나 똑같이 만들어 낼 수 없다.
  */
-export function 복사해옮기기(앞, 뒤, { 복사 = cpSync, 지우기 = rmSync } = {}) {
+/*
+ * ── cpSync 는 윈도우에서 프로세스를 **통째로** 죽인다 ─────────────────────
+ *
+ * Node 22 + 윈도우에서 경로에 한글이 들어 있으면 cpSync 가 0xC0000409 로
+ * 프로세스를 끝낸다. try 로 못 잡는다 — 예외가 아니라 네이티브 크래시다.
+ * 아래 `복사깨짐` 갈래는 아예 돌지 못하고, 옮기던 사람은 아무 말도 못 듣는다.
+ * 한국어로 쓰는 도구라 폴더 이름에 한글은 늘 있다.
+ *
+ * fsutil.js 의 copyDir 이 **이미 같은 까닭으로** 있었다 — 거기 머리말에
+ * 0xC0000409 까지 적혀 있다. 그런데 옮기기만 cpSync 로 남아 있었다.
+ * 한 자리를 고칠 때 같은 병이 다른 자리에도 있나를 안 물었던 것이다.
+ *
+ * copyDir 은 링크를 안 따라가고 건너뛴 것을 돌려준다. 그 편이 맞다 —
+ * 따라가면 링크 너머의 진짜 파일이 사본이 되고, 원본을 지울 때 링크만
+ * 사라진다. 건너뛴 것은 아래에서 사람에게 그대로 말한다.
+ */
+function 안전복사(앞, 뒤) {
+  if (statSync(앞).isDirectory()) return copyDir(앞, 뒤);
+  mkdirSync(dirname(뒤), { recursive: true });
+  copyFileSync(앞, 뒤);
+  return { skipped: [] };
+}
+
+export function 복사해옮기기(앞, 뒤, { 복사 = 안전복사, 지우기 = rmSync } = {}) {
+  let 건너뜀 = [];
   try {
-    복사(앞, 뒤, { recursive: true });
+    건너뜀 = 복사(앞, 뒤, { recursive: true })?.skipped ?? [];
   } catch (err) {
     return { 복사깨짐: err.message };
   }
+  /*
+   * ── 안 베낀 것이 있으면 원본을 **안 지운다** (2차 눈) ────────────────
+   *
+   * copyDir 은 링크를 안 따라가고 건너뛴다. 그런데 그 뒤에서 원본 폴더를
+   * 통째로 지우면 **베끼지도 않은 링크가 영영 없어진다.** 옮긴 자리에도
+   * 없고 헌 자리에도 없다 — 재어 봤더니 실제로 그렇게 사라졌다.
+   *
+   * 게다가 화면은 「링크는 안 옮겼습니다」 라고 말할 참이었다. 안 옮긴 것이
+   * 아니라 **지운** 것인데. 옮기기가 파일을 없애는 꼴이라 여기서 멈춘다.
+   *
+   * 못 옮긴 것이 하나라도 있으면 원본을 그대로 둔다. 무엇이 남았는지 말하고
+   * 사람이 고르게 한다 — 안전망(/undo)도 못 되살리는 것을 조용히 지우는
+   * 것보다 낫다.
+   */
+  if (건너뜀.length) {
+    return { 건너뜀, 원본남음: `링크 ${건너뜀.length}개를 안 베껴, 지우면 없어지므로 원본을 그대로 뒀습니다` };
+  }
   try {
     지우기(앞, { recursive: true, force: true });
   } catch (err) {
@@ -1240,6 +1297,8 @@ async function 한개옮기기({ from, to, overwrite = false }, ctx) {
   }
 
   let 원본남음 = null;
+  /** 드라이브를 넘는 복사에서 안 따라간 링크. 옮겼다는 말과 같이 적어 준다. */
+  let 건너뛴링크 = [];
   /*
    * 옮기는 함수는 갈아 끼울 수 있게 둔다. rename 이 EBUSY 로 깨지는 판(다른
    * 프로그램이 잡고 있는 파일)은 검사에서 파일 시스템으로 못 만든다
@@ -1269,6 +1328,7 @@ async function 한개옮기기({ from, to, overwrite = false }, ctx) {
      * 복사 도중에 끊기면 양쪽에 반씩 남기 때문이다.
      */
     const 벌어진일 = 복사해옮기기(앞, 뒤);
+    건너뛴링크 = 벌어진일.건너뜀 ?? [];
     if (벌어진일.복사깨짐) {
       // 닿은 자리를 여기서 지우지 않는다 — 이미 있던 폴더로 옮기는 중이었으면
       // 남의 파일까지 지운다. 어디에 반쯤 남았는지만 정확히 말한다.
@@ -1288,7 +1348,11 @@ async function 한개옮기기({ from, to, overwrite = false }, ctx) {
     + (되돌리기반쪽
     ? `\n(파일이 ${훑은것.상한.toLocaleString('en-US')}개를 넘어 되돌리기에는 앞부분만 떴습니다 — 옮기기는 전부 됐지만 /undo 는 다 못 되돌립니다)`
     : '')
-    + (원본남음
+    + (건너뛴링크.length
+      ? `\n(링크 ${건너뛴링크.length}개는 안 옮겼습니다 — 드라이브를 넘는 복사라 링크는 따라가지 않습니다:`
+        + ` ${건너뛴링크.slice(0, 3).map((p) => ctx.scope.show(p)).join(' · ')}${건너뛴링크.length > 3 ? ' 외' : ''}).`
+        + `\n 그래서 원본도 안 지웠습니다 — ${ctx.scope.show(앞)} 에 그대로 있습니다.`
+      : 원본남음
       ? `\n(닿은 자리에는 다 옮겼는데 원본을 못 지웠습니다 — 지금 ${ctx.scope.show(앞)} 에도 그대로 있습니다: ${원본남음})`
       : '')
     + (이름못되돌림
@@ -1388,6 +1452,7 @@ function hwpx새로만들기(args, ctx, abs) {
     writeFileSync(abs, 만듦.buf);
   }, () => !existsSync(abs));
   if (못씀) return 못씀;
+  { const 탈 = 파일안생김(ctx, abs); if (탈) return 탈; }
   /*
    * `seen` 에 안 올린다.
    *
@@ -1557,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(원래)}${짐작이다 ? ' (짐작)' : ''}` : '';
@@ -2401,6 +2467,7 @@ export const TOOLS = {
         else writeFileSync(abs, 만든것.buf);
       }, () => (existed ? 파일크기(abs) === 지금크기 : !existsSync(abs)));
       if (못씀) return 못씀;
+      { const 탈 = 파일안생김(ctx, abs); if (탈) return 탈; }
       // 붙인 **뒤** 앞머리로 적어 둔다. 64KB 보다 작던 파일은 붙인 조각이 앞머리에 든다.
       잰것캐시.set(abs, {
         지문: 지금크기 >= 인코딩볼바이트 ? 앞지문 : 표본지문(앞머리(abs, 인코딩볼바이트)),
@@ -3004,6 +3071,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);
       // 무엇을 빼고 넘길지 여기서 한 번 정한다. 뺀 이름은 아래에서 명령이