deel-local-cli 2.0.1 → 2.1.0

package/src/agent/donecheck.js

@@ -0,0 +1,97 @@
+// 완료 검사 — 「다 됐습니다」 를 모델의 말이 아니라 **검사 결과**로 가른다 (2.1.0).
+//
+// ── 왜 만드나 ───────────────────────────────────────────────────────────
+//
+// 사내 검토에서 나온 말이 둘이었다. 「검증을 정적 검사에 기대면 한계가 있다」 와
+// 「루프를 더 다듬어야 한다」. 재 보니 맞았다. 턴이 끝나는 자리는 **모델이 도구를
+// 안 부르고 말만 한 걸음** 하나였다. 모델이 「고쳤습니다」 라고 하면 그걸로 끝이었다.
+//
+// 확인할 길은 있었다. Verify 는 문법·짝을 읽어서 보고(tools/verify.js), checkmethods 는
+// 이 프로젝트의 검사 명령을 찾아 알려 주고(tools/checkmethods.js), 증거는 「고친 뒤에
+// 돌려서 통과한 검사가 있나」 를 사람에게 보여 준다(agent/evidence.js). 셋 다 **권하거나
+// 보여 주기만** 한다. 돌릴지는 모델이 정했고, 안 돌리고 끝내도 막는 자리가 없었다.
+//
+// 그래서 사람이 검사 명령 하나를 정해 두면(`"check": "npm test"`), 모델이 끝내려는
+// 자리에서 **deel 이 직접** 그 명령을 돌린다.
+//
+//   통과      그대로 끝낸다. 끝맺음에 「완료 검사 통과」 가 붙는다
+//   실패      실패 출력을 모델에게 돌려주고 이어서 고치게 한다 — 정해 둔 판수까지
+//   다 써도 실패   끝내되 **실패로** 끝낸다. `deel run` 은 종료코드 8 을 낸다
+//
+// ── 안 하는 것 ──────────────────────────────────────────────────────────
+//
+// 명령을 **지어내지 않는다.** 정해 둔 것이 없으면 이 고리는 아예 안 돈다. 있을 법한
+// 검사(npm test)를 짐작해 돌리면, 그 프로젝트에서 그게 20분짜리이거나 DB 를 비우는
+// 스크립트일 때 사람이 모르는 채로 돈다.
+//
+// 따로 도는 길도 **안 만든다.** 이 명령은 모델이 부른 Bash 와 똑같은 관문을 지난다 —
+// 적어 둔 금지 규칙, 사람이 건 훅, 승인 모드(strict 면 묻는다), 위험 명령 막이, 열쇠 뺀
+// 환경. 설정에 적힌 명령이라고 관문을 건너뛰면 저장소 설정 한 줄이 strict 를 뚫는다.
+//
+// 아무것도 안 바꾼 턴에는 안 돈다. 물어본 것에 답만 한 턴에 테스트가 도는 것은 소음이다.
+// 고친 뒤 실패를 받고 **다시 아무것도 안 바꾼 채** 끝내려 하면 다시 돌리지 않는다 —
+// 같은 결과가 나올 것을 또 기다리게 하지 않고, 실패로 끝낸다.
+
+/** 한 턴에 몇 번까지 「고치고 → 다시 검사」 를 돌까. 기본과 상한. */
+export const 기본판수 = 3;
+export const 최대판수 = 10;
+/** 검사 한 번의 제한 시간(ms). Bash 도구의 상한(10분)과 같다 — 넘겨 봐야 거기서 잘린다. */
+export const 기본시간 = 600_000;
+const 최소시간 = 1_000;
+
+/**
+ * 설정과 실행 깃발에서 완료 검사를 읽는다. 정해 둔 명령이 없으면 null — 고리를 안 돈다.
+ *
+ * @param {object} cfg        설정 (`check` · `checkRounds` · `checkTimeout`)
+ * @param {string} [덮을명령]   `deel run --check` 로 준 명령. 설정보다 이긴다
+ * @returns {{명령:string, 판수:number, 시간:number} | null}
+ */
+export function 검사설정(cfg = {}, 덮을명령 = undefined) {
+  const 날것 = 덮을명령 !== undefined && 덮을명령 !== null ? 덮을명령 : cfg?.check;
+  if (typeof 날것 !== 'string') return null;
+  const 명령 = 날것.trim();
+  if (!명령) return null;
+  /*
+   * 판수는 1 ~ 10 에서만 받는다. 0 이나 음수를 「끈다」 로 읽으면 명령을 적어 둔 사람이
+   * 왜 안 도는지 모른다. 끄려면 check 를 지운다. 숫자가 아니면 기본값이다.
+   */
+  const n = Number(cfg?.checkRounds);
+  const 판수 = Number.isInteger(n) && n >= 1 ? Math.min(n, 최대판수) : 기본판수;
+  const 초 = Number(cfg?.checkTimeout);
+  const 시간 = Number.isFinite(초) && 초 > 0 ? Math.min(기본시간, Math.max(최소시간, Math.round(초 * 1000))) : 기본시간;
+  return { 명령, 판수, 시간 };
+}
+
+/**
+ * 긴 출력에서 **뒤를** 남긴다. 테스트가 무엇이 틀렸는지 말하는 자리는 대개 끝이다 —
+ * 앞을 남기면 모델은 「테스트 시작」 줄만 받고 무엇이 틀렸는지 모른다.
+ */
+export function 출력꼬리(글, 한도 = 6000) {
+  const s = String(글 ?? '');
+  if (s.length <= 한도) return s;
+  return `…(앞 ${s.length - 한도}자 줄임)\n${s.slice(s.length - 한도)}`;
+}
+
+/**
+ * 도구 결과 하나를 통과·실패로 가른다. 종료코드 0 으로 끝난 것만 통과다 —
+ * 시그널로 죽은 것·시간 초과·못 돌린 것은 다 실패다 (tools/index.js 의 Bash 결과 머리말).
+ */
+export function 통과했나(result) {
+  return !!result && !result.error && result.failed !== true;
+}
+
+/** 실패한 검사를 모델에게 돌려줄 말. 무엇을 돌렸고, 몇 번째이고, 무엇이 나왔는지. */
+export function 실패말({ 명령, 출력, 판, 최대 }, { 영어 = false } = {}) {
+  const 남은 = Math.max(0, 최대 - 판);
+  const 꼬리 = 출력꼬리(출력);
+  if (영어) {
+    return `The completion check \`${명령}\` failed (${판}/${최대}). You said the work was done, but the check does not pass.\n\n`
+      + `${꼬리}\n\n`
+      + 'Read the failure, fix the cause in the code, and finish again. Do not edit or delete the check itself to make it pass.'
+      + (남은 ? ` The check runs again when you finish (${남은} more ${남은 === 1 ? 'try' : 'tries'}).` : '');
+  }
+  return `완료 검사 \`${명령}\` 가 실패했습니다 (${판}/${최대}). 다 됐다고 했는데 검사가 통과하지 않습니다.\n\n`
+    + `${꼬리}\n\n`
+    + '실패 내용을 읽고 코드에서 원인을 고친 뒤 다시 끝내세요. 검사를 통과시키려고 검사 자체를 고치거나 지우지 마세요.'
+    + (남은 ? ` 끝내면 검사가 다시 돕니다 (${남은}번 남음).` : '');
+}

