deel-local-cli 1.20.10 → 1.20.12

package/src/reset.js

@@ -31,6 +31,7 @@ import { existsSync, readFileSync, readdirSync, rmSync } from 'node:fs';
 import { c, say, mark, rule, pad } from './ui/ansi.js';
 import { ask, confirm } from './ui/prompt.js';
 import { homeDir } from './config.js';
+import { pluginsDir } from './plugins/manage.js';
 import { 잠긴것인가, 잠금지우기, 보관방식 } from './safety/keystore.js';
 
 /** 사람이 칠 수 있는 이름. bin/deel.js 의 도움말·완성 목록과 같아야 한다. */
@@ -41,16 +42,28 @@ export const 갈래들 = ['model', 'memory', 'sessions', 'learned', 'plugins', '
 // 세다가 나는 탈은 전부 삼킨다. 이건 '무엇이 있나' 를 보여 주려는 것이지
 // 검사가 아니다 — 한 줄 못 셌다고 초기화 자체를 못 하게 하면 안 된다.
 
+/*
+ * 다만 **없는 것과 못 읽은 것은 가른다.** 둘 다 0 으로 적으면, 지우기 전
+ * 확인 화면이 「기억 0줄 → 돌아오지 않습니다」 라고 말한다. 사람은 잃을 것이
+ * 없다고 읽고 넘기는데, 바로 다음 줄에서 폴더가 통째로 사라진다.
+ * 없으면 0, 못 읽으면 null 이다 — null 은 화면에서 「알 수 없음」 으로 뜬다
+ * (설정살피기 가 이미 그렇게 하고 있다).
+ */
 function 줄수(파일) {
+  if (!existsSync(파일)) return 0;
   try { return readFileSync(파일, 'utf8').split('\n').filter((l) => l.trim()).length; }
-  catch { return 0; }
+  catch { return null; }
 }
 
 function 안에것(폴더, 거르기 = () => true) {
+  if (!existsSync(폴더)) return 0;
   try { return readdirSync(폴더, { withFileTypes: true }).filter(거르기).length; }
-  catch { return 0; }
+  catch { return null; }
 }
 
+/** 여러 자리를 센 것을 하나로 모은다. 한 자리라도 못 셌으면 못 센 것이다. */
+const 셈모으기 = (값들) => (값들.some((n) => n === null) ? null : 값들.reduce((a, n) => a + n, 0));
+
 /**
  * 설정을 읽어 본다. **깨져 있어도 답한다.**
  *
@@ -68,10 +81,21 @@ export function 설정살피기(파일) {
     return { 있나: true, 프로필: null, 잠긴열쇠: [], 왜: `읽을 수 없습니다 (${한줄})` };
   }
   const 목록 = Array.isArray(j?.profiles) ? j.profiles : [];
+  /*
+   * 연결 말고 **다른 것**이 이 파일에 적혀 있나.
+   *
+   * 저장소의 `.deel/config.json` 에는 프로필 대신 `mode` 나
+   * `permissions.deny` 만 적어 두는 쓰임이 있다 (config.js 가 권하는 그
+   * 쓰임이다). 그런 파일을 `deel reset model` 이 통째로 지우면, 사람이 손으로
+   * 적어 둔 **금지 규칙**이 초기화 한 번에 없어진다. 이 파일 머리말이
+   * 「사람이 손으로 적은 것은 어떤 길로도 안 지운다」 고 적어 둔 그 약속이다.
+   */
+  const 연결칸 = new Set(['profiles', 'active', '정책주소', 'api-version']);
   return {
     있나: true,
     프로필: 목록.length,
     잠긴열쇠: 목록.map((p) => p?.apiKey).filter((k) => 잠긴것인가(k)),
+    다른것: Object.keys(j ?? {}).filter((k) => !연결칸.has(k)),
     왜: '',
   };
 }
