deel-local-cli 2.0.1 → 2.0.3

package/src/plugins/manage.js

@@ -6,7 +6,7 @@ import { execFile } from 'node:child_process';
 import { homeDir } from '../config.js';
 import { join, dirname, basename, resolve, relative, sep } from 'node:path';
 import {
-  existsSync, mkdirSync, writeFileSync, readFileSync, rmSync,
+  existsSync, mkdirSync, writeFileSync, readFileSync, rmSync, renameSync,
   readdirSync, statSync,
 } from 'node:fs';
 import { untargz, stripTop, 밖을가리키는것 } from '../pack/tar.js';
@@ -107,13 +107,26 @@ export function 묶음풀기(dest, files) {
    * 고 하고 하나만 남겼다. 쓰기 전에 전부 재 보고 사람 말로 거절한다.
    */
   const 뿌리 = resolve(dest);
-  const 자리들 = new Map();                 // 소문자 상대 자리 → 적힌 이름
+  /*
+   * ── 쓸 이름도 **잰 이름과 같게** (2.0.2 · P3 · P1) ──────────────────────────
+   *
+   * 아래 재기는 역슬래시를 빗금으로 보고 쟀는데, 쓸 때는 적힌 이름 그대로 `join` 했다.
+   * 윈도에서는 둘이 같지만 리눅스·맥에서는 역슬래시가 **이름 글자**라, 윈도에서 만든
+   * 묶음의 `sub\file.txt` 가 `sub` 폴더 안이 아니라 뿌리에 한 파일로 풀렸다 — 스킬이
+   * 제자리를 못 찾는다. 이름을 한 번 빗금으로 편 것을 재기와 쓰기가 같이 쓴다.
+   *
+   * 같은 자리 견주기에는 NFC 도 맞춘다. 맥은 `한글`(NFC)과 `한글`(NFD)을 한 파일로
+   * 보므로, 두 꼴이 같이 든 묶음은 맥에서 하나가 말없이 사라진다. 대소문자만 다른
+   * 이름과 같은 대접으로 묶음째 거절한다.
+   */
+  const 편이름 = (f) => String(f.name ?? '').replace(/\\/g, '/');
+  const 자리들 = new Map();                 // 소문자·NFC 상대 자리 → 적힌 이름
   for (const f of files) {
-    const 상대 = relative(뿌리, resolve(뿌리, String(f.name ?? '').replace(/\\/g, '/'))).replace(/\\/g, '/');
+    const 상대 = relative(뿌리, resolve(뿌리, 편이름(f))).replace(/\\/g, '/');
     if (!상대) return { error: `묶음 안에 풀 폴더 그 자체를 가리키는 파일이 있습니다 — 풀지 않았습니다: ${f.name}` };
-    const 열쇠 = 상대.toLowerCase();
+    const 열쇠 = 상대.normalize('NFC').toLowerCase();
     if (자리들.has(열쇠)) {
-      return { error: `묶음 안에 같은 자리를 가리키는 이름이 둘 있습니다(대소문자만 다를 수 있음) — 풀지 않았습니다: ${자리들.get(열쇠)} · ${f.name}` };
+      return { error: `묶음 안에 같은 자리를 가리키는 이름이 둘 있습니다(대소문자나 한글 자모 꼴만 다를 수 있음) — 풀지 않았습니다: ${자리들.get(열쇠)} · ${f.name}` };
     }
     자리들.set(열쇠, f.name);
   }
@@ -126,13 +139,32 @@ export function 묶음풀기(dest, files) {
   }
   rmSync(dest, { recursive: true, force: true });
   for (const f of files) {
-    const p = join(dest, f.name);
+    const p = join(dest, 편이름(f));
     mkdirSync(dirname(p), { recursive: true });
     writeFileSync(p, f.data);
   }
   return { 푼것: files.length };
 }
 