package/src/agent/grade.js

@@ -42,7 +42,7 @@ import { 언어 } from '../i18n/index.js';
  */
 
 /** 급 이름. 숫자가 아니라 이름으로 쓰는 이유는 화면에 그대로 나가기 때문이다. */
-export const 급들 = ['작음', '보통', '큼'];
+const 급들 = ['작음', '보통', '큼'];
 
 /**
  * 이름에서 파라미터 수를 읽어 본다.

package/src/agent/loop.js

@@ -2,10 +2,10 @@
 // 화면에 그릴 것은 이벤트로 흘려보낸다 — 화면 코드와 섞지 않는다.
 import { chat, chatStream, assistantMessage, toolMessage, 말없이끝남, 흐름멎음, 보낸토큰, 부른것들, 도구결과인가 } from '../backend/adapter.js';
 import { 그림메시지 } from '../backend/vision.js';
-import { 어떻게할까 } from '../safety/policy.js';
+import { 어떻게할까, 승인바닥 } from '../safety/policy.js';
 import { 자리돌리기, 막힘말 } from '../safety/hooks.js';
-import { toolSchemas, runTool, TOOLS, 파일현황 } from '../tools/index.js';
-import { isMutating } from '../safety/guard.js';
+import { toolSchemas, runTool, TOOLS, 파일현황, 바뀔내용 } from '../tools/index.js';
+import { isMutating, 셸이파일에쓰나 } from '../safety/guard.js';
 import { effortFor, tokensFor, fullCap, wasCut, shiftLevel, 자동강도, 천장고르기, 인사인가 as 인사말인가 } from './effort.js';
 import { 배울전선, 카드고치기, 카드저장꼴, 전선붙이기 } from '../backend/wire.js';
 import { 살린쓰기 } from './salvage.js';
@@ -19,13 +19,14 @@ import { 프로필찾기, 쓸수있나, 연결만들기, 알릴말, 목록보기
 import { allowTemporarily, isOffline } from '../safety/network.js';
 import { 가리기, 훑기, 가렸다는말, 봤다는말, 가릴까 } from '../safety/secrets.js';
 import { 바깥인가 } from '../safety/runmode.js';
-import { get as workMode } from './modes.js';
+import { get as workMode, 바꾸는도구 } from './modes.js';
 // 종합 모드에서 단계가 일을 따라간다 (agent/phase.js).
 import { 다음단계 } from './phase.js';
 import { 묻지말라했나, 손대라했나 } from './route.js';
 import { 지시말 } from '../i18n/index.js';
 import { 빠진것, 빠졌다는말 } from './asks.js';
 import { 환경속열쇠들 } from '../config.js';
+import { 통과했나, 실패말 as 검사실패말, 출력꼬리 } from './donecheck.js';
 
 /*
  * 콜백으로만 소식을 주는 부름을, 제너레이터가 중간에 내보낼 수 있는 모양으로 바꾼다.
@@ -148,6 +149,13 @@ function thinkFor(conn, level) {
  */
 const 읽기전용 = new Set(['Read', 'Outline', 'Glob', 'Grep', 'Def', 'Refs', 'Recall', 'Skill', 'WebFetch']);
 
