deel-local-cli 1.20.13 → 2.0.0

package/src/reset.js

@@ -26,11 +26,11 @@
 // 설정을 먼저 읽는다. 그래서 이 파일은 config.js 의 load() 를 안 쓴다 —
 // 파일을 직접 읽고, 못 읽으면 못 읽었다고 적은 채로 계속 간다.
 // (`deel --version` 을 연결 없이 답하게 만든 것과 같은 이유다.)
-import { join, resolve, sep } from 'node:path';
-import { existsSync, readFileSync, readdirSync, rmSync } from 'node:fs';
+import { join, resolve, sep, dirname, basename } from 'node:path';
+import { existsSync, readFileSync, readdirSync, rmSync, writeFileSync, chmodSync, realpathSync } 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 { homeDir, 소식줄들 } from './config.js';
 import { pluginsDir } from './plugins/manage.js';
 import { 잠긴것인가, 잠금지우기, 보관방식 } from './safety/keystore.js';
 
@@ -64,6 +64,12 @@ function 안에것(폴더, 거르기 = () => true) {
 /** 여러 자리를 센 것을 하나로 모은다. 한 자리라도 못 셌으면 못 센 것이다. */
 const 셈모으기 = (값들) => (값들.some((n) => n === null) ? null : 값들.reduce((a, n) => a + n, 0));
 
+/** 두 경로가 같은 파일인가. 윈도우는 대소문자를 안 가린다. */
+const 같은자리 = (a, b) => {
+  const [x, y] = [resolve(a), resolve(b)];
+  return process.platform === 'win32' ? x.toLowerCase() === y.toLowerCase() : x === y;
+};
+
 /**
  * 설정을 읽어 본다. **깨져 있어도 답한다.**
  *
@@ -90,12 +96,24 @@ export function 설정살피기(파일) {
    * 적어 둔 **금지 규칙**이 초기화 한 번에 없어진다. 이 파일 머리말이
    * 「사람이 손으로 적은 것은 어떤 길로도 안 지운다」 고 적어 둔 그 약속이다.
    */
-  const 연결칸 = new Set(['profiles', 'active', '정책주소', 'api-version']);
+  /*
+   * `apiVersion` 은 Azure 판 번호가 실제로 읽히는 이름이다(backend/azure.js).
+   * 여기에 `api-version` 만 있어서 그 칸이 「사람이 적은 다른 것」 으로 잡혔다.
+   * `version` 은 이 프로그램이 파일 모양 번호로 적는 칸이라 사람 것이 아니다 —
+   * 이걸 세면 한 번이라도 저장한 집 설정은 언제나 「다른 것이 있다」 가 된다.
+   */
+  const 연결칸 = new Set(['profiles', 'active', '정책주소', 'api-version', 'apiVersion']);
+  const 구조칸 = new Set(['version']);
+  const 객체 = j && typeof j === 'object' && !Array.isArray(j) ? j : {};
   return {
     있나: true,
     프로필: 목록.length,
     잠긴열쇠: 목록.map((p) => p?.apiKey).filter((k) => 잠긴것인가(k)),
-    다른것: Object.keys(j ?? {}).filter((k) => !연결칸.has(k)),
+    다른것: Object.keys(객체).filter((k) => !연결칸.has(k) && !구조칸.has(k)),
+    // 걷을 연결 칸이 하나라도 있나. 없으면 되쓸 것도 지웠다고 할 것도 없다.
+    연결있나: Object.keys(객체).some((k) => 연결칸.has(k)),
+    // 연결 칸만 걷고 남길 때 적을 모양. 구조 칸은 같이 남긴다.
+    남길값: Object.fromEntries(Object.entries(객체).filter(([k]) => !연결칸.has(k))),
     왜: '',
   };
 }