+/*
+ * ── git 없이 받을 주소들 (2.0.2 · P5) ─────────────────────────────────────────
+ *
+ * `#v1.0.0` 처럼 **태그**를 적어도 `refs/heads/` 만 물어서, git 이 없는 PC 에서는 늘
+ * 「받지 못했습니다 — 가지 이름을 확인하세요」 였다. git 이 있으면 `clone --branch` 가
+ * 태그도 받으니, 같은 명령이 git 유무에 따라 되고 안 됐다. 가지를 먼저 묻고 없으면
+ * 태그를 묻는다(같은 이름이면 git 도 가지를 먼저 고른다).
+ */
+export function 받을주소들(spec) {
+  const 뿌리 = `https://codeload.github.com/${spec.owner}/${spec.repo}/tar.gz`;
+  if (spec.ref) {
+    return [
+      { branch: spec.ref, url: `${뿌리}/refs/heads/${spec.ref}` },
+      { branch: spec.ref, url: `${뿌리}/refs/tags/${spec.ref}` },
+    ];
+  }
+  return ['main', 'master'].map((b) => ({ branch: b, url: `${뿌리}/refs/heads/${b}` }));
+}
+
 // 받는 방법 두 가지. git 이 있으면 clone, 없으면 tarball 을 내려받아 푼다.
 async function fetchInto(spec, dest, onStep) {
   if (await has('git')) {
@@ -150,8 +182,7 @@ async function fetchInto(spec, dest, onStep) {
 
   onStep?.('tarball 내려받기');
   if (isOffline()) return { error: '오프라인 모드입니다 — 받아 올 수 없습니다. 풀어 놓은 폴더 경로를 주세요.' };
-  for (const branch of spec.ref ? [spec.ref] : ['main', 'master']) {
-    const url = `https://codeload.github.com/${spec.owner}/${spec.repo}/tar.gz/refs/heads/${branch}`;
+  for (const { branch, url } of 받을주소들(spec)) {
     // 사용자가 이 명령을 친 동안만 github 를 연다. 끝나면 바로 닫는다.
     const close = allowTemporarily(url);
     let gz;
@@ -183,7 +214,7 @@ async function fetchInto(spec, dest, onStep) {
     if (푼것.error) return { error: 푼것.error };
     return { how: 'tarball', branch };
   }
-  return { error: '받지 못했습니다 — 저장소 주소나 가지 이름을 확인하세요' };
+  return { error: '받지 못했습니다 — 저장소 주소나 가지·태그 이름을 확인하세요' };
 }
 
 /**
@@ -246,7 +277,7 @@ export function 이름한칸(이름) {
  * 자르는 자가 언젠가 틀릴 수 있다. 그때 마지막으로 서는 그물이다. 지우고
  * 쓰는 자리라 두 겹으로 막는다.
  */
-export function 플러그인자리인가(base, dest) {
+function 플러그인자리인가(base, dest) {
   const 뿌리 = resolve(base);
   const 갈곳 = resolve(dest);
   return 갈곳 !== 뿌리 && 갈곳.startsWith(뿌리 + sep);
@@ -312,7 +343,7 @@ export async function install(spec, 옵션 = {}) {
   }
 }
 
-async function 설치하기(spec, { home = homeDir(), onStep } = {}, 치울것 = []) {
+async function 설치하기(spec, { home = homeDir(), onStep, 복사 = copyDir } = {}, 치울것 = []) {
   const base = pluginsDir(home);
 
   // 이미 풀어 놓은 폴더를 그대로 넣는 길. 오프라인 기기에서 이쪽을 쓴다.
@@ -383,9 +414,43 @@ async function 설치하기(spec, { home = homeDir(), onStep } = {}, 치울것 =
     return { error: `스킬도 명령도 없습니다. 플러그인이 맞는지 확인하세요 (${isLocal ? asPath : parsed.owner + '/' + parsed.repo})` };
   }
 
-  rmSync(dest, { recursive: true, force: true });
+  /*
+   * ── 옛것을 **먼저 지우지 않는다** (2.0.2 · P7) ──────────────────────────────
+   *
+   * 다시 설치(업데이트)는 옛 폴더를 지우고 새것을 베꼈다. 베끼다 넘어지면(디스크가
+   * 꽉 참 · 잠긴 파일 · 긴 경로) **둘 다 잃었다** — 옛것은 지웠고 새것은 반쪽이다.
+   * 업데이트 한 번에 쓰던 플러그인이 사라지는 것이다.
+   *
+   * 옛것을 점 이름(`.old-…` — list() 가 안 보는 이름)으로 비켜 두고 베낀다. 다 베끼면
+   * 비켜 둔 것을 버리고, 넘어지면 반쪽을 치우고 비켜 둔 것을 제자리로 되돌린다.
+   * 비키기(rename)부터 안 되면(윈도에서 그 폴더의 파일을 연 프로그램이 있으면 흔하다)
+   * 아무것도 안 건드리고 그렇다고 말한다.
+   */
   mkdirSync(dirname(dest), { recursive: true });
-  copyDir(tmp, dest, { skipped: 건너뛴것 });
+  const 옛것있나 = existsSync(dest);
+  const 비켜둘곳 = join(base, `.old-${name}-${process.pid}-${Date.now()}`);
+  if (옛것있나) {
+    try { renameSync(dest, 비켜둘곳); }
+    catch (err) {
+      rmSync(tmp, { recursive: true, force: true });
+      return { error: `깔려 있던 ${name} 을 비키지 못해 다시 설치하지 않았습니다 — 쓰던 것은 그대로입니다 (${err?.code ?? err?.message ?? err}). 그 폴더의 파일을 연 프로그램을 닫고 다시 하세요.` };
+    }
+  }
+  try {
+    복사(tmp, dest, { skipped: 건너뛴것 });
+  } catch (err) {
+    try { rmSync(dest, { recursive: true, force: true }); } catch { /* 반쪽을 못 치우면 아래 되돌리기가 넘어진다 — 그 말도 한다 */ }
+    let 되돌림 = '쓰던 것은 그대로입니다';
+    if (옛것있나) {
+      try { renameSync(비켜둘곳, dest); }
+      catch { 되돌림 = `쓰던 것은 ${비켜둘곳} 에 남아 있습니다 — 폴더 이름을 ${name} 으로 되돌리면 됩니다`; }
+    } else {
+      되돌림 = '반쪽은 치웠습니다';
+    }
+    rmSync(tmp, { recursive: true, force: true });
+    return { error: `${name} 을 베끼지 못해 설치하지 않았습니다 — ${되돌림} (${err?.code ?? err?.message ?? err})` };
+  }
+  if (옛것있나) { try { rmSync(비켜둘곳, { recursive: true, force: true }); } catch { /* 못 버려도 list() 는 점 이름을 안 본다 */ } }
   rmSync(tmp, { recursive: true, force: true });
   // 개수는 **깔린 자리**에서 다시 센다. 복사하다 빠진 것이 여기서 빠진다.
   const counts = countIn(dest);
@@ -569,7 +634,9 @@ export function pack(outFile, { home = homeDir(), only = null } = {}) {
   ].join('\n');
   entries.unshift({ name: '사용안내.txt', data: Buffer.from(manifest, 'utf8') });
 
-  const zip = makeZip(entries);
+  // 한도(파일 65,535개 · 4GB)를 넘으면 makeZip 이 사람 말로 던진다 — 명령째 죽지 않게 받아 올린다 (2.0.2 · Z5).
+  let zip;
+  try { zip = makeZip(entries); } catch (err) { return { error: String(err?.message ?? err) }; }
   mkdirSync(dirname(outFile), { recursive: true });
   writeFileSync(outFile, zip);
   return { out: outFile, plugins: included, files: entries.length, skipped, bytes: zip.length, manifest };

package/src/reap.js

@@ -0,0 +1,70 @@
+/*
+ * 신호로 끝날 때 아이들을 거두는 **하나뿐인** 손 (2.0.2 · M3).
+ *
+ * ── 왜 한 자리로 모았나 ──────────────────────────────────────────────────
+ *
+ * 'exit' 그물(MCP 서버 · 일감 · 언어 서버가 저마다 건 것)은 **신호로 끝나면 안 돈다.**
+ * Node 는 SIGINT·SIGTERM 에 손이 없으면 그 자리에서 죽고, 그 길에는 'exit' 이 없다.
+ *
+ * 신호 손은 언어 서버(lsp/client.js)에만 있었고, 그 손은 **제 아이만** 거둔 뒤 같은 신호를
+ * 다시 보내 죽었다. 그래서 `kill <pid>` 한 번에 언어 서버는 거둬지고 MCP 서버와 일감
+ * (`npm run dev` 같은 것)은 남았다 — 입력이 닫히면 스스로 끝나는 서버만 운 좋게 사라졌다.
+ * 저마다 손을 따로 달면 더 나쁘다. 손이 둘이면 서로 「남이 맡고 있다」 고 보고 아무도 안
+ * 죽어서, deel 이 SIGTERM 을 **삼키는** 프로그램이 된다(아래 다시보낼까).
+ *
+ * 그래서 손은 여기 하나만 달고, 거둘 것은 각자 `신호에거두기()` 로 적는다.
+ *
+ * ── 치우고 나면 **원래대로 죽어야 한다** ────────────────────────────────
+ *
+ * Node 는 SIGINT·SIGTERM 에 손이 하나라도 달려 있으면 **기본 동작(끝내기)을 안 한다.**
+ * 치우기만 하고 말면 `kill <pid>` 에 아이들은 죽고 deel 은 그대로 산다 — 잡 관리자·컨테이너
+ * 종료·systemd 가 전부 이 신호로 정리하는데, 그것들이 하나같이 시간을 다 기다린 뒤 SIGKILL 로
+ * 때려잡게 된다. 그래서 치운 다음 우리 손을 떼고 같은 신호를 자신에게 다시 보낸다. 그러면
+ * 기본 동작이 돌아 128+n 로 끝난다 — 셸이 기대하는 그 값이다.
+ *
+ * 다만 **남이 그 신호를 맡고 있으면 안 건드린다.** 한 방 실행은 SIGINT 로 턴만 끊고 살아
+ * 있어야 하고(oneshot.js), 대화 화면의 Ctrl+C 는 readline 이 따로 받는다. 우리 것 말고 다른
+ * 손이 달려 있으면 그쪽 뜻이 먼저다 — 남이 맡은 신호로 결국 끝나면 그때는 'exit' 그물이 거둔다.
+ */
+
+/** 신호로 끝날 때 부를 것들. 저마다 제 'exit' 그물과 같은 함수를 적는다. */
+const 거둘것 = new Set();
+
+/** 신호로 끝날 때 이것도 부른다. 같은 함수를 두 번 적어도 한 번만 돈다. */
+export function 신호에거두기(손) { 거둘것.add(손); return 손; }
+
+/** 검사가 본다 — 이 손이 적혀 있나. */
+export function 거둘것에있나(손) { return 거둘것.has(손); }
+
+/**
+ * 치운 다음 그 신호로 진짜 죽어야 하나.
+ *
+ * 갈림을 함수로 빼 둔 까닭: 윈도우에서는 이 길을 통째로 밟아 볼 수가 없다
+ * (SIGTERM 을 보내면 손이 돌기도 전에 Node 가 죽인다). 그런데 갈림 자체가
+ * 틀리면 유닉스에서 한 방 실행의 Ctrl+C 가 턴만 끊는 대신 프로그램을 죽인다 —
+ * 어느 판에서든 재어 볼 수 있어야 하는 자리다.
+ *
+ * @param 셈  이 신호에 달린 손의 수. 우리 것 하나만이면 우리가 마지막이다.
+ */
+export function 다시보낼까(신호, 셈 = process.listenerCount(신호)) {
+  return Number(셈) <= 1;
+}
+
+/** 적힌 것을 다 부른다. 하나가 던져도 나머지는 부른다 — 끝나는 길이다. */
+function 모두거두기() {
+  for (const 손 of 거둘것) { try { 손(); } catch { /* 끝나는 중이라 할 수 있는 게 없다 */ } }
+}
+
+for (const 신호 of ['SIGINT', 'SIGTERM']) {
+  const 손 = () => {
+    /*
+     * 갈림을 **거두기보다 먼저** 본다. 거두고 나서 갈랐었다 — 그래서 대화 화면의 Ctrl+C 가
+     * 턴만 끊고 세션은 사는데 언어 서버는 전부 죽고 풀도 비었다(2.0.0 6회차 사냥).
+     */
+    if (!다시보낼까(신호)) return;   // 남이 맡고 있다 — 그쪽 뜻이 먼저다
+    모두거두기();
+    process.removeListener(신호, 손);
+    try { process.kill(process.pid, 신호); } catch { process.exit(신호 === 'SIGINT' ? 130 : 143); }
+  };
+  process.on(신호, 손);
+}

package/src/report.js

@@ -109,7 +109,7 @@ const VERDICT_STYLE = {
 };
 
 /** 판정을 사람 말로. 모르는 값이면 그대로 돌려준다 — 지어내지 않는다. */
-export function verdictName(level) {
+function verdictName(level) {
   return VERDICT_NAME[level] ?? String(level ?? '');
 }
 

package/src/safety/audit.js

@@ -1,7 +1,8 @@
 // 감사 로그. 무엇을 언제 어떻게 했는지 전부 남긴다.
 // 자율 실행을 사내에 설득할 때 이 파일이 근거가 된다.
 import { join } from 'node:path';
-import { appendFileSync, mkdirSync, existsSync, readFileSync, chmodSync, statSync, openSync, readSync, closeSync } from 'node:fs';
+import { appendFileSync, mkdirSync, existsSync, readFileSync } from 'node:fs';
+import { 줄로끝나나, 본인만잠그기 } from '../jsonl.js';
 import { 가리기 } from './secrets.js';
 import { 첫이름 } from '../tools/label.js';
 
@@ -126,25 +127,13 @@ export class Audit {
    * 개행이 아니면 개행부터 붙인다. 줄마다 재지 않는다 — 그 뒤로는 우리가 적은 줄이다.
    */
   #줄끝봤나 = false;
-  #줄로끝나나() {
-    let fd = null;
-    try {
-      const 크기 = statSync(this.file).size;
-      if (!크기) return true;
-      fd = openSync(this.file, 'r');
-      const 한바이트 = Buffer.alloc(1);
-      readSync(fd, 한바이트, 0, 1, 크기 - 1);
-      return 한바이트[0] === 0x0a;
-    } catch { return true; }         // 없거나 못 읽으면 붙일 반쪽도 없다
-    finally { if (fd != null) { try { closeSync(fd); } catch { /* 닫다 터져도 적기는 한다 */ } } }
-  }
 
   write(kind, data) {
     const rec = { at: new Date().toISOString(), session: this.session, kind, ...data };
     try {
       let 줄 = JSON.stringify(rec) + '\n';
       if (!this.#줄끝봤나) {
-        if (!this.#줄로끝나나()) 줄 = '\n' + 줄;
+        if (!줄로끝나나(this.file)) 줄 = '\n' + 줄;
         this.#줄끝봤나 = true;
       }
       appendFileSync(this.file, 줄, 'utf8');
@@ -180,11 +169,7 @@ export class Audit {
   #잠그기() {
     if (this.#잠갔나) return;
     this.#잠갔나 = true;
-    // 윈도우에서 chmod 는 아무 일도 안 하고 **성공한다.** 그 성공을 적으면 위 머리말이 금지한
-    // 「잠근 척」 이다 — agent/store.js 와 같이 안 걸었다고 적는다.
-    if (process.platform === 'win32') { this.잠금 = { 못함: 'windows' }; return; }
-    try { chmodSync(this.file, 0o600); this.잠금 = { 모드: 0o600 }; }
-    catch (err) { this.잠금 = { 못함: err?.code ?? String(err) }; }
+    this.잠금 = 본인만잠그기(this.file);
   }
 
   /** 기록이 새고 있나. 새고 있으면 `{수, 까닭}`, 멀쩡하면 null. */

package/src/safety/authcmd.js

@@ -49,7 +49,7 @@ import { isOffline } from './network.js';
 import { 가리기 } from './secrets.js';
 
 /** 기다려 주는 시간. 사내 로그인은 브라우저를 열고 사람을 기다린다. */
-export const 기본기다림 = 180000;
+const 기본기다림 = 180000;
 
 /** 수명을 안 알려 줄 때 몇 초짜리로 볼까. 짧게 잡는다 — 늦게 아는 것보다 낫다. */
 export const 기본수명 = 3300;

package/src/safety/guard.js

@@ -1,9 +1,9 @@
 // 자율 실행의 울타리.
 // 승인 프롬프트를 안 쓰는 대신 (1) 작업 범위 밖은 못 건드리고
 // (2) 되돌릴 수 없는 명령만 막는다. 나머지는 전부 통과시킨다.
-import { resolve, relative, isAbsolute, sep, dirname, basename } from 'node:path';
-import { realpathSync, existsSync } from 'node:fs';
-import { homedir } from 'node:os';
+import { resolve, relative, isAbsolute, sep, dirname, basename, win32, posix } from 'node:path';
+import { realpathSync, existsSync, readFileSync } from 'node:fs';
+import { homedir, userInfo } from 'node:os';
 import { 내부살림 } from '../tools/fsutil.js';
 
 export class ScopeError extends Error {}
@@ -110,8 +110,28 @@ export function makeScope(root) {
       // Git Bash 꼴 절대 경로(/c/Users/…)는 윈도우에서 C:\Users\… 다. 안 풀면 지금
       // 드라이브 밑의 \c\Users\… 로 읽혀, 안에 있는 파일이 '범위 밖' 으로 막힌다.
       const 경로 = MSYS풀기(p);
-      const abs = isAbsolute(경로) ? resolve(경로) : resolve(base, 경로);
-      if (밖(base, abs)) throw new ScopeError(`작업 범위 밖입니다: ${p}\n  범위: ${base}`);
+      let abs = isAbsolute(경로) ? resolve(경로) : resolve(base, 경로);
+      /*
+       * ── 글자로는 밖인데 **같은 자리를 다르게 적은 것** (2.0.2 · A5) ──────────────
+       *
+       * 윈도우는 한 폴더를 두 이름으로 적는다 — `C:\Users\RUNNER~1\…`(8.3) 와
+       * `C:\Users\runneradmin\…`. 뿌리를 짧은 이름으로 들고 있는데 모델이 긴 이름
+       * 절대경로를 주면(셸의 pwd · 오류 글 · 딴 도구의 답에서 베낀 것), 여기가 글자로만
+       * 견줘 **같은 폴더의 파일을 「작업 범위 밖」 으로** 막았다. 재 봤다 —
+       * `DEEL_A~1` 뿌리에서 `deel_a5_longfoldername_…\b.txt` 쓰기가 막혔다.
+       *
+       * 그래서 글자로 밖이면 한 번 더 **실제 자리끼리** 견준다. 실제로도 밖이면 그대로
+       * 막는다. 실제로는 안이면 받아 들이되, 돌려주는 경로는 **뿌리가 적힌 꼴로** 다시
+       * 붙인다 — 되돌리기 기록(rel)·화면 경로(show)·커밋이 다 뿌리의 꼴로 견주기 때문이다.
+       * 긴 이름 그대로 넘기면 여기만 지나고 아래에서 같은 병이 다시 난다.
+       */
+      if (밖(base, abs)) {
+        const 실제 = 진짜자리(abs);
+        const 뿌리실제 = 진짜뿌리();
+        if (밖(뿌리실제, 실제)) throw new ScopeError(`작업 범위 밖입니다: ${p}\n  범위: ${base}`);
+        const 안쪽 = relative(같은꼴(뿌리실제), 같은꼴(실제));
+        abs = 안쪽 ? resolve(base, 안쪽) : base;
+      }
       // 글자로는 안인데 링크를 따라가면 밖인 자리. 정션 하나로 울타리가 열린다.
       //
       // 여기 견주기도 한 모양으로 맞춘다. 맥에서 realpathSync 는 디스크에 있는
@@ -560,6 +580,36 @@ export function checkPaths(cmd, scope) {
   return true;
 }
 
+/*
+ * ── `~이름` 이 가리키는 집 (2.0.2 · 388) ────────────────────────────────────
+ *
+ * 「내 집 옆자리」 로만 풀었다. 그런데 root 로 돌면 내 집이 `/root` 라 옆자리가 **뿌리**다 —
+ * `~admin` 이 `/admin` 이 됐다. 셸은 passwd 의 `/home/admin` 으로 가는데. 작업 폴더가 마침
+ * `/admin` 이면 남의 집을 「범위 안」 으로 읽는다.
+ *
+ * 유닉스에서는 passwd 에 적힌 집을 먼저 본다(셸이 보는 그 자리). 없으면(맥의 디렉터리 서비스 ·
+ * 윈도) 예전처럼 내 집 옆자리로 풀되, 그 옆자리가 뿌리면 관례 자리(`/home`)로 간다. 내 이름이면
+ * 내 집이다.
+ */
+export function 남의집(이름, { 집 = homedir(), 나 = null, passwd = null, platform = process.platform } = {}) {
+  let 내이름 = 나;
+  if (내이름 == null) { try { 내이름 = userInfo().username; } catch { 내이름 = ''; } }
+  if (이름 === 내이름) return 집;
+  if (platform !== 'win32') {
+    let 글 = passwd;
+    if (글 == null) { try { 글 = readFileSync('/etc/passwd', 'utf8'); } catch { 글 = ''; } }
+    for (const 줄 of String(글).split('\n')) {
+      const 칸 = 줄.split(':');
+      if (칸[0] === 이름 && 칸[5]) return 칸[5];
+    }
+  }
+  // 판을 넘겨받았으면 경로 셈도 그 판으로 한다. 리눅스에서 윈도 판을 물으면 `C:\Users\me` 가
+  // 상대경로로 읽혀 작업 폴더 밑이 됐다(검사만 그 판을 만든다 — 실제로는 늘 이 PC 의 판이다).
+  const 길 = platform === 'win32' ? win32 : posix;
+  const 옆 = 길.dirname(집);
+  return 길.resolve(옆 === 길.parse(옆).root ? 길.join(옆, 'home') : 옆, 이름);
+}
+
 // 셸이 알아서 풀어 주는 자리표. 우리도 같이 풀어야 실제로 닿는 곳을 본다.
 function 자리표풀기(s) {
   return s
@@ -582,7 +632,7 @@ function 자리표풀기(s) {
      * 남의 집은 어느 쪽으로 풀든 내 작업 폴더 밖이다. 이름은 글자·밑줄로 시작할 때만 받는다
      * (`~1` · `~+` 은 셸의 다른 뜻). 가운데 물결(`./~backup` · `PROGRA~1`)은 `^` 에 안 닿는다.
      */
-    .replace(/^~([A-Za-z_][\w.-]*)(?=[/\\]|$)/, (전체, 이름) => resolve(dirname(homedir()), 이름))
+    .replace(/^~([A-Za-z_][\w.-]*)(?=[/\\]|$)/, (전체, 이름) => 남의집(이름))
     /*
      * 파워셸은 `$env:이름` 으로 적는다.
      *

package/src/safety/hooks.js

@@ -55,7 +55,7 @@ export const 제한기본 = 15000;
 /** 한 훅이 뱉을 수 있는 글의 최대. 넘으면 자르고 잘랐다고 말한다. */
 export const 글최대 = 16 * 1024;
 /** 한 자리에서 돌릴 수 있는 훅 수. 이보다 많으면 설정이 잘못된 것이다. */
-export const 훅최대 = 32;
+const 훅최대 = 32;
 
 /**
  * 훅을 걸 수 있는 자리.

package/src/safety/keystore.js

@@ -222,7 +222,7 @@ export function 잠그기(글, { 프로필id = null } = {}) {
 
   if (process.platform === 'win32') {
     const r = 파워셸실행(잠그는스크립트, Buffer.from(값, 'utf8').toString('base64'));
-    if (r.ok && r.out) return `dpapi:${r.out}`;
+    if (r.ok && r.out) return 됐다(`dpapi:${r.out}`);
     못잠근까닭 = r.err || '파워셸이 잠그기를 못 마쳤습니다';
     해보고졌나 = true;
     return null;
@@ -230,7 +230,7 @@ export function 잠그기(글, { 프로필id = null } = {}) {
   if (process.platform === 'darwin') {
     const 이름 = 키체인이름(프로필id);
     const r = 키체인넣기(값, 이름);
-    if (r.ok) return `keychain:${이름}`;
+    if (r.ok) return 됐다(`keychain:${이름}`);
     못잠근까닭 = r.err || 'security 가 열쇠를 못 넣었습니다';
     해보고졌나 = true;
     return null;
@@ -282,7 +282,22 @@ let 못잠근까닭 = null;
  */
 let 해보고졌나 = false;
 
-/** 마지막으로 잠그다 실패한 까닭. 한 번도 실패한 적이 없으면 null. */
+/*
+ * ── 되고 나면 옛 실패를 **내려놓는다** (2.0.2 · 530) ──────────────────────
+ *
+ * 잠그기가 한 번 지면 그 까닭이 프로세스 내내 남았다. 뒤에 같은 판에서 잠그기가 되어도
+ * (파워셸이 잠깐 막혔다 풀림 · 키체인이 잠겼다 열림) 보관방식() 은 평문 값을 보면 여전히
+ * 「잠그려다 실패했습니다」 라고 적었다 — 지금은 되는 장치를 안 된다고 말하는 것이다.
+ * 되면 지운다. config.js 가 「몇 개를 왜 못 잠갔나」 에 쓰는 까닭은 그쪽이 **진 순간에**
+ * 받아 둔다(잠금옮기기).
+ */
+function 됐다(값) {
+  못잠근까닭 = null;
+  해보고졌나 = false;
+  return 값;
+}
+
+/** 마지막으로 잠그다 실패한 까닭. 한 번도 실패한 적이 없으면(또는 그 뒤로 됐으면) null. */
 export function 잠그다실패한까닭() { return 못잠근까닭; }
 
 /** 사람이 스스로 껐나. 껐으면 이 판에서는 **아무것도 안 해 본다.** */

package/src/safety/shellenv.js

@@ -116,7 +116,7 @@ function 이름마디들(이름) {
 const 자격든주소 = /^[a-z][a-z0-9+.-]*:\/\/[^\s/?#@:]*:[^\s/?#@]+@/i;
 
 /** 이 값이 자격이 든 주소인가. 이름으로는 못 거르는 DATABASE_URL 같은 것을 거른다. */
-export function 비밀값인가(값) {
+function 비밀값인가(값) {
   return typeof 값 === 'string' && 자격든주소.test(값.trim());
 }
 

package/src/safety/undo.js

@@ -1,7 +1,8 @@
 // 되돌리기. 승인 프롬프트를 안 쓰는 대신 이게 안전망이다.
 // 파일을 고치기 전에 항상 이전 내용을 떠 놓고, /undo 로 턴 단위로 되돌린다.
 import { join, dirname, basename, resolve, relative, isAbsolute, sep } from 'node:path';
-import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync, appendFileSync, statSync, chmodSync, renameSync, realpathSync, openSync, readSync, closeSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync, rmdirSync, appendFileSync, statSync, renameSync, realpathSync } from 'node:fs';
+import { 줄로끝나나, 본인만잠그기 } from '../jsonl.js';
 import { looksBinary } from '../tools/encoding.js';
 import { 살림폴더만들기 } from './audit.js';
 import { 말 } from '../i18n/index.js';
@@ -86,6 +87,19 @@ export class History {
     this.잠금 = null;
   }
 
+  /** 이 경로의 조상 가운데 **아직 없는** 폴더들(뿌리 기준 상대 경로, 깊은 것부터). 뿌리 밖으로는 안 올라간다. */
+  #없는폴더들(abs) {
+    const 들 = [];
+    let d = dirname(resolve(String(abs)));
+    for (let i = 0; i < 64 && !existsSync(d); i++) {
+      const 상대 = this.#상대(d);
+      if (상대 === null) break;
+      들.push(상대);
+      d = dirname(d);
+    }
+    return 들;
+  }
+
   /** 새 기록에 적을 상대 경로. 뿌리 밖이면 null — 그런 기록은 되돌릴 때 안 받는다. */
   #상대(abs) {
     const a = resolve(String(abs));
@@ -120,23 +134,11 @@ export class History {
    * 개행으로 끝내므로 한 번 본 것이 계속 맞다.
    */
   #줄끝봤나 = false;
-  #줄로끝나나() {
-    let fd = null;
-    try {
-      const 크기 = statSync(this.file).size;
-      if (!크기) return true;
-      fd = openSync(this.file, 'r');
-      const 한바이트 = Buffer.alloc(1);
-      readSync(fd, 한바이트, 0, 1, 크기 - 1);
-      return 한바이트[0] === 0x0a;
-    } catch { return true; }         // 없거나 못 읽으면 붙일 반쪽도 없다
-    finally { if (fd != null) { try { closeSync(fd); } catch { /* 닫다 터져도 적기는 한다 */ } } }
-  }
 
   #덧붙이기(rec) {
     let 줄 = 적을줄(rec) + '\n';
     if (!this.#줄끝봤나) {
-      if (!this.#줄로끝나나()) 줄 = '\n' + 줄;
+      if (!줄로끝나나(this.file)) 줄 = '\n' + 줄;
       this.#줄끝봤나 = true;
     }
     appendFileSync(this.file, 줄, 'utf8');
@@ -166,11 +168,7 @@ export class History {
   #잠그기() {
     if (this.#잠갔나) return;
     this.#잠갔나 = true;
-    // 윈도우에서 chmod 는 아무 일도 안 하고 **성공한다.** 그 성공을 적으면 위 머리말이 금지한
-    // 「잠근 척」 이다 — agent/store.js 와 같이 안 걸었다고 적는다.
-    if (process.platform === 'win32') { this.잠금 = { 못함: 'windows' }; return; }
-    try { chmodSync(this.file, 0o600); this.잠금 = { 모드: 0o600 }; }
-    catch (err) { this.잠금 = { 못함: err?.code ?? String(err) }; }
+    this.잠금 = 본인만잠그기(this.file);
   }
 
   /**
@@ -236,6 +234,22 @@ export class History {
      * 그림·문서가 /undo 뒤에도 남았다. 이 표가 있으면 정말 없던 자리라 바이너리여도 지운다.
      */
     if (없던) rec.없던 = true;
+    /*
+     * ── 이 파일과 **같이 생길 폴더**도 적는다 (2.0.2 · B3) ─────────────────────
+     *
+     * 폴더를 통째로 옮긴 판(`dirA` → `dirB`)을 되돌리면 파일은 `dirA` 로 돌아오고
+     * `dirB/f.txt` 는 「원래 없던 파일」 로 지워지는데, **빈 `dirB` 가 남았다.** 되돌린
+     * 뒤의 폴더가 되돌리기 전과 다르다. 그 폴더가 이번에 생겼다는 것을 아무 데도
+     * 안 적어서 지울 근거가 없었다.
+     *
+     * 원래 있던 빈 폴더에 파일을 만든 판과 가르려면 **뜰 때** 봐야 한다 — 되돌릴 때는
+     * 둘 다 「빈 폴더」 라 구별이 안 된다. 그래서 여기서 아직 없는 조상 폴더를 깊은
+     * 것부터 적어 두고, 되돌릴 때 그 폴더가 **비었을 때만** 지운다.
+     */
+    if (없던) {
+      const 새폴더 = this.#없는폴더들(absPath);
+      if (새폴더.length) rec.새폴더 = 새폴더;
+    }
     // 작업 폴더 기준 자리. 폴더를 옮기거나 복사해도 이 이력은 **그 폴더**를 되돌린다 (위 머리말).
     const 상대 = this.#상대(absPath);
     if (상대 !== null) rec.rel = 상대;
@@ -618,6 +632,16 @@ export class History {
           }
           rmSync(path, { force: true });
           restored.push({ path, how: 말('undo.wayDeleted'), ok: true });
+          // 그 파일과 같이 생긴 폴더가 이제 비었으면 거둔다 (snapshot 의 새폴더 머리말). rmdirSync 는 **빈
+          // 폴더만** 지운다 — 그 뒤에 누가 넣은 것이 있으면 ENOTEMPTY 로 멈추고, 폴더가 아니면 ENOTDIR 다.
+          // 이력은 저장소에 딸려 올 수 있으니(파일 머리말) 폴더 자리도 밖·링크 너머면 안 건드린다.
+          // 파일이 아니라서 되돌린 수에는 안 센다.
+          for (const 상대 of rec.새폴더 ?? []) {
+            const d = this.#자리풀기(null, 상대);
+            if (!d || 링크밖(d)) break;
+            try { rmdirSync(d); } catch { break; }
+            restored.push({ path: d, how: '빈 폴더 지움 (이번에 새로 생긴 폴더)', ok: true, 폴더: true });
+          }
         } else {
           /*
            * 담고 있던 폴더가 없어졌을 수 있다 — Move 로 폴더째 옮긴 경우다.
@@ -710,7 +734,7 @@ export class History {
       // 이력에서 못 읽은 줄 수. 그만큼은 되돌릴 길이 애초에 없었다.
       깨진줄: this.깨진줄,
       // 화면·감사기록이 쓰는 수. **진짜로 되돌아간 것만** 센다.
-      되돌린수: restored.filter((x) => x.ok === true).length,
+      되돌린수: restored.filter((x) => x.ok === true && !x.폴더).length,
       못한것: restored.filter((x) => x.ok === false),
       turns: turns.length,
       turnIds: turns.slice(),

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/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';