+/*
+ * 스크립트 **파일**을 돌리는 꼴 — `python fix.py` · `node update.mjs` · `sh gen.sh`.
+ * 완료 검사가 「이번 턴에 무엇을 바꿨나」 를 셀 때만 쓴다. 스크립트 안에서 무엇을 쓰는지는
+ * 명령줄로 모르니 **바꿨을 수 있다**로 친다. 잘못 걸리면 검사가 한 번 더 돌 뿐이다.
+ */
+const 스크립트돌림 = /\b(?:node|python[\d.]*|py|ruby|perl|php|deno|bun|bash|sh|pwsh|powershell)(?:\.exe)?\s+(?:-\S+\s+)*[^\s|;&]+\.(?:[cm]?js|ts|py|rb|pl|php|sh|ps1)\b/i;
+
 /*
  * 잘린 답을 「생각을 줄여」 다시 부를 때 쓰는 두 값.
  *
@@ -160,8 +168,8 @@ const 읽기전용 = new Set(['Read', 'Outline', 'Glob', 'Grep', 'Def', 'Refs',
  * 2,400토큰이고 2k 상한에서는 300토큰이다. 같은 잣대인 척하면서 실제로는
  * 상한이 클수록 헐거워진다.
  */
-export const 되찾을몫 = 0.4;
-export const 쓸모있는자리 = 1024;
+const 되찾을몫 = 0.4;
+const 쓸모있는자리 = 1024;
 
 /**
  * 호출 목록을 '같이 돌려도 되는 덩어리' 로 자른다.
@@ -337,6 +345,99 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0,
    */
   const 손댄파일 = new Set();
   const 마무리 = () => [...손댄파일].map(파일현황);
+  /*
+   * 완료 검사 (agent/donecheck.js). 사람이 검사 명령을 정해 뒀으면 모델이 끝내려는 자리에서
+   * 그걸 돌린다. 하위 작업은 안 돈다 — 한 번 시킨 일에 검사가 하위 수만큼 돈다.
+   *
+   * 「고친 뒤에 다시 돌릴까」 는 바뀐 **횟수**로 가른다. 손댄파일 은 이름 모음이라 같은
+   * 파일을 다시 고치면 안 늘어난다 — 실패를 받고 같은 파일을 고친 판이 「안 바꿨다」 로
+   * 읽혀 검사가 다시 안 돈다.
+   */
+  const 완료검사 = 깊이 ? null : (ctx.완료검사 ?? null);
+  let 바뀜수 = 0;
+  let 검사때바뀜수 = 0;
+  let 검사판 = 0;
+  let 검사상태 = null;
+
+  /**
+   * 완료 검사를 한 번 돌린다. 모델이 부른 Bash 와 **같은 관문**을 지난다 — 적어 둔 규칙,
+   * 사람이 건 훅, 승인 모드, 그리고 Bash 도구 안의 위험 명령 막이·열쇠 뺀 환경.
+   * 설정에 적힌 명령이라고 건너뛰면 저장소 설정 한 줄이 strict 를 뚫는다.
+   *
+   * @returns {{ok: boolean|null, 명령, 판, 최대, 요약?, 까닭?, 출력?}}  ok 가 null 이면 못 돌렸다
+   */
+  async function* 완료검사돌리기(판) {
+    const 명령 = 완료검사.명령;
+    const 최대 = 완료검사.판수;
+    const args = { command: 명령, description: '완료 검사', timeout: 완료검사.시간 };
+    yield { type: 'check_start', 명령, 판, 최대 };
+    const 못돌림 = (까닭) => ({ ok: null, 명령, 판, 최대, 까닭 });
+
+    let 결판 = null;
+    const 판정 = 어떻게할까(ctx.규칙들, 'Bash', args, { 뿌리: ctx.scope?.root ?? null });
+    if (판정.답 === 'deny') {
+      ctx.audit?.blocked?.('규칙으로 금지됨', `${판정.출처}: ${판정.규칙}`);
+      결판 = 못돌림(`${판정.출처}에 적힌 규칙 ${판정.규칙} 으로 막혀 있습니다`);
+    }
+    if (!결판 && ctx.훅들?.length) {
+      const 훅 = await 자리돌리기(ctx.훅들, '도구전', {
+        도구: 'Bash', 넣을것: { 인자: args }, signal, audit: ctx.audit,
+      });
+      if (훅.막힘) {
+        ctx.audit?.blocked?.('도구전 훅이 막음', `Bash · ${훅.막힘.훅.명령}`);
+        결판 = 못돌림(막힘말(훅.막힘));
+      }
+    }
+    if (!결판) {
+      // 아래 도구 관문의 needsOk 와 같은 잣대다. 검사 명령은 대개 안 바꾸는 명령이라 confirm 은 안 묻는다.
+      const 정책이묻게함 = 승인바닥().바닥 !== 'auto';
+      const 물어야 = (판정.답 === 'allow' && !정책이묻게함) ? false
+        : session.mode === 'strict' ? true
+          : session.mode === 'confirm' ? isMutating(명령) : false;
+      if (물어야) {
+        const ok = ctx.confirm ? await ctx.confirm('Bash', args, { 미리보기: [] }) : false;
+        if (!ok) 결판 = 못돌림(ctx.confirm ? '사람이 거절했습니다' : '승인이 필요한데 물어볼 사람이 없습니다');
+      }
+    }
+    if (!결판) {
+      let result;
+      try { result = await runTool('Bash', args, ctx); }
+      catch (err) { result = { error: String(err?.message ?? err) }; }
+      const 아는열쇠들 = [conn.key, ...환경속열쇠들()].filter(Boolean);
+      if (result.중단됨) 결판 = 못돌림('중단했습니다');
+      /*
+       * Bash 도구 안의 위험 명령 막이·경로 막이에 걸렸다(`막힘 — …`). 이것도 **못 돌린** 것이다.
+       * 실패로 치면 모델에게 「검사를 통과시키라」 고 되미는데, 막힌 것은 모델이 고칠 수 있는 일이
+       * 아니다 — 판만 쓰고 같은 자리에서 또 막힌다 (2차 눈 판정).
+       */
+      else if (/^막힘 — /.test(String(result.error ?? ''))) 결판 = 못돌림(String(result.error));
+      else {
+        let 출력 = String(result.content ?? result.error ?? '');
+        // 모델에게 돌려줄 글이다 — 도구 결과와 같은 자로 가린다 (아래 도구 결과 싣는 자리).
+        if (가릴까('Bash', { 바깥: 바깥으로나감 })) {
+          const 가린 = 가리기(출력, { 열쇠들: 아는열쇠들 });
+          if (가린.가린것.length) 출력 = 가린.글 + 가렸다는말(가린.가린것);
+        }
+        결판 = {
+          ok: 통과했나(result), 명령, 판, 최대, 출력,
+          요약: String(result.summary ?? result.error ?? '').split('\n')[0],
+        };
+      }
+      // 도구전 훅을 지났으면 도구후 훅도 지난다 — 감사 훅이 앞만 보고 뒤를 못 보면 반쪽 기록이다.
+      if (ctx.훅들?.length && !result.중단됨) {
+        const 훅 = await 자리돌리기(ctx.훅들, '도구후', {
+          도구: 'Bash', 넣을것: { 인자: args, 실패: 결판.ok !== true, 바뀐것: null }, signal, audit: ctx.audit,
+        });
+        if (훅.말들.length) {
+          const 가린 = 가리기(훅.말들.join('\n'), { 열쇠들: 아는열쇠들 });
+          for (const 말 of 가린.글.split('\n')) yield { type: 'hook_note', 자리: '도구후', 도구: 'Bash', 말 };
+        }
+      }
+    }
+    const { 출력: _뺌, ...보일것 } = 결판;
+    yield { type: 'check', ...보일것, 꼬리: 결판.출력 ? 출력꼬리(결판.출력, 1200) : '' };
+    return 결판;
+  }
 
   // 살려 쓴 파일이 지난번보다 실제로 커졌는지 보려고 크기를 기억해 둔다.
   const 살린크기 = new Map();