@@ -91,12 +115,15 @@ export function 살펴보기({ home = homeDir(), root = process.cwd() } = {}) {
   const 집설정 = 설정살피기(집('config.json'));
   const 일설정 = 설정살피기(일('config.json'));
   const 열쇠들 = [...집설정.잠긴열쇠, ...일설정.잠긴열쇠];
+  // 저장소 설정에 연결 말고 다른 것이 적혀 있으면 그 파일은 안 건드린다.
+  const 일설정남길까 = 일설정.있나 && (일설정.프로필 === null || (일설정.다른것?.length ?? 0) > 0);
+  const 플러그인자리 = pluginsDir(home);
 
   const 항목 = [
     {
       키: 'model',
       이름: '연결·프로필',
-      자리: [집('config.json'), 일('config.json')],
+      자리: [집('config.json'), ...(일설정남길까 ? [] : [일('config.json')])],
       몇: 집설정.프로필 === null || 일설정.프로필 === null
         ? null : (집설정.프로필 ?? 0) + (일설정.프로필 ?? 0),
       단위: '개',
@@ -139,7 +166,7 @@ export function 살펴보기({ home = homeDir(), root = process.cwd() } = {}) {
       키: '만든것',
       이름: '증거·내보낸 것·임시',
       자리: [일('증거'), 일('export'), 일('tmp'), 일('붙인그림')],
-      몇: [일('증거'), 일('export'), 일('tmp'), 일('붙인그림')].reduce((n, p) => n + 안에것(p), 0),
+      몇: 셈모으기([일('증거'), 일('export'), 일('tmp'), 일('붙인그림')].map((p) => 안에것(p))),
       단위: '개',
       뒤: '안전합니다',
       all: true,
@@ -148,8 +175,11 @@ export function 살펴보기({ home = homeDir(), root = process.cwd() } = {}) {
     {
       키: 'plugins',
       이름: '플러그인',
-      자리: [집('plugins')],
-      몇: 안에것(집('plugins'), (e) => e.isDirectory() && !e.name.startsWith('.')),
+      // 깔리는 자리와 **같은 함수**로 고른다 (plugins/manage.js 의 pluginsDir).
+      // 두 자리가 갈리면 화면이 「0개 · 이미 비어 있습니다」 를 찍는데
+      // 플러그인은 그대로 살아 있다.
+      자리: [플러그인자리],
+      몇: 안에것(플러그인자리, (e) => e.isDirectory() && !e.name.startsWith('.')),
       단위: '개',
       뒤: c.yellow('다시 설치해야 합니다'),
       // 따로 고를 때만 지운다. 다시 받는 데 시간이 걸리고, 사람이 초기화하려는
@@ -181,6 +211,7 @@ export function 살펴보기({ home = homeDir(), root = process.cwd() } = {}) {
   // 어떤 길로도 안 지우는 것. 화면에 이름을 적어 둔다 — 「왜 이건 안 지웠지」
   // 를 나중에 묻게 하지 않으려고.
   const 안건드림 = [
+    { 이름: '.deel/config.json (연결 말고 다른 것이 적혀 있습니다)', 있나: 일설정남길까 },
     { 이름: '.deel/mcp.json', 있나: existsSync(일('mcp.json')) },
     { 이름: '.deelignore', 있나: existsSync(join(root, '.deelignore')) },
     { 이름: 'DEEL.md', 있나: existsSync(join(root, 'DEEL.md')) },

package/src/safety/hooks.js

@@ -156,7 +156,10 @@ export function 훅펴기(raw, 출처) {
   if (Array.isArray(것)) {
     for (const x of 것) {
       const 자리 = 자리풀기(x?.때 ?? x?.자리 ?? x?.event);
-      if (!자리) { 버린것.push(`모르는 자리: ${x?.때 ?? x?.event ?? '(없음)'}`); continue; }
+      // 바로 위에서 `때 · 자리 · event` 셋을 다 보고 골랐는데, 무엇이 틀렸는지
+      // 적을 때는 `자리` 만 빠져 있었다. `{자리: '오타'}` 로 적어 둔 사람은
+      // 「모르는 자리: (없음)」 을 받는다 — 제가 적은 글자가 화면에 안 나온다.
+      if (!자리) { 버린것.push(`모르는 자리: ${x?.때 ?? x?.자리 ?? x?.event ?? '(없음)'}`); continue; }
       const h = 한훅(자리, x?.도구 ?? x?.matcher ?? '*', x, 출처);
       if (h) 훅들.push(h); else 버린것.push(`${자리}: 명령이나 무늬가 잘못 적혀 있습니다`);
     }

package/src/safety/runmode.js

@@ -89,6 +89,21 @@ export function 지금모드({ online = false, offline = false } = {}) {
   return 기본;
 }
 
+/**
+ * 봉인이 켜져 있나 — 깃발·프로필·설정 **셋 중 하나라도** 켜져 있으면 켜진 것이다.
+ *
+ * 여태 부르는 자리마다 `깃발 ?? prof.offline ?? cfg.offline` 으로 골랐다.
+ * `??` 는 null·undefined 에서만 다음 칸으로 넘어가는데, 부르는 쪽이 깃발을
+ * **언제나 boolean 으로** 넘겼다 (bin/deel.js 의 `flags.offline === true || …`).
+ * 그래서 첫 칸이 늘 false 로 차 있었고 뒤의 둘은 한 번도 안 읽혔다 —
+ * 관리자가 정책에 못 박아 둔 봉인도, 사람이 제 손으로 설정에 적은 봉인도
+ * 아무 데도 안 붙어 있었다. 정책은 켜기만 하므로 여기서는 OR 로 모은다.
+ */
+export function 봉인됐나({ 깃발 = undefined, prof = null, cfg = null } = {}) {
+  return 깃발 === true || 깃발 === 'true'
+    || prof?.offline === true || cfg?.offline === true;
+}
+
 /**
  * 이 주소가 바깥인가.
  *

package/src/safety/undo.js

@@ -122,18 +122,54 @@ export class History {
   #maybePrune() {
     this.#writes = (this.#writes ?? 0) + 1;
     if (this.#writes % 20 !== 0) return;
+    // 앞서 못 줄였으면 한참 쉬었다가 다시 본다 (prune 의 주석).
+    if (this.#writes < this.#다음줄이기) return;
     try {
       if (statSync(this.file).size < MAX_BYTES) return;
     } catch { return; }
-    this.prune();
+    /*
+     * 줄이다 터져도 **고치던 파일까지 말려들면 안 된다.**
+     *
+     * 이 함수는 snapshot() 안에서 돈다 — 즉 Write·Edit 이 파일을 쓰기
+     * 직전이다. prune() 이 이력을 읽다 던지면(EACCES·EBUSY) 그 예외가
+     * 도구 밖으로 새어 나가, 사람은 고치려던 파일과 아무 상관 없는
+     * 「EACCES: …/edits.jsonl」 을 보게 된다. 이력을 못 줄인 것은
+     * 위쪽(줄이기못함)에 남기고, 고치는 일은 그대로 이어 간다.
+     */
+    try { this.prune(); }
+    catch (err) {
+      this.줄이기못함 = err?.message ?? String(err);
+      this.#다음줄이기 = this.#writes + 500;
+    }
   }
 
+  #다음줄이기 = 0;
+  /** 이력을 못 줄였으면 그 까닭. 못 줄이면 안전망이 제 무게로 무너진다. */
+  줄이기못함 = null;
+
   #writes = 0;
 
   /** 최근 keep 개 턴만 남기고 자른다. 버린 줄 수를 돌려준다. */
   prune({ keep = KEEP_TURNS } = {}) {
-    const recs = this.all();
-    const turns = this.turns();
+    /*
+     * ── **읽다 터지는 것**도 못 줄인 것이다 ────────────────────────────
+     *
+     * 아래 쓰기만 감싸 두고 여기 읽기는 맨몸이었다. 그런데 이력을 못 읽는
+     * 판(권한·잠김·자리가 폴더로 바뀜)은 못 쓰는 판만큼이나 흔하고, 그때
+     * 예외가 여기를 뚫고 나가면 부르는 쪽 — 파일을 쓰던 Write·Edit — 이
+     * 고치려던 파일과 아무 상관 없는 오류를 뒤집어쓴다.
+     *
+     * 못 줄인 것은 못 줄였다고 위쪽(줄이기못함)에 남기고 0을 돌려준다.
+     * 그게 이 함수가 실패를 말하는 유일한 방식이라 여기서도 같아야 한다.
+     */
+    let recs;
+    let turns;
+    try { recs = this.all(); turns = this.turns(); }
+    catch (err) {
+      this.줄이기못함 = err?.message ?? String(err);
+      this.#다음줄이기 = (this.#writes ?? 0) + 500;
+      return 0;
+    }
     if (turns.length <= keep) return 0;
     const 남길턴 = new Set(turns.slice(-keep));
     const 남길것 = recs.filter((r) => 남길턴.has(r.turn));
@@ -143,7 +179,22 @@ export class History {
       writeFileSync(this.file, 남길것.map((r) => JSON.stringify(r)).join('\n') + (남길것.length ? '\n' : ''), 'utf8');
       // 통째로 다시 쓰면 새 파일일 수 있다 — 빗장을 다시 건다 (agent/store.js 도 같다).
       this.#잠갔나 = false; this.#잠그기();
-    } catch { return 0; }
+      this.줄이기못함 = null;
+    } catch (err) {
+      /*
+       * 못 줄인 것을 **0개 버렸다**와 같은 값으로 돌려주고 있었다.
+       *
+       * 부르는 쪽은 둘을 구별할 길이 없다. 그리고 실패는 대개 이어진다 —
+       * 읽기 전용이거나 디스크가 찬 것이라 다음 번에도 같다. 그러면 이력은
+       * 32MB 를 넘긴 채 끝없이 자라는데 화면에는 영영 안 뜬다.
+       *
+       * 곧바로 또 시도하지도 않는다. 32MB 짜리 파일을 스무 번 쓸 때마다
+       * 통째로 다시 읽는 셈이라, 실패가 이어지면 그 자체가 느려지는 원인이 된다.
+       */
+      this.줄이기못함 = err?.message ?? String(err);
+      this.#다음줄이기 = (this.#writes ?? 0) + 500;
+      return 0;
+    }
     return 버린수;
   }
 
@@ -152,12 +203,30 @@ export class History {
     try { return statSync(this.file).size; } catch { return 0; }
   }
 
+  /*
+   * ── 깨진 줄은 **되돌릴 수 없는 파일**이다 ────────────────────────────
+   *
+   * 여태 `catch { return null }` 로 조용히 버렸다. 그런데 이 파일의 한 줄은
+   * 곧 한 파일의 원문이다 — 줄이 깨졌다는 것은 그 파일을 되돌릴 길이
+   * 사라졌다는 뜻이다. 그걸 안 세면 `/undo` 는 「파일 3개를 되돌렸습니다」
+   * 라고만 하고, 넷째 파일이 왜 안 돌아왔는지는 아무 데도 안 남는다.
+   *
+   * 줄은 실제로 깨진다. 쓰다 죽으면 마지막 줄이 반만 적히고, 같은 폴더에서
+   * 창을 둘 띄워 놓으면 큰 줄 둘이 서로 끼어든다(appendFileSync 는 긴 줄을
+   * 통째로 보장하지 않는다).
+   */
+  /** 마지막으로 읽을 때 깨져 있던 줄 수. 0 이 아니면 그만큼 못 되돌린다. */
+  깨진줄 = 0;
+
   all() {
     if (!existsSync(this.file)) return [];
-    return readFileSync(this.file, 'utf8')
+    let 깨진 = 0;
+    const 것들 = readFileSync(this.file, 'utf8')
       .split('\n').filter(Boolean)
-      .map((l) => { try { return JSON.parse(l); } catch { return null; } })
+      .map((l) => { try { return JSON.parse(l); } catch { 깨진 += 1; return null; } })
       .filter(Boolean);
+    this.깨진줄 = 깨진;
+    return 것들;
   }
 
   turns() {
@@ -232,10 +301,31 @@ export class History {
      */
     const 못한것 = new Set(restored.filter((x) => x.ok === false).map((x) => x.path));
     const keep = recs.filter((r) => !turns.includes(r.turn) || 못한것.has(r.path));
-    writeFileSync(this.file, keep.map((r) => JSON.stringify(r)).join('\n') + (keep.length ? '\n' : ''), 'utf8');
-    this.#잠갔나 = false; this.#잠그기();
+    /*
+     * ── 여기가 터지면 **파일은 이미 되돌아가 있다** ────────────────────
+     *
+     * 감싸지 않은 쓰기였다. 던지면 위에서 받아 「명령을 처리하다 막혔습니다」
+     * 한 줄만 남는다 — 그런데 디스크의 파일들은 방금 되돌아갔다. 화면이
+     * 실패라고 말하는데 실제로는 성공한, 이 저장소가 계속 잡아 온 어긋남이
+     * 방향만 뒤집힌 꼴이다.
+     *
+     * 게다가 이력을 못 줄였으니 그 턴이 그대로 남는다. 사람이 「실패했으니
+     * 다시」 하고 /undo 를 또 치면 **같은 턴**을 또 되돌린다 — 두 턴을
+     * 되돌린 줄 알지만 한 턴이다.
+     */
+    let 이력줄임 = { ok: true };
+    try {
+      writeFileSync(this.file, keep.map((r) => JSON.stringify(r)).join('\n') + (keep.length ? '\n' : ''), 'utf8');
+      this.#잠갔나 = false; this.#잠그기();
+    } catch (err) {
+      이력줄임 = { ok: false, 왜: err?.message ?? String(err) };
+    }
     return {
       restored,
+      // 이력에서 그 턴을 지웠나. 못 지웠으면 같은 턴이 그대로 남아 있다.
+      이력줄임,
+      // 이력에서 못 읽은 줄 수. 그만큼은 되돌릴 길이 애초에 없었다.
+      깨진줄: this.깨진줄,
       // 화면·감사기록이 쓰는 수. **진짜로 되돌아간 것만** 센다.
       되돌린수: restored.filter((x) => x.ok === true).length,
       못한것: restored.filter((x) => x.ok === false),

package/src/setup.js

@@ -12,7 +12,7 @@ import { 보관방식 } from './safety/keystore.js';
 import { 애저풀기, 애저base } from './backend/azure.js';
 import { allowEndpoint } from './safety/network.js';
 import { 인증서설정, 인증서등록 } from './backend/clientcert.js';
-import { 바깥인가 } from './safety/runmode.js';
+import { 바깥인가, 봉인됐나 } from './safety/runmode.js';
 import { 제공자들, 제공자고르기, 어디것일까, 주소후보, 막힌까닭 } from './providers/index.js';
 import { writeFileSync } from 'node:fs';
 
@@ -107,8 +107,21 @@ async function chooseModel(found) {
   return items[i].label;
 }
 
-// 진단을 돌리고 결과를 화면에 그린다.
-export async function runProbe(conn, { out = null } = {}) {
+/*
+ * 진단을 돌리고 결과를 화면에 그린다.
+ *
+ * **봉인은 진단에도 걸린다.** 여기가 빠져 있었다 — 관리자가 정책으로 밖을
+ * 막아 둔 PC 에서도 `deel diagnose` 는 그냥 나갔다. 자물쇠가 명령 하나로
+ * 열리면 자물쇠가 아니다. 사내망 주소는 봉인에서도 그대로 간다.
+ */
+export async function runProbe(conn, { out = null, 봉인 = false } = {}) {
+  if (봉인 && 바깥인가(conn.base)) {
+    say('');
+    say(`  ${mark.no} ${c.red('봉인되어 있어 이 주소는 안 두드립니다.')} ${c.gray(conn.base)}`);
+    say(`     ${c.gray('관리 정책이나 설정에 offline 이 켜져 있습니다. 사내망 주소는 그대로 됩니다.')}`);
+    say('');
+    return { facts: null, results: null, v: null, 봉인: true };
+  }
   allowEndpoint(conn.base);   // 진단도 이 주소 하나로만 나간다
   renderHeader({ shape: conn.kind, base: conn.base, auth: conn.auth, model: conn.model });
   const { facts, results } = await probe(conn, renderLine);
@@ -344,9 +357,11 @@ export async function runSetup() {
 export async function runDiagnose(flags) {
   banner();
   let conn;
+  let 쓴설정 = null;
+  let 쓴프로필 = null;
 
   if (flags.url) {
-    load();      // 설정의 api-version 을 먼저 읽는다 (runSetup 과 같은 이유)
+    쓴설정 = load();      // 설정의 api-version 을 먼저 읽는다 (runSetup 과 같은 이유)
     const key = flags.key ?? process.env.DEEL_API_KEY ?? '';
     const found = await connect(flags.url, key);
     if (!found) return 1;
@@ -356,6 +371,8 @@ export async function runDiagnose(flags) {
   } else {
     const cfg = load();
     const prof = activeProfile(cfg);
+    쓴설정 = cfg;
+    쓴프로필 = prof;
     if (!prof) {
       say(`  ${mark.warn} 저장된 연결이 없습니다. ${c.cyan('deel setup')} 을 먼저 실행하세요.`);
       say(`     ${c.gray('또는')} deel diagnose --url <주소> --key <키> --model <모델>`);
@@ -377,7 +394,11 @@ export async function runDiagnose(flags) {
     };
   }
 
-  await runProbe(conn, { out: flags.out ?? null });
+  /*
+   * 봉인은 --url 로 주소를 직접 준 갈래에도 걸린다. 오히려 그쪽이 더 위험하다
+   * — 설정에 없는 주소를 그 자리에서 두드리는 길이기 때문이다.
+   */
+  await runProbe(conn, { out: flags.out ?? null, 봉인: 봉인됐나({ 깃발: flags.offline, prof: 쓴프로필, cfg: 쓴설정 }) });
   return 0;
 }
 

package/src/skills/discover.js

@@ -11,6 +11,8 @@ import { readdirSync, readFileSync, existsSync } from 'node:fs';
 import { join, basename, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
+import { homeDir } from '../config.js';
+import { pluginsDir } from '../plugins/manage.js';
 // 저장소에 딸려 온 스킬·명령이 시스템 글에 실리지 않게 한다 (discover 안구절 머리말).
 import { 믿나 } from '../safety/trust.js';
 
@@ -163,6 +165,7 @@ function countSkillDirs(rootDir) {
  */
 export function discover(root, opts = {}) {
   const home = opts.home ?? homedir();
+  const 살림 = opts.살림 ?? (opts.home ? join(opts.home, '.deel') : homeDir());
   const caps = { skills: opts.maxSkills ?? 400, commands: opts.maxCommands ?? 400 };
   const skills = [];
   const commands = [];
@@ -177,7 +180,13 @@ export function discover(root, opts = {}) {
   // 같은 플러그인이 cache/ 와 marketplaces/ 양쪽에 있을 수 있다.
   // 이름이 같으면 알맹이가 더 많은 쪽 하나만 쓴다.
   const roots = [];
-  for (const base of [join(home, '.deel', 'plugins'), join(home, '.claude', 'plugins')]) {
+  /*
+   * 우리 플러그인은 **살림 자리** 밑이다 (`~/.deel` 또는 `DEEL_HOME`).
+   * OS 집 폴더에 `.deel` 을 직접 붙이면 `DEEL_HOME` 을 쓰는 휴대용 설치에서
+   * 깔아 놓은 플러그인의 스킬이 안 보인다 — 깔리는 자리(plugins/manage.js)와
+   * 여기가 갈리기 때문이다. 클로드 것(.claude)은 그쪽 규칙이라 집 폴더 그대로다.
+   */
+  for (const base of [pluginsDir(살림), join(home, '.claude', 'plugins')]) {
     if (existsSync(base)) roots.push(...findPluginRoots(base));
   }
   const best = new Map();

package/src/tools/fsutil.js

@@ -297,6 +297,8 @@ const 한숨 = () => new Promise((풀기) => setImmediate(풀기));
 export async function walk(root, { limit = 훑기상한(), skipDirs = SKIP_DIRS, ignore = true, signal = null } = {}) {
   const out = [];
   const 건너뜀 = { 폴더: 0, 파일: 0 };
+  // .gitignore 로 건너뛴 것과 다르다 — 이쪽은 우리가 늘 안 보는 살림 폴더다.
+  const 건너뛴살림 = [];
   let 끊김 = false;
   let 본것 = 0;
   const stack = [{ dir: root, rel: '', 규칙: ignore ? 뿌리규칙읽기(root) : [] }];
@@ -315,7 +317,10 @@ export async function walk(root, { limit = 훑기상한(), skipDirs = SKIP_DIRS,
       const full = join(dir, e.name);
       const erel = rel ? `${rel}/${e.name}` : e.name;
       if (e.isDirectory()) {
-        if (skipDirs.has(e.name)) continue;
+        // 살림 폴더(node_modules·.git·dist…)는 안 훑는다. 다만 **몇 개를
+        // 안 봤는지는 센다** — Move 가 폴더를 통째로 옮길 때 이 수를 모르면
+        // 「폴더 12개 파일」 이라고 말해 놓고 3만 개를 옮기게 된다.
+        if (skipDirs.has(e.name)) { 건너뛴살림.push(erel); continue; }
         if (여기규칙.length && 걸리나(erel, true, 여기규칙)) { 건너뜀.폴더 += 1; continue; }
         stack.push({ dir: full, rel: erel, 규칙: 여기규칙 });
       } else if (e.isFile()) {
@@ -335,6 +340,7 @@ export async function walk(root, { limit = 훑기상한(), skipDirs = SKIP_DIRS,
     if (끊김) break;
   }
   Object.defineProperty(out, '건너뜀', { value: 건너뜀, enumerable: false });
+  Object.defineProperty(out, '건너뛴살림', { value: 건너뛴살림, enumerable: false });
   // 상한까지 찼으면 "여기서 멈췄다" 고 표시한다. 딱 맞아떨어져 끝난 경우까지
   // 잘렸다고 하게 되지만, 그쪽으로 틀리는 편이 낫다 — 덜 봤다고 말하는 것은
   // 사람을 한 번 더 보게 만들 뿐이고, 다 봤다고 말하는 것은 못 보게 만든다.