@@ -113,23 +131,51 @@ export function 살펴보기({ home = homeDir(), root = process.cwd() } = {}) {
   const 일 = (...n) => join(root, '.deel', ...n);
 
   const 집설정 = 설정살피기(집('config.json'));
-  const 일설정 = 설정살피기(일('config.json'));
-  const 열쇠들 = [...집설정.잠긴열쇠, ...일설정.잠긴열쇠];
-  // 저장소 설정에 연결 말고 다른 것이 적혀 있으면 그 파일은 안 건드린다.
+  /*
+   * DEEL_HOME 이 곧 이 폴더의 .deel 이면(홈 폴더에서 돌리면 그렇다) 두 자리는 **한 파일**이다.
+   * 따로 읽으면 프로필을 두 번 세고 지울 자리에도 두 번 적는다. 그때는 집 설정으로만 본다.
+   */
+  const 한파일 = 같은자리(집('config.json'), 일('config.json'));
+  const 일설정 = 한파일 ? { 있나: false, 프로필: 0, 잠긴열쇠: [], 왜: '' } : 설정살피기(일('config.json'));
+  // 저장소 설정에 연결 말고 다른 것이 적혀 있거나 못 읽으면 그 파일은 안 건드린다.
   const 일설정남길까 = 일설정.있나 && (일설정.프로필 === null || (일설정.다른것?.length ?? 0) > 0);
+  // 남기는 파일이 가리키는 열쇠는 잠금장치에서도 안 지운다 — 파일만 남고 열쇠가 사라진다.
+  const 열쇠들 = [...집설정.잠긴열쇠, ...(일설정남길까 ? [] : 일설정.잠긴열쇠)];
+  /*
+   * 집 설정은 사정이 다르다 — 이건 이 PC 의 연결이라 초기화하려는 바로 그것이다.
+   * 그런데 같은 파일에 사람이 건 금지·봉인·셸도 산다. 통째로 지우면 「연결
+   * 초기화」 에 그것들이 딸려 사라졌다. 그래서 파일은 남기고 **연결 칸만** 걷는다.
+   *
+   * 깨졌으면(프로필 null) 통째로 지운다. 깨진 설정이야말로 지우려는 것이고,
+   * 못 읽으면 무엇이 사람 것인지 가를 수도 없다.
+   */
+  const 집설정다듬기 = 집설정.있나 && 집설정.프로필 !== null && 집설정.연결있나 && (집설정.다른것?.length ?? 0) > 0;
+  // 걷을 연결 칸이 아예 없고 사람 칸만 있으면 파일을 **안 건드린다.** 되쓰면 바뀐 것도
+  // 없이 「연결·프로필 0개 지웠습니다」 가 뜨고, 지우는 쪽으로 가면 사람 칸이 없어진다.
+  const 집설정그대로 = 집설정.있나 && 집설정.프로필 !== null && !집설정.연결있나 && (집설정.다른것?.length ?? 0) > 0;
   const 플러그인자리 = pluginsDir(home);
+  // 배운 것도 홈 폴더에서 켜면 두 자리가 **한 파일**이다 — 위 `한파일` 과 같은 판인데 여기만 빠져
+  // 「배운 것 2곳」 으로 셌다 (2.0.0 6회차 · Gemini 되돌림6ab-a R2).
+  const 배운자리 = 같은자리(집('배운것.json'), 일('배운것.json')) ? [집('배운것.json')] : [집('배운것.json'), 일('배운것.json')];
 
   const 항목 = [
     {
       키: 'model',
       이름: '연결·프로필',
-      자리: [집('config.json'), ...(일설정남길까 ? [] : [일('config.json')])],
-      몇: 집설정.프로필 === null || 일설정.프로필 === null
-        ? null : (집설정.프로필 ?? 0) + (일설정.프로필 ?? 0),
+      자리: [
+        ...(집설정그대로 ? [] : [집('config.json')]),
+        ...(일설정남길까 || 한파일 ? [] : [일('config.json')]),
+      ],
+      // 남기는 저장소 설정의 프로필은 **안 센다.** 세면 「3개 → 지웁니다」 라고
+      // 적어 놓고 2개만 지운다. 셈과 지우는 것이 같은 목록을 봐야 한다.
+      몇: 집설정.프로필 === null
+        ? null : (집설정.프로필 ?? 0) + (일설정남길까 ? 0 : (일설정.프로필 ?? 0)),
       단위: '개',
       탈: 집설정.왜 || 일설정.왜,
       뒤: 'deel setup 을 다시 하게 됩니다',
       all: true,
+      // 지우지 않고 연결 칸만 걷어 되쓰는 자리.
+      다듬기: 집설정다듬기 ? [{ 자리: 집('config.json'), 남길값: 집설정.남길값, 남긴칸: 집설정.다른것 }] : [],
       // 설정 파일을 지우기 **전에** 잠금장치를 먼저 손봐야 한다. 파일을
       // 지우고 나면 어느 열쇠가 잠겨 있었는지 알 길이 없다.
       열쇠: 열쇠들,
@@ -155,8 +201,8 @@ export function 살펴보기({ home = homeDir(), root = process.cwd() } = {}) {
     {
       키: 'learned',
       이름: '배운 것',
-      자리: [집('배운것.json'), 일('배운것.json')],
-      몇: [집('배운것.json'), 일('배운것.json')].filter((p) => existsSync(p)).length,
+      자리: 배운자리,
+      몇: 배운자리.filter((p) => existsSync(p)).length,
       단위: '곳',
       뒤: '다시 배웁니다',
       all: true,
@@ -211,7 +257,14 @@ export function 살펴보기({ home = homeDir(), root = process.cwd() } = {}) {
   // 어떤 길로도 안 지우는 것. 화면에 이름을 적어 둔다 — 「왜 이건 안 지웠지」
   // 를 나중에 묻게 하지 않으려고.
   const 안건드림 = [
-    { 이름: '.deel/config.json (연결 말고 다른 것이 적혀 있습니다)', 있나: 일설정남길까 },
+    {
+      이름: 일설정.프로필 === null
+        ? '.deel/config.json (읽을 수 없어서 안 건드립니다 — 저장소에 딸린 파일입니다)'
+        : '.deel/config.json (연결 말고 다른 것이 적혀 있습니다)',
+      있나: 일설정남길까,
+    },
+    { 이름: `이 PC 설정의 ${(집설정.다른것 ?? []).join(' · ')} (연결 칸만 걷습니다)`, 있나: 집설정다듬기 },
+    { 이름: `이 PC 설정의 ${(집설정.다른것 ?? []).join(' · ')} (걷을 연결 칸이 없습니다)`, 있나: 집설정그대로 },
     { 이름: '.deel/mcp.json', 있나: existsSync(일('mcp.json')) },
     { 이름: '.deelignore', 있나: existsSync(join(root, '.deelignore')) },
     { 이름: 'DEEL.md', 있나: existsSync(join(root, 'DEEL.md')) },
@@ -229,13 +282,43 @@ export function 살펴보기({ home = homeDir(), root = process.cwd() } = {}) {
  * 것까지 딸려 가면 이 기능을 못 믿게 된다.
  */
 export function 울타리안인가(경로, 울타리들) {
-  const p = resolve(경로);
+  const p = 윗자리풀기(경로);
   return 울타리들.some((u) => {
     const r = resolve(u);
     return p !== r && p.startsWith(r + sep);
   });
 }
 
+/*
+ * ── 링크를 따라간 진짜 자리로 본다 (2.0.0 6회차 · Gemini 되돌림6ab-b R4) ────────────
+ *
+ * resolve 는 글자만 푼다. 작업 폴더의 `.deel` 이 다른 폴더로 가는 링크면(리눅스·맥 git 은 받은
+ * 저장소의 링크를 그대로 푼다) 그 너머의 memory.md · tmp · export 가 「작업 폴더 안」 으로 읽혀
+ * 통째로 지워졌다 — 임시 폴더로 실행해 확인. 그래서 **윗자리들**을 진짜 경로로 푼 뒤 본다.
+ *
+ * 자리 그 자체는 안 푼다. 그것이 링크면 rmSync 는 링크만 지우고 너머는 그대로다(검사로 확인).
+ * 없는 자리는 있는 데까지 올라가 푼 뒤 나머지 이름을 붙인다 — 글자만 준 검사도 그대로 돈다.
+ */
+function 윗자리풀기(경로) {
+  const p = resolve(경로);
+  const 꼬리 = [basename(p)];
+  let 위 = dirname(p);
+  for (;;) {
+    try { return join(realpathSync.native(위), ...꼬리); } catch {
+      const 더위 = dirname(위);
+      if (더위 === 위) return p;
+      꼬리.unshift(basename(위));
+      위 = 더위;
+    }
+  }
+}
+
+/*
+ * 울타리 쪽 풀기. 살림 자리(home)는 끝까지 푼다 — 사람이 DEEL_HOME 을 링크로 옮겨 둔 것은
+ * 그 사람의 뜻이다. 작업 폴더는 폴더까지만 풀고 `.deel` 은 **안 따라간다** — 거기가 R4 의 문이다.
+ */
+const 실경로 = (p) => { try { return realpathSync.native(p); } catch { return resolve(p); } };
+
 /**
  * 고른 것을 지운다.
  *
@@ -245,7 +328,8 @@ export function 울타리안인가(경로, 울타리들) {
  */
 export function 지우기(무엇, { home = homeDir(), root = process.cwd(), hard = false } = {}) {
   const 본것 = 살펴보기({ home, root });
-  const 울타리 = [home, join(root, '.deel')];
+  // 울타리도 진짜 경로로 — 자리 쪽을 윗자리까지 푸는 것과 짝이다 (6회차 R4 · 위 실경로 머리말).
+  const 울타리 = [실경로(home), join(실경로(root), '.deel')];
 
   const 고른것 = 무엇 === 'all'
     ? [...본것.항목.filter((x) => x.all), ...(hard ? 본것.굳은것 : [])]
@@ -254,11 +338,27 @@ export function 지우기(무엇, { home = homeDir(), root = process.cwd(), hard
   const 지운것 = [];
   const 못한것 = [];
   let 열쇠 = null;
+  let 열쇠들 = [];
 
   for (const 것 of 고른것) {
     // 설정을 지우기 전에 잠금장치부터. 순서가 반대면 어느 열쇠였는지 잃는다.
+    /*
+     * ── 첫 열쇠 하나만 지우고 있었다 ────────────────────────────────────
+     *
+     * 여기가 `잠금지우기(것.열쇠[0])` 였다. 프로필마다 키체인 자리를 따로 쓰니
+     * (safety/keystore.js 의 키체인이름) 잠긴 열쇠는 여럿일 수 있는데, 두 번째부터는
+     * 키체인에 그대로 남고 화면은 「잠금장치의 열쇠 ✓」 한 줄이었다.
+     * 전부 지우고 하나하나 무엇을 했는지 돌려준다. 같은 태그는 한 번만 — 두 번째는
+     * 「이미 없습니다」 로 돌아와 못 지운 것처럼 읽힌다.
+     * `열쇠` 는 모아 본 답이다. 하나라도 못 지웠으면 지웠다고 안 한다.
+     */
     if (것.키 === 'model' && 것.열쇠?.length) {
-      열쇠 = 잠금지우기(것.열쇠[0]);
+      열쇠들 = [...new Set(것.열쇠)].map((태그) => {
+        const 갈래 = /^keychain:(.*)$/s.exec(String(태그));
+        return { 이름: 갈래 ? 갈래[1] : null, ...잠금지우기(태그) };
+      });
+      const 못한 = 열쇠들.find((x) => !x.지움);
+      열쇠 = { 지움: !못한, 방식: (못한 ?? 열쇠들[0]).방식, 왜: 못한?.왜 ?? '' };
     }
     // 한 갈래가 여러 자리에 걸쳐 있다 (배운 것은 이 PC 와 이 폴더 둘 다).
     // 화면에는 **갈래 하나로** 적는다 — 자리마다 한 줄씩 내면 「배운 것 2곳」
@@ -271,9 +371,16 @@ export function 지우기(무엇, { home = homeDir(), root = process.cwd(), hard
         못한것.push({ 이름: 것.이름, 자리, 왜: '작업 폴더 밖이라 안 건드렸습니다' });
         continue;
       }
+      const 다듬 = (것.다듬기 ?? []).find((x) => x.자리 === 자리);
       try {
-        rmSync(자리, { recursive: true, force: true });
-        지운자리.push(자리);
+        if (다듬) {
+          writeFileSync(자리, JSON.stringify(다듬.남길값, null, 2) + '\n', 'utf8');
+          try { chmodSync(자리, 0o600); } catch { /* 안 먹는 파일 체계가 있다 — 원래 모드 그대로다 */ }
+          지운자리.push(`${자리}  (연결 칸만 — ${다듬.남긴칸.join(' · ')} 은 남겼습니다)`);
+        } else {
+          rmSync(자리, { recursive: true, force: true });
+          지운자리.push(자리);
+        }
       } catch (err) {
         못한것.push({ 이름: 것.이름, 자리, 왜: String(err.message).slice(0, 80) });
       }
@@ -282,7 +389,7 @@ export function 지우기(무엇, { home = homeDir(), root = process.cwd(), hard
       지운것.push({ 키: 것.키, 이름: 것.이름, 몇: 것.몇, 단위: 것.단위, 자리들: 지운자리 });
     }
   }
-  return { 지운것, 못한것, 열쇠 };
+  return { 지운것, 못한것, 열쇠, 열쇠들 };
 }
 
 // ── 화면 ────────────────────────────────────────────────────────────────
@@ -322,7 +429,15 @@ function 보여주기(본것) {
 function 지운뒤적기(결과) {
   say('');
   // 「완료」 한 줄은 확인이 안 된다. 무엇이 몇 개 없어졌는지 적는다.
-  if (!결과.지운것.length) {
+  /*
+   * **못 지운 것이 있으면 「비어 있다」 고 하지 않는다.**
+   *
+   * 지운 것이 0 이라는 것만 보고 있어서, 있는데 못 지운 판에서도 이 줄이 그대로
+   * 나갔다 — 화면에는 「⚠ 이미 비어 있습니다」 와 「✗ … 안 건드렸습니다」 가 나란히
+   * 붙었다. 앞줄을 믿은 사람은 지워진 줄 알고 그 PC 를 넘기고, 지우려던 것은 그대로
+   * 남는다. 「없어서 안 지웠다」 와 「있는데 못 지웠다」 는 사람이 할 일이 정반대다.
+   */
+  if (!결과.지운것.length && !결과.못한것.length) {
     say(`  ${mark.warn} ${c.gray('지울 것이 없었습니다 — 이미 비어 있습니다.')}`);
   }
   for (const x of 결과.지운것) {
@@ -330,10 +445,15 @@ function 지운뒤적기(결과) {
     say(`  ${mark.ok} ${c.bold(x.이름)}${셈}`);
     for (const 자리 of x.자리들) say(`     ${c.gray(자리)}`);
   }
-  if (결과.열쇠) {
-    say(결과.열쇠.지움
-      ? `  ${mark.ok} ${c.bold('잠금장치의 열쇠')}  ${c.gray(결과.열쇠.방식)}`
-      : `  ${mark.warn} ${c.gray(`잠금장치 — ${결과.열쇠.왜}`)}`);
+  // 열쇠마다 한 줄. 모아서 한 줄로 적으면 둘 중 하나만 지운 것이 「✓」 뒤에 숨는다.
+  // 같은 말(DPAPI 는 전부 「설정 파일 안에」)은 한 번만 적는다.
+  const 적은줄 = new Set();
+  for (const k of 결과.열쇠들 ?? (결과.열쇠 ? [결과.열쇠] : [])) {
+    const 이름 = k.이름 ? ` ${k.이름}` : '';
+    const 줄 = k.지움
+      ? `  ${mark.ok} ${c.bold('잠금장치의 열쇠')}  ${c.gray(`${k.방식}${이름}`)}`
+      : `  ${mark.warn} ${c.gray(`잠금장치${이름} — ${k.왜}`)}`;
+    if (!적은줄.has(줄)) { 적은줄.add(줄); say(줄); }
   }
   for (const x of 결과.못한것) {
     say(`  ${mark.no} ${x.이름} ${c.gray(x.자리)}`);
@@ -364,6 +484,12 @@ export async function runReset(args = [], flags = {}) {
   }
 
   const 본것 = 살펴보기({ home, root });
+  /*
+   * 모아 둔 소식을 비운다 (config.js 의 소식줄들). 이 문은 설정을 안 읽으므로
+   * 대개 관리 정책이 깨졌다는 말 하나다 — 초기화를 찾는 사람이 「왜 설정이
+   * 안 먹나」 를 쫓고 있다면 제일 먼저 봐야 할 줄이다.
+   */
+  for (const 줄 of 소식줄들()) say(줄);
   보여주기(본것);
 
   if (!무엇) {

package/src/safety/audit.js

@@ -1,9 +1,36 @@
 // 감사 로그. 무엇을 언제 어떻게 했는지 전부 남긴다.
 // 자율 실행을 사내에 설득할 때 이 파일이 근거가 된다.
 import { join } from 'node:path';
-import { appendFileSync, mkdirSync, existsSync, readFileSync, chmodSync } from 'node:fs';
+import { appendFileSync, mkdirSync, existsSync, readFileSync, chmodSync, statSync, openSync, readSync, closeSync } from 'node:fs';
 import { 가리기 } from './secrets.js';
 import { 첫이름 } from '../tools/label.js';
+
+/*
+ * 살림 폴더(.deel · .deel/history)를 만든다. 못 만들면 **사람 말로** 던진다 (6회차 C3).
+ *
+ * 앞서는 mkdirSync 의 원시 오류가 그대로 올라가, 대화 화면·deel -p·에디터 셋 다
+ * 「EEXIST: file already exists, mkdir '…\.deel'」 한 줄만 보였다. 안 죽기는 했지만
+ * 무엇이 막혔고 어떻게 하면 되는지가 없었다. 작업 폴더에 같은 이름의 파일이 있거나
+ * 읽기 전용 자리면 여기서 막힌다.
+ *
+ * 던지는 것은 그대로 둔다 — 감사기록·되돌리기 이력 없이 조용히 켜지면 안 된다.
+ * 되돌리기 이력(undo.js)도 같은 말을 쓰게 여기서 내준다.
+ */
+export function 살림폴더만들기(dir, 덧 = {}) {
+  try {
+    mkdirSync(dir, { recursive: true, ...덧 });
+  } catch (err) {
+    const 까닭 = {
+      EEXIST: '같은 이름의 파일이 있습니다', ENOTDIR: '같은 이름의 파일이 있습니다',
+      EACCES: '쓸 권한이 없습니다', EPERM: '쓸 권한이 없습니다', EROFS: '읽기 전용 자리입니다',
+    }[err?.code] ?? String(err?.message ?? err);
+    const e = new Error(`작업 폴더에 deel 살림 폴더를 만들지 못했습니다 (${dir}) — ${까닭}.`
+      + ' 같은 이름의 파일이면 옮기거나 지우고, 쓸 수 없는 폴더면 쓸 수 있는 곳에서 켜세요.');
+    e.code = err?.code;
+    e.cause = err;
+    throw e;
+  }
+}
 import { 환경속열쇠들 } from '../config.js';
 
 /**
@@ -36,9 +63,19 @@ export class Audit {
    */
   constructor(root, { 열쇠들 = [] } = {}) {
     const dir = join(root, '.deel');
-    mkdirSync(dir, { recursive: true });
+    살림폴더만들기(dir);
     this.file = join(dir, 'audit.jsonl');
-    this.session = `${new Date().toISOString().slice(0, 19).replace(/[:T]/g, '')}`;
+    /*
+     * 세션 이름은 시각으로 시작하되 그것만으로 끝내지 않는다.
+     *
+     * 초 단위 시각 하나였더니 같은 초에 띄운 창 두 개(또는 한 판 안의 하위 작업)가
+     * 같은 이름을 나눠 가졌다. `deel stats` 는 세션을 이름으로 세고 증거모으기는
+     * 이 이름으로 「이번 세션」 을 가르므로, 남의 기록이 내 것으로 섞였다.
+     * agent/store.js 의 freeId 처럼 밀리초·프로세스 번호·난수를 덧붙인다.
+     */
+    const 지금 = new Date();
+    this.session = `${지금.toISOString().slice(0, 19).replace(/[:T]/g, '')}`
+      + `-${String(지금.getMilliseconds()).padStart(3, '0')}-${process.pid}-${Math.random().toString(36).slice(2, 6)}`;
     /** 적으려다 못 적은 건수와 첫 까닭. 0 이 아니면 이 세션의 기록은 불완전하다. */
     this.못쓴수 = 0;
     this.못쓴까닭 = null;
@@ -78,12 +115,47 @@ export class Audit {
    * 아니라 아예 **안 고친 것처럼** 보고서가 짧아진다.
    * 그래서 못 적은 건수를 세어 두고, 보고서와 화면이 그걸 말하게 한다.
    */
+  /*
+   * ── 반쪽 줄 뒤에 이어 적지 않는다 ─────────────────────────────────────────
+   *
+   * 적는 도중에 죽으면 마지막 줄이 개행 없이 반만 남는다. 다음 판이 그 뒤에 그대로
+   * 이어 적으면 새 기록이 반쪽에 **붙어** 한 줄이 되고, 그 줄은 JSON 이 아니라
+   * recent()·deel stats·증거모으기가 통째로 버린다 — 다음 판이 한 첫 일이, 그것도
+   * 막힌 명령이나 되돌리기 같은 것이 기록에서 사라진다.
+   * agent/store.js 와 같은 방법이다. 이 기록으로 처음 적을 때 한 번만 파일 끝을 보고,
+   * 개행이 아니면 개행부터 붙인다. 줄마다 재지 않는다 — 그 뒤로는 우리가 적은 줄이다.
+   */
+  #줄끝봤나 = 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 {
-      appendFileSync(this.file, JSON.stringify(rec) + '\n', 'utf8');
+      let 줄 = JSON.stringify(rec) + '\n';
+      if (!this.#줄끝봤나) {
+        if (!this.#줄로끝나나()) 줄 = '\n' + 줄;
+        this.#줄끝봤나 = true;
+      }
+      appendFileSync(this.file, 줄, 'utf8');
       this.#잠그기();
     } catch (err) {
+      /*
+       * 막혔으면 끝을 다시 보게 되돌린다 (2.0.0 6회차 · Gemini 감사6aa C2 — agent/store.js 저장6w X1 과
+       * 같은 까닭). 본 표시를 적기 전에 세워서, 첫 적기가 막히면 다음 기록이 반쪽 줄 뒤에 붙었다 —
+       * 못쓴수 에는 막힌 한 건만 오르고, 붙은 기록은 적었다고 친 채 deel audit · 증거모으기에서 사라진다.
+       */
+      this.#줄끝봤나 = false;   // 막혔으니 다음 적기에서 끝을 다시 본다
       this.못쓴수 += 1;
       if (!this.못쓴까닭) this.못쓴까닭 = err?.message ?? String(err);
     }
@@ -108,6 +180,9 @@ 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) }; }
   }
@@ -129,19 +204,44 @@ export class Audit {
       // 이 빠져 있어서, 웹을 읽은 줄과 스킬을 부른 줄이 감사기록에서만
       // 무엇을 향한 것인지 없이 남았다.
       target: this.#가린것(첫이름(args) ?? args?.command ?? null),
-      ok: !result?.error,
+      // 실패는 error 로만 오지 않는다. Bash 는 종료 코드가 0 이 아니면 `failed: true`(tools/index.js),
+      // Verify 는 탈이 나면 `failed: true` 를 싣고 error 는 비운다. error 만 보면 빨간 검사가
+      // ok 로 남고, 증거(agent/evidence.js)가 그걸 「확인한 것」 으로 내민다 (6회차 근거6at EV4).
+      ok: !result?.error && result?.failed !== true,
       note: this.#가린것(result?.error ?? result?.summary ?? null),
     });
   }
 
-  turn(text) { return this.write('turn', { text: this.#가린것(String(text).slice(0, 500)) }); }
-  blocked(why, what) { return this.write('blocked', { why, what: this.#가린것(String(what).slice(0, 300)) }); }
+  /*
+   * ── 가린 뒤에 자른다 ────────────────────────────────────────────────
+   *
+   * 자르기가 먼저였다. 열쇠가 500자(300자) 선에 걸치면 앞 조각만 남는데, 조각은
+   * 정확히 아는 열쇠라도 **통째가 아니라서** 못 알아본다 — 게이트웨이 열쇠 앞
+   * 스무 글자가 그대로 적혔다. 가리기가 글을 짧게 만들 뿐 길게 만들지는 않으니
+   * 자르는 선은 그대로 지켜진다.
+   *
+   * 막힌 까닭(why)도 가린다. guard.js 가 던지는 말은 막은 명령 앞 120자를 그대로
+   * 담아서, what 은 가렸는데 why 칸에 `Authorization: Bearer …` 가 평문으로 남았다.
+   */
+  turn(text) { return this.write('turn', { text: this.#가린것(String(text)).slice(0, 500) }); }
+  blocked(why, what) {
+    return this.write('blocked', { why: this.#가린것(why), what: this.#가린것(String(what)).slice(0, 300) });
+  }
   undo(info) { return this.write('undo', info); }
 
+  /*
+   * 최근 n 줄. 0 이하는 「내줄 줄이 없다」 는 말이다.
+   *
+   * `slice(-0)` 은 `slice(0)` 이라 **전부** 나왔다. 0 을 넘기는 호출부는 지금 없지만,
+   * 여기서 나온 줄은 `deel audit` 화면·증거모으기·`deel stats` 로 곧장 간다 —
+   * 「최근 0줄만」 이 기록 전체를 읽어 오는 것은 부르는 쪽이 못 알아챈다.
+   */
   recent(n = 20) {
+    const 몇 = Math.floor(Number(n));
+    if (!Number.isFinite(몇) || 몇 <= 0) return [];
     if (!existsSync(this.file)) return [];
     return readFileSync(this.file, 'utf8')
-      .split('\n').filter(Boolean).slice(-n)
+      .split('\n').filter(Boolean).slice(-몇)
       .map((l) => { try { return JSON.parse(l); } catch { return null; } })
       .filter(Boolean);
   }

package/src/safety/authcmd.js

@@ -151,6 +151,9 @@ export function 쓸수있나(설정, { auth = 'bearer', 봉인 = isOffline() } =
  */
 const 토큰글자 = /^[A-Za-z0-9._~+/=-]{16,8192}$/;
 
+/** 명령이 뱉은 것을 이만큼까지만 받는다. 넘으면 토큰이 아니다 (한번받기 의 data 머리말). */
+const 받을상한 = 1024 * 1024;
+
 /**
  * 명령이 뱉은 것을 읽는다.
  *
@@ -165,14 +168,34 @@ export function 읽기(글, { 수명 = 기본수명, 지금 = Date.now() } = {})
   const s = String(글 ?? '').trim();
   if (!s) return { ok: false, 왜: '아무것도 안 나왔습니다', 보인것: '' };
 
-  const 첫줄 = s.split('\n')[0].trim().slice(0, 120);
+  /*
+   * 보여 주는 첫 줄도 **가린다.**
+   *
+   * 여기만 날것이었다. 같은 파일의 stderr 자리(한번받기)는 처음부터 가리기 를
+   * 거치는데, 나온 것을 못 읽었을 때 보여 주는 이 값만 안 거쳤다. 그런데 못
+   * 읽는 까닭 1등이 「배너와 토큰이 같이 나왔다」 라서, 거절하는 그 줄에 토큰이
+   * 들어 있는 것이 예외가 아니라 보통이다. 이 값은 repl · oneshot · acp 가
+   * 그대로 찍는다 — 화면 사진·로그·심사서에 통째로 남는다.
+   *
+   * 자르고 나서 가린다. 1MB 짜리 한 줄을 통째로 가리기 에 넣으면 그 무늬들이
+   * 몇 분을 돈다 (아래 한번받기 의 받을상한 자리에 같은 까닭이 적혀 있다).
+   */
+  const 첫줄 = 가리기(s.slice(0, 400).split('\n')[0].trim(), {}).글.slice(0, 120);
 
   if (s.startsWith('{')) {
     let 것;
     try { 것 = JSON.parse(s); } catch (err) {
       return { ok: false, 왜: `JSON 처럼 시작하는데 못 읽었습니다 (${err.message})`, 보인것: 첫줄 };
     }
-    const token = String(것?.token ?? 것?.access_token ?? '').trim();
+    /*
+     * `accessToken` 도 본다.
+     *
+     * 이 파일 머리말이 권하는 명령은 `--query accessToken -o tsv` 라 한 줄이
+     * 나온다. 그런데 그 뒤를 빠뜨리는 것이 제일 흔한 실수이고, 그때 az 가 뱉는
+     * 기본 JSON 의 칸 이름이 정확히 이것이다. 이름 하나를 안 봐서 「token 이
+     * 없습니다」 로 거절했고, 거절하는 김에 토큰이 든 줄을 화면에 꺼내 놓았다.
+     */
+    const token = String(것?.token ?? 것?.access_token ?? 것?.accessToken ?? '').trim();
     if (!token) return { ok: false, 왜: 'JSON 은 읽었는데 token 이 없습니다', 보인것: 첫줄 };
     if (!토큰글자.test(token)) return { ok: false, 왜: 'token 에 토큰이 아닌 글자가 들었습니다', 보인것: 첫줄 };
     /*
@@ -242,8 +265,35 @@ export async function 한번받기(설정, { 기다림 = 기본기다림, signal
     if (signal?.aborted) return 끊기();
     signal?.addEventListener?.('abort', 끊기, { once: true });
 
-    kid.stdout.on('data', (b) => { 나온것 += b; });
-    kid.stderr.on('data', (b) => { 탈난것 += b; });
+    /*
+     * ── 받는 양에 뚜껑을 씌운다 (사냥5 M7) ────────────────────────────────
+     *
+     * 여기는 `나온것 += b` 뿐이었다. 망가진 로그인 도구가 배너·로그를 끝없이 뱉거나
+     * 700MB 를 쏟으면 문자열 상한에 걸려 **이 data 처리기 안에서** RangeError 가 났다.
+     * 그건 잡을 자리가 없는 던짐이라 deel 이 대화째 죽었다.
+     *
+     * 토큰은 많아야 몇 KB 다(토큰글자 는 8192자까지, JSON 머리말을 붙여도). 1MB 를
+     * 넘으면 토큰이 아니라고 보고 **그 자리에서** 죽이고 까닭을 말한다. 우리 쪽 파이프도
+     * 놓는다 — 셸 아래 손자가 계속 쓰고 있으면 그놈이 EPIPE 를 맞고 멈추게.
+     * stderr 는 첫 줄만 쓰므로 앞부분만 모은다.
+     */
+    kid.stdout.on('data', (b) => {
+      if (끝났나) return;
+      if (나온것.length + b.length > 받을상한) {
+        try { kid.kill('SIGKILL'); } catch { /* 이미 죽었으면 그만 */ }
+        try { kid.stdout.destroy(); kid.stderr.destroy(); } catch { /* 이미 닫힘 */ }
+        // 먼저 자르고 가린다 — 1MB 짜리 한 줄을 통째로 가리기 에 넣으면 그 무늬들이
+        // 몇 분을 돈다(처음 고칠 때 검사가 여기서 멈춰 섰다).
+        const 첫줄 = 가리기(나온것.slice(0, 400).trim().split('\n')[0] ?? '', {}).글.slice(0, 120);
+        return 마치기({
+          ok: false,
+          왜: `명령이 ${받을상한 / (1024 * 1024)}MB 넘게 뱉어서 끊었습니다 — 너무 많이 나옵니다. 토큰 한 줄만 나오게 해 주세요`,
+          보인것: 첫줄,
+        });
+      }
+      나온것 += b;
+    });
+    kid.stderr.on('data', (b) => { if (탈난것.length < 65536) 탈난것 += b; });
     kid.on('error', (err) => 마치기({ ok: false, 왜: `명령을 못 띄웠습니다 (${err.message})`, 보인것: '' }));
     kid.on('close', (code) => {
       if (code !== 0) {
@@ -287,10 +337,30 @@ export async function 열쇠(설정, { 다시 = false, 물어보기 = null, sign
    *
    * 한 판에 한 번만 묻는다. 토큰이 한 시간짜리면 세 시간 일하는 동안 세 번
    * 받아 오는데, 세 번 다 물으면 사람은 그냥 손이 가는 대로 누른다.
+   *
+   * ── 물을 자리가 없으면 **안 띄운다** (2.0.0 8회차) ──────────────────────
+   *
+   * 여기가 `설정.곳 !== '정책' && 물어보기` 였다. 갈고리가 안 넘어오면 승인
+   * 블록을 통째로 건너뛰고 그냥 띄웠다. 그 자리가 실제로 열린다 — 세 문
+   * (repl · oneshot · acp)이 다 **켤 때** `if (conn.열쇠받기)` 로만 갈고리를
+   * 달아서, 열쇠받기 없는 프로필로 켠 뒤 `/model` 로 갈아타면
+   * `session.열쇠물어보기` 가 영영 안 붙는다. 그 뒤로는 남이 적어 준 로그인
+   * 명령이 승인 한 번 없이 돈다. 잰 것: `ok=true · 물음 없이 명령이 돌았나: true`.
+   *
+   * 물을 자리가 없는 것은 「안 물어도 된다」 가 아니라 「승인을 못 받았다」 다.
+   * 안 띄우고 까닭을 말한다 — adapter.js 는 이걸 듣고 던지지 않고 원래 열쇠로
+   * 가므로, 이 자물쇠가 멀쩡하던 연결을 끊지는 않는다.
+   *
+   * 이미 이 판에서 승인을 받아 뒀으면 그 승인이 그대로 산다. 갈고리를 안
+   * 넘기는 뒷일(요약·되돌아보기)이 같은 판에서 열쇠를 다시 받는 자리가 있고,
+   * 거기서까지 막으면 사람이 승인을 했는데도 열쇠가 안 붙는다.
    */
-  if (설정.곳 !== '정책' && 물어보기) {
+  if (설정.곳 !== '정책') {
     if (물어본것 === false) return { ok: false, 왜: '이 판에서는 안 부르기로 했습니다' };
     if (물어본것 === null) {
+      if (typeof 물어보기 !== 'function') {
+        return { ok: false, 왜: '이 명령을 띄워도 되는지 물어볼 자리가 없습니다 — 승인 없이는 안 띄웁니다' };
+      }
       물어본것 = !!(await 물어보기(설정));
       if (!물어본것) return { ok: false, 왜: '이 판에서는 안 부르기로 했습니다' };
     }