@@ -1536,6 +1637,30 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0,
         yield { type: 'nudge', why: '요청누락', 빠진, text: msg.content };
         continue;
       }
+      /*
+       * ── 완료 검사 (agent/donecheck.js) ────────────────────────────────
+       *
+       * 모델은 「다 됐습니다」 라고 했다. 사람이 검사 명령을 정해 뒀고 이번 턴에 무엇을
+       * 바꿨으면, 그 말을 믿기 전에 검사를 돌린다. 실패하면 출력을 돌려주고 이어서
+       * 고치게 한다 — 정해 둔 판수까지. 다 쓰고도 실패면 **실패로** 끝낸다(done 의 검사).
+       *
+       * 지난 검사 뒤로 바뀐 것이 없으면 다시 안 돌린다. 같은 결과를 또 기다리게 할 뿐이다.
+       * 못 돌린 것(규칙 금지·훅·승인 거절)은 되밀지 않는다 — 모델이 고칠 수 있는 일이 아니다.
+       */
+      if (완료검사 && 바뀜수 > 검사때바뀜수 && 검사판 < 완료검사.판수) {
+        검사판++;
+        검사때바뀜수 = 바뀜수;
+        검사상태 = yield* 완료검사돌리기(검사판);
+        if (검사상태.ok === false && 검사판 < 완료검사.판수) {
+          // 명령 줄도 모델에게 가는 글이다. 출력만 가리고 `--token=…` 을 날것으로 싣으면 반쪽이다.
+          const 명령줄 = 가리기(검사상태.명령, { 열쇠들: [conn.key, ...환경속열쇠들()].filter(Boolean) }).글;
+          session.push({
+            role: 'user',
+            content: 검사실패말({ 명령: 명령줄, 출력: 검사상태.출력, 판: 검사판, 최대: 완료검사.판수 }, { 영어: 지시말() === 'en' }),
+          });
+          continue;
+        }
+      }
       /*
        * ── 턴이 끝나는 자리 (safety/hooks.js) ────────────────────────────
        *
@@ -1560,7 +1685,9 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0,
         }
       }
       // 밀고도 그대로면 조용히 넘어가지 않는다. 사람이 알아야 다음을 정한다.
-      yield { type: 'done', steps, text: msg.content, files: 마무리(), 빠진 };
+      // 완료 검사를 돌렸으면 그 결과도 싣는다 — `deel run` 이 종료코드를, 화면이 끝맺음 줄을 여기서 정한다.
+      const 검사 = 검사상태 && (({ 출력: _뺌, ...나머지 }) => 나머지)(검사상태);
+      yield { type: 'done', steps, text: msg.content, files: 마무리(), 빠진, 검사 };
       return;
     }
 
@@ -1894,16 +2021,40 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0,
           for (const 말 of 훅.말들) yield { type: 'hook_note', 자리: '도구전', 도구: call.name, 말 };
         }
 
-        // 모드에 따라 물어본다. 기본(auto)은 안 묻고 되돌리기로 대응한다.
-        const needsOk = 판정.답 === 'allow' ? false : session.mode === 'strict'
-          ? ['Write', 'Edit', 'Bash'].includes(call.name)
+        /*
+         * 모드에 따라 물어본다. 기본(auto)은 안 묻고 되돌리기로 대응한다.
+         *
+         * strict 는 **바꾸는 도구를 다** 묻는다. 여태 여기는 Write·Edit·Bash 셋만 적혀 있어서
+         * Append·Move·Jobs 는 strict 에서도 안 묻고 돌았다 — modes.js 가 바꾸는 도구를 여섯으로
+         * 적어 두고, 이 자리만 옛 목록에 남아 있었다. MCP 도구는 남의 프로그램이라 무엇을 바꾸는지
+         * 우리가 모른다. 모를 때는 묻는다.
+         *
+         * 관리 정책이 승인 바닥을 걸었으면(policy.js 의 승인바닥) 사람이 설정에 적어 둔 「늘 허락」
+         * 도 묻기를 못 건너뛴다. 정책은 설정을 이긴다 — 관리자가 「바꾸기 전에 늘 묻는다」 를
+         * 걸었는데 `"allow": ["Edit"]` 한 줄로 풀리면 그 바닥은 장식이다.
+         */
+        const 정책이묻게함 = 승인바닥().바닥 !== 'auto';
+        // Jobs 는 대개 뒤에서 도는 명령의 출력을 **읽는** 호출이다. 끝내기(stop)만 바꾸는 것으로
+        // 친다 — 읽을 때마다 물으면 사람은 y 만 치다가 정작 물어야 할 것도 그렇게 넘긴다.
+        const 바꾸는것 = (call.name === 'Jobs' ? !!call.args?.stop : 바꾸는도구.includes(call.name))
+          || call.name.startsWith('mcp__');
+        const needsOk = (판정.답 === 'allow' && !정책이묻게함) ? false : session.mode === 'strict'
+          ? 바꾸는것
           : session.mode === 'confirm'
             ? (call.name === 'Bash' && isMutating(call.args?.command))
             : false;
-        if (needsOk && ctx.confirm) {
-          const ok = await ctx.confirm(call.name, call.args);
+        if (needsOk) {
+          /*
+           * 물어볼 사람이 없으면 **거절**이다. 여태 `needsOk && ctx.confirm` 이라, confirm 을 안 단
+           * 부르는 쪽에서는 strict 가 물음 없이 그대로 실행했다 — 「묻는다」 가 「물을 곳이 있으면
+           * 묻는다」 였다. 승인은 답한 사람이 있을 때만 난다 (repl.js 의 confirm 머리말과 같은 자세).
+           */
+          const 미리보기 = 바뀔내용(call.name, call.args, ctx);
+          const ok = ctx.confirm ? await ctx.confirm(call.name, call.args, { 미리보기 }) : false;
           if (!ok) {
-            거절(call, '사용자가 거부했습니다. 다른 방법을 찾거나 이유를 물어보세요.');
+            거절(call, ctx.confirm
+              ? '사용자가 거부했습니다. 다른 방법을 찾거나 이유를 물어보세요.'
+              : '승인이 필요한데 물어볼 사람이 없어 하지 않았습니다. 승인 없이 되는 방법을 고르세요.');
             // 거부를 못 알아듣고 같은 것을 계속 물으면 사람만 계속 n 을 치게 된다.
             if (막힘셈(call, '사용자 거부')) 멈출까 = '거부하셨는데도 같은 것을 계속 물어보고 있습니다';
             yield { type: 'tool', name: call.name, args: call.args, result: { error: '거부됨' }, showLabel: true };
@@ -2141,6 +2292,7 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0,
          * 여기서 또 합치면 같은 변경이 두 번 세어진다.
          */
         for (const f of 끝?.files ?? []) if (f?.path) 손댄파일.add(f.path);
+        if (끝?.files?.length) 바뀜수++;
         // 하위가 쓴 토큰·시간도 이번 턴의 셈에 들어가야 한다. 안 그러면 /context 가 거짓말을 한다.
         session.usage.in += 자식.usage.in;
         session.usage.out += 자식.usage.out;
@@ -2282,6 +2434,17 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0,
         if (result.changed || result.여럿?.some((f) => f.ok) || result.바뀐것들?.length) {
           이번턴본것.바꿈 = true;
         }
+        /*
+         * 완료 검사가 「고친 뒤에 다시 돌릴까」 를 이걸로 가른다. 셸로 바꾼 것(sed -i · mv ·
+         * `> 파일` · 스크립트 파일 돌리기)도 센다 — 실패를 받고 셸로만 고친 판에서 검사가 다시
+         * 안 돌면 고쳐 놓고도 실패로 끝난다. **검사가 한 번 돈 뒤에는** 셸·MCP 호출을 무엇이든
+         * 센다(2차 눈 판정: `make` · `npx codemod` 는 어느 목록에도 없다). 고치는 중이라
+         * 헛짚어도 검사가 한 번 더 돌 뿐이고, 판수가 끝을 막는다.
+         */
+        const 셸명령 = call.name === 'Bash' ? String(call.args?.command ?? '') : null;
+        if (!result.error && (result.changed || result.여럿?.some((f) => f.ok) || result.바뀐것들?.length
+          || (셸명령 !== null && (isMutating(셸명령) || 셸이파일에쓰나(셸명령) || 스크립트돌림.test(셸명령)))
+          || (검사판 > 0 && (셸명령 !== null || call.name.startsWith('mcp__'))))) 바뀜수++;
         if (call.name === 'TodoWrite' && !result.error) 이번턴본것.할일 = true;
         // 한 번에 여러 개를 쓴 경우. changed 하나만 보면 나머지가 조용히 빠져서,
         // 턴 끝에 "만들어졌다" 고 확인해 주는 파일이 넷 중 하나만 나온다.

package/src/agent/memory.js

@@ -71,7 +71,7 @@ const 머리말 = `# 기억
  * 남의 줄이 든 파일에 한 줄 **더해서** 쓸 때는 지문을 안 적는다. 적으면 남의
  * 줄이 내 줄 틈에 끼어 「이 PC 가 적은 것」 으로 세탁된다.
  */
-export const 내것표자리 = (env = process.env) => join(dirname(신뢰자리(env)), 'memory-own.json');
+const 내것표자리 = (env = process.env) => join(dirname(신뢰자리(env)), 'memory-own.json');
 /** 지문을 들고 있는 폴더 수. 넘으면 오래 안 쓴 것부터 뺀다 — 빠진 폴더는 믿기 전까지 안 실릴 뿐이다. */
 const 내것표최대 = 200;
 /*

package/src/agent/models.js

@@ -195,7 +195,7 @@ export function 알릴말(지금conn, 새conn) {
 /**
  * 지금 붙어 있는 프로필. `/ask` 가 '나 자신에게 묻기' 를 걸러낼 때 쓴다.
  */
-export function 지금프로필(cfg = load()) {
+function 지금프로필(cfg = load()) {
   return activeProfile(cfg);
 }
 

package/src/agent/modes.js

@@ -36,6 +36,9 @@ const 계획 = ['TodoWrite', 'Remember'];
 // Move 는 구조를 바꾸는 유일한 길이다. 이게 없으면 "폴더를 역할대로 나눠 줘"
 // 에 남는 길이 Bash mv 뿐인데, 그건 매번 승인을 묻고 되돌리기에 안 잡힌다.
 const 쓰기 = ['Write', 'Append', 'Edit', 'Move', 'Bash', 'Jobs'];
+// strict 승인이 묻는 도구도 이 목록이다 (agent/loop.js). 따로 적어 두면 여기 도구가
+// 늘 때 관문 쪽 목록이 뒤에 남는다 — Append·Move·Jobs 가 실제로 그렇게 빠져 있었다.
+export const 바꾸는도구 = Object.freeze([...쓰기]);
 // 만든 것을 확인하는 도구. 아무것도 안 바꾸지만 **쓰는 모드에만** 준다 —
 // 안 만든 모드에서 확인할 것이 없고, 도구 정의로 나가는 자리만 먹는다.
 const 확인 = ['Verify'];

package/src/agent/outschema.js

@@ -210,7 +210,7 @@ function 제자리참조찾기(뿌리) {
 }
 
 /** 같은 파일 안(`#`으로 시작)이 아닌 `$ref` 를 다 찾는다. */
-export function 바깥ref찾기(스키마, 본것 = new Set()) {
+function 바깥ref찾기(스키마, 본것 = new Set()) {
   const out = [];
   const 훑기 = (s) => {
     if (!s || typeof s !== 'object' || 본것.has(s)) return;

package/src/agent/pins.js

@@ -43,9 +43,14 @@ export class 못박기 {
     this.것들 = this.것들.slice(0, 최대개수);
   }
 
+  /*
+   * 견줄 때는 NFC 로 맞춘다 (2.0.2 · 429). 맥에서 친 한글은 자모로 풀린 꼴(NFD)로 오기도 해서,
+   * 같은 「운영 DB 는 건드리지 마라」 가 두 번 박혔다 — 매 턴 실리는 자리를 같은 말이 둘 먹는다.
+   */
   #이미있나(말) {
-    const 낮 = 말.toLowerCase();
-    return this.것들.some((x) => x.toLowerCase() === 낮);
+    const 열쇠 = (x) => x.normalize('NFC').toLowerCase();
+    const 낮 = 열쇠(말);
+    return this.것들.some((x) => 열쇠(x) === 낮);
   }
 
   /**

package/src/agent/project.js

@@ -68,7 +68,7 @@ const 명령이름최대 = 60;
 const 가지최대 = 120;
 
 /** 떨어져 나온 머리(detached HEAD). 135-136 주석이 적은 말과 같은 글이어야 한다. */
-export const 떨어진머리 = '가지 없음 (detached)';
+const 떨어진머리 = '가지 없음 (detached)';
 
 /*
  * 확장자로만 갈래가 정해지는 것들 (2.0.0 8회차 판정).

package/src/agent/recall.js

@@ -23,7 +23,7 @@ import { sessionsDir } from './store.js';
 import { 부른것들, 결과들, 도구결과인가, 본문글 } from '../backend/adapter.js';
 
 // 한 번 찾을 때 읽을 최대 바이트. 넘으면 거기서 멈추고 **멈췄다고 말한다.**
-export const 읽기예산 = 64 * 1024 * 1024;
+const 읽기예산 = 64 * 1024 * 1024;
 // 한 메시지에서 볼 최대 길이. 파일을 통째로 붙인 도구 결과가 수 MB 씩 있다.
 const 메시지최대 = 200 * 1024;
 

package/src/agent/session.js

@@ -7,6 +7,7 @@ import { 조각표 } from '../backend/cachemark.js';
 import { get as workMode, 말 as 모드말, DEFAULT as WORK_DEFAULT } from './modes.js';
 import { toolSchemas } from '../tools/index.js';
 import { isOffline } from '../safety/network.js';
+import { 승인바닥, 더센승인 } from '../safety/policy.js';
 import { normalize as normLevel, DEFAULT as LEVEL_DEFAULT } from '../ui/level.js';
 import { 매김, 급말, 값 as 급값, 지켜본것 } from './grade.js';
 import { 지문 } from './project.js';
@@ -218,6 +219,20 @@ function 기본규칙(ctx) {
 const 규칙최대 = 20000;
 
 export class Session {
+  #승인 = 'auto';
+
+  /*
+   * 승인 모드는 관리 정책의 바닥 아래로 못 내려간다 (safety/policy.js 의 승인바닥).
+   *
+   * 읽는 자리에서 덮는다. `/mode` · Shift+Tab · 편집기 · `deel run` · 하위 작업이 제각각
+   * session.mode 를 쓰는데, 자리마다 바닥을 걸면 하나를 빠뜨린 자리가 곧 구멍이다.
+   * 여기 한 곳에서 걸면 누가 무엇을 적든 관문(agent/loop.js)이 읽는 값은 바닥 위다.
+   */
+  get mode() { return 더센승인(this.#승인, 승인바닥().바닥); }
+  set mode(v) { this.#승인 = v; }
+  /** 사람이 고른 그대로 — 바닥이 덮었는지를 화면이 말할 때 쓴다. */
+  get 고른승인() { return this.#승인; }
+
   constructor(conn, { root, mode = 'auto', work = null, level = null, think = 'medium', effort = 'save', web = true, maxSteps = null } = {}) {
     this.conn = conn;
     this.root = root;

package/src/agent/store.js

@@ -15,8 +15,8 @@
 import {
   existsSync, mkdirSync, readdirSync, readFileSync,
   appendFileSync, writeFileSync, statSync, rmSync, chmodSync, renameSync,
-  openSync, readSync, closeSync,
 } from 'node:fs';
+import { 줄로끝나나, 본인만잠그기 } from '../jsonl.js';
 import { join } from 'node:path';
 import { 도구결과인가 } from '../backend/adapter.js';
 import { BOM떼기 } from '../safety/trust.js';
@@ -131,9 +131,15 @@ export class Store {
    * 그래서 「안 적히고 있습니다」 가 한 번도 안 떴다. 사람이 알아차리는 자리는
    * 또 **다음 날 --resume** 이다 — 이 파일 위쪽이 너무 늦다고 적어 둔 그 자리다.
    *
-   * 우리가 지은 이름은 freeId 와 'wx' 가 이미 막는다. 사람이 이름을 준 자리
-   * (--resume/--continue)만 여기서 본다. 내가 적어 둔 데까지의 바이트 수를
-   * 들고 있다가, 적기 전에 파일이 그보다 자라 있으면 남이 쓴 것이다.
+   * 내가 적어 둔 데까지의 바이트 수를 들고 있다가, 적기 전에 파일이 그보다 자라
+   * 있으면 남이 쓴 것이다.
+   *
+   * **우리가 지은 이름의 창도 본다** (2.0.2 · 527). 지은 이름은 freeId 와 'wx' 가
+   * 「두 창이 같은 새 이름을 집는 것」 은 막지만, 다른 창이 `--continue` 로 **이 파일을**
+   * 집어 오는 것은 못 막는다 — 제일 최근 대화가 바로 이것이다. 그래서 뒤에 연 창만 멈추고
+   * 먼저 연 창은 그 창의 줄 사이에 제 줄을 섞어 넣었고, 접으면(replace) 그 창의 줄을
+   * 통째로 지웠다. 이제 누가 먼저 적든 **먼저 적은 쪽이 이어 가고 다른 쪽이 멈춘다** —
+   * 한 파일에 두 대화가 섞이는 일이 없다. 멈춘 쪽 화면은 「안 적히고 있습니다」 를 말한다.
    *
    * 그러면 **안 적고 센다.** 그냥 이어 붙이는 것은 두 대화를 섞어 놓는 일이고,
    * 섞인 파일은 둘 다 못 쓰게 된다. 대신 잠자코 물러나지는 않는다 — 못쓴 셈에
@@ -144,7 +150,7 @@ export class Store {
   /** 지금 파일 크기. 못 재면 null — 모르는 것은 모른다고 둔다(헛경보가 더 나쁘다). */
   #크기() { try { return statSync(this.file).size; } catch { return null; } }
   #남이썼나() {
-    if (this.auto || this.#끝자리 == null) return false;
+    if (this.#끝자리 == null) return false;
     const 지금 = this.#크기();
     return 지금 != null && 지금 !== this.#끝자리;
   }
@@ -167,14 +173,7 @@ export class Store {
   #잠그기() {
     if (this.#잠갔나) return;
     this.#잠갔나 = true;
-    /*
-     * 윈도우에서 chmod 는 **아무 일도 안 하고 성공한다.** 그 성공을 그대로
-     * 적으면 바로 위 머리말이 스스로 금지한 「잠근 척」 이 된다 — 같은 PC 를
-     * 여럿이 쓰는 사람이 화면만 보고 안심한다. 안 걸었으면 안 걸었다고 적는다.
-     */
-    if (process.platform === 'win32') { this.잠금 = { 못함: 'windows' }; return; }
-    try { chmodSync(this.file, 0o600); this.잠금 = { 모드: 0o600 }; }
-    catch (err) { this.잠금 = { 못함: err?.code ?? String(err) }; }
+    this.잠금 = 본인만잠그기(this.file);
   }
 
   #open() {
@@ -274,18 +273,6 @@ export class Store {
    * 파일마다 처음 적을 때 한 번, 끝이 개행인지 보고 아니면 개행부터 붙인다.
    */
   #줄끝봤나 = 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 { /* 닫다 터져도 적기는 한다 */ } } }
-  }
 
   /** 한 줄 적는다. 적었으면 true. 못 적었으면 false 이고 셈에 오른다. */
   #write(obj) {
@@ -296,7 +283,7 @@ export class Store {
     if (this.#남이썼나()) { this.#못썼다({ code: 'OTHER_WINDOW' }); return false; }
     try {
       if (!this.#줄끝봤나) {
-        if (!this.#줄로끝나나()) 줄 = '\n' + 줄;
+        if (!줄로끝나나(this.file)) 줄 = '\n' + 줄;
         this.#줄끝봤나 = true;
       }
       appendFileSync(this.file, 줄, 'utf8');

package/src/backend/ctxsize.js

@@ -97,7 +97,7 @@ function 성한수(v) {
  *
  * llama.cpp 의 /props 나 일부 게이트웨이의 설명 필드도 같은 모양이다.
  */
-export function 글에서찾기(s, 이름들) {
+function 글에서찾기(s, 이름들) {
   const 글 = String(s ?? '');
   if (!글 || 글.length > 200000) return null;
   for (const 이름 of 이름들) {
@@ -122,7 +122,7 @@ export function 글에서찾기(s, 이름들) {
  * 어느 이름에서 찾았는지도 같이 돌려준다 — 값이 이상할 때 사람이 원인을
  * 짚을 수 있어야 한다. /ctx 자세히 가 이걸 보여 준다.
  */
-export function 파보기(obj, 이름들, { 글도 = true, depth = 0 } = {}) {
+function 파보기(obj, 이름들, { 글도 = true, depth = 0 } = {}) {
   if (!obj || typeof obj !== 'object' || depth > 5) return null;
   for (const key of 이름들) {
     const v = 성한수(obj[key]);

package/src/backend/http.js

@@ -304,7 +304,7 @@ function 신호(timeout, signal) {
  */
 export const 잠잠기본 = 60000;
 
-export function 멎음오류(잠잠) {
+function 멎음오류(잠잠) {
   return Object.assign(
     new Error(`${초로(잠잠)}초 동안 아무것도 안 왔습니다 — 흐름이 멎었습니다`),
     { name: 'StallError', code: 'STALL', 잠잠 },

package/src/backend/learn.js

@@ -29,6 +29,32 @@ const 성한수 = (v) => {
   return Number.isFinite(n) && n >= 최소 && n <= 최대허용 ? n : null;
 };
 
+/*
+ * 창 한계 문장에서 **우리가 보낸 크기**를 뽑는다 (2.0.2 · 488).
+ *
+ * 한계 뒤 `requested N` 만 봤다. 요즘 vLLM 은 이렇게 말한다 —
+ *
+ *   However, your request has 40000 input tokens.                              → 못 뽑음 (null)
+ *   However, you requested 1024 output tokens and your prompt contains at least
+ *   7169 input tokens, for a total of at least 8193 tokens.                    → 1024 로 뽑음
+ *
+ * 뒤엣것은 틀린 수다 — 화면이 「(1,024 을 보냈었습니다)」 라고, 8,192 창에 1,024 를 보내 거절당한
+ * 것처럼 말한다. 합이 있으면 합, 없으면 답 길이가 아닌 `requested N`, 그다음 입력 크기 순으로 본다.
+ */
+function 보낸크기(s) {
+  const 차례 = [
+    /for a total of\s+(?:at least\s+)?(\d+)/i,
+    /requested\s+(\d+)(?!\d)(?!\s*(?:output|completion|new)\b)/i,
+    /requested tokens\s*\(\s*(\d+)\s*\)/i,
+    /(?:request has|prompt contains|input (?:has|contains))\s+(?:at least\s+)?(\d+)/i,
+  ];
+  for (const re of 차례) {
+    const n = 성한수(re.exec(s)?.[1]);
+    if (n) return n;
+  }
+  return null;
+}
+
 /**
  * 거절 문장에서 배울 것이 있나.
  *
@@ -107,7 +133,7 @@ export function 배울것(message) {
     if (!m) continue;
     const limit = 성한수(m[1]);
     if (!limit) continue;
-    return { kind: 'ctx', limit, asked: 성한수(m[2]) ?? null, text: 짧게(원문) };
+    return { kind: 'ctx', limit, asked: 보낸크기(s), text: 짧게(원문) };
   }
 
   // ── 2) 답 길이 한계 ───────────────────────────────────────────────────