deel-local-cli 2.0.3 → 2.1.1

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';
@@ -14,18 +14,20 @@ import { compact, shouldCompact, shouldFold, foldToolResults, foldImages, 못박
 import { 걸음수, 하위걸음수, 요약길이 } from './budget.js';
 import { Session, estimateTokens } from './session.js';
 import { 최대깊이, 하위모드, 하위요약 } from '../tools/task.js';
+import { 일감인자 } from '../tools/jobs.js';
 import { 찾기 as 에이전트찾기, 할일합치기, 도구줄이기 } from './agents.js';
 import { 프로필찾기, 쓸수있나, 연결만들기, 알릴말, 목록보기 } from './models.js';
 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 +150,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;
+
 /*
  * 잘린 답을 「생각을 줄여」 다시 부를 때 쓰는 두 값.
  *
@@ -337,6 +346,100 @@ 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', 명령, 판, 최대, ...(판 === 1 && 완료검사.줄임?.length ? { 줄임: 완료검사.줄임 } : {}) };
+    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();
@@ -431,10 +534,22 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0,
     if (!부른것.length) return;
     // 결과가 어느 role 에 실리는지도 규격마다 다르다. `role === 'tool'` 로
     // 세면 Anthropic 꼴에서 언제나 0 이라, 지어낸 번호가 전부 겹친다.
-    const 이미 = session.messages.filter(도구결과인가).length;
+    /*
+     * 지어낸 번호는 부름마다 새로 짓고, **이미 쓰인 번호는 건너뛴다.** 한 번만 세면 id 없는 부름 여럿이
+     * 같은 번호를 받고, 결과 수로만 세면 모델이 준 `call_1` 이나 접기 뒤 남은 옛 번호와 겹쳐 또 400 이다
+     * (2.1.1 검수 · 2차 눈). 빈 글 id 도 없는 것으로 친다.
+     */
+    const 쓴번호 = new Set(session.messages.flatMap((m) => 부른것들(m).map((t) => t.id)).filter(Boolean));
+    let 이미 = session.messages.filter(도구결과인가).length;
+    const 새번호 = () => {
+      let id;
+      do { id = `call_${++이미}`; } while (쓴번호.has(id));
+      쓴번호.add(id);
+      return id;
+    };
     for (const t of 부른것) {
       session.push(toolMessage(conn.kind, {
-        callId: t.id ?? `call_${이미 + 1}`,
+        callId: t.id || 새번호(),
         name: t.name ?? '?',
         content: 왜,
       }));
@@ -1536,6 +1651,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 +1699,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 +2035,42 @@ 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 만 치다가 정작 물어야 할 것도 그렇게 넘긴다.
+        // 끄는가는 **도구가 읽는 자**(일감인자)로 가른다. `stop` 칸만 보면 작은 모델이 보내는
+        // `kill` · `끝내기` 가 안 묻고 서버를 끄고, `stop:"false"` 는 `!!` 로 참이 되어 헛물음이 난다.
+        const 바꾸는것 = (call.name === 'Jobs' ? 일감인자(call.args).끝내기 === true : 바꾸는도구.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 +2308,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 +2450,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/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/route.js

@@ -1381,7 +1381,8 @@ export function route(text, { 승인받을수있나 = true } = {}) {
 
   // 1·2등이 붙으면 고르지 않는다. 반반인 것을 억지로 정하면 절반은 틀린다.
   const 둘째 = 순위[1]?.[1] ?? 0;
-  if (점수 - 둘째 < 2 && 둘째 >= (문턱[순위[1][0]] ?? 4)) {
+  // 둘째가 없을 수도 있다 — 지금 표로는 늘 둘이 남지만, 모드 표가 바뀌면 여기서 사람 말 한 줄이 죽는다.
+  if (순위[1] && 점수 - 둘째 < 2 && 둘째 >= (문턱[순위[1][0]] ?? 4)) {
     return {
       mode: null, score: 점수, why: `${으뜸} 과 ${순위[1][0]} 가 비슷함`,
       겹침: 겹.겹침, 점수들, 뺀것, 일부러: true,

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';
@@ -217,7 +218,24 @@ function 기본규칙(ctx) {
  */
 const 규칙최대 = 20000;
 
+/** 메시지 하나를 센 값 — 메시지 객체가 열쇠다(breakdown 의 「한 번 센 메시지」). 갈아 끼우면 저절로 빠진다. */
+const 메시지셈 = new WeakMap();
+
 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;
@@ -1139,6 +1157,18 @@ export class Session {
      */
     let 도구결과수 = 0;
     for (const m of this.messages) {
+      /*
+       * 한 번 센 메시지는 다시 안 센다 (2.1.1 검수).
+       *
+       * 상태줄은 일하는 동안 90ms 마다 그려지고 그때마다 여기를 부른다. 64만 토큰 창이면 초당
+       * 스무 번 넘게 대화 전체를 글자 단위로 훑었다. 메시지는 제자리에서 안 고치고 **새 것으로
+       * 갈아 끼우므로**(접기·요약·짝맞추기 다 그렇다) 메시지 자체를 열쇠로 잡아도 낡지 않는다.
+       */
+      const 센것 = m && typeof m === 'object' ? 메시지셈.get(m) : undefined;
+      if (센것) {
+        if (센것.결과) { files += 센것.t; 도구결과수 += 1; } else history += 센것.t;
+        continue;
+      }
       /*
        * 그림은 글자 수로 세지 않는다.
        *
@@ -1155,7 +1185,9 @@ export class Session {
       // 도구 결과는 규격마다 다른 자리에 온다. `role` 만 보면 Anthropic 에서는
       // 도구 결과가 통째로 '대화' 로 세어져서, /context 가 「도구 결과 0 토큰」
       // 이라고 적는다 — 무엇을 접어야 할지 보라고 만든 표가 거꾸로 가리킨다.
-      if (도구결과인가(m)) { files += t; 도구결과수 += 1; } else history += t;
+      const 결과 = 도구결과인가(m);
+      if (m && typeof m === 'object') 메시지셈.set(m, { t, 결과 });
+      if (결과) { files += t; 도구결과수 += 1; } else history += t;
     }
 
     // 도구 정의도 매 요청에 실려 나간다. 세는 값이라기보다 '이미 나간 값' 이다.

package/src/commands.js

@@ -885,6 +885,12 @@ export async function handle(line, session, ctx) {
         say('');
         say(`  ${c.gray('지금은')} ${승인표시(session.mode)} ${c.gray('입니다. 상태줄 오른쪽에도 늘 떠 있습니다.')}`);
         say(`  ${c.gray('치지 않고 바꾸려면')} ${c.cyan('Shift+Tab')} ${c.gray('— 누를 때마다 차례로 돕니다.')}`);
+        {
+          const { 승인바닥 } = await import('./safety/policy.js');
+          const 바닥 = 승인바닥();
+          if (바닥.모름) say(`  ${mark.warn} ${c.gray(말('approve.lockedUnknown', { 값: 바닥.모름, 곳: 바닥.곳 ?? '' }))}`);
+          else if (바닥.바닥 !== 'auto') say(`  ${mark.warn} ${c.gray(말('approve.locked', { 바닥: 승인표시(바닥.바닥), 곳: 바닥.곳 ?? '' }))}`);
+        }
         /*
          * 적어 둔 규칙은 모드보다 세다. 그러니 모드만 보여 주고 규칙을 안 보여
          * 주면 화면이 거짓말을 하는 셈이다 — "안 묻습니다" 라고 적힌 모드에서
@@ -898,6 +904,20 @@ export async function handle(line, session, ctx) {
         return { handled: true };
       }
       const 앞 = session.mode;
+      /*
+       * 관리 정책의 바닥 아래로는 못 내린다 (safety/policy.js 의 승인바닥). Session 이 읽는
+       * 자리에서 어차피 덮지만, 여기서 말없이 받으면 화면에 「→ auto」 가 찍히고 실제로는
+       * strict 로 돈다 — 사람은 제 손으로 바꾼 줄 안다. 막고, 누가 막았는지 적는다.
+       */
+      const { 승인바닥, 더센승인 } = await import('./safety/policy.js');
+      const 바닥 = 승인바닥();
+      if (더센승인(승인이름, 바닥.바닥) !== 승인이름) {
+        say('');
+        say(`  ${mark.warn} ${c.gray(말('approve.locked', { 바닥: 승인표시(바닥.바닥), 곳: 바닥.곳 ?? '' }))}`);
+        say(`     ${c.gray('지금은')} ${승인표시(앞)} ${c.gray('입니다.')}`);
+        say('');
+        return { handled: true };
+      }
       session.mode = 승인이름;
       const m = 승인[승인이름];
       say('');

package/src/completion.js

@@ -39,6 +39,7 @@ export const 명령들 = [
   { 이름: 'doctor', 뜻: 'diagnose 와 같다', en: 'same as diagnose' },
   { 이름: 'pack', 뜻: '오프라인 반입용으로 묶는다', en: 'bundle for offline transfer' },
   { 이름: 'audit', 뜻: '무엇을 했는지 기록을 본다', en: 'show the record of what it did' },
+  { 이름: 'eval', 뜻: '과제 모음(골든셋)을 실제 모델로 돌려 성공률을 잰다', en: 'run a task set (golden set) on the real model and measure the pass rate' },
   { 이름: 'doc2md', 뜻: '문서·시안을 마크다운으로 (hwpx·docx·pptx·xlsx·pdf·fig)', en: 'document or design to Markdown (hwpx/docx/pptx/xlsx/pdf/fig)' },
   { 이름: 'sbom', 뜻: '무엇이 들었는지 목록을 낸다', en: 'list what is inside (SBOM)' },
   { 이름: 'trust', 뜻: '이 폴더의 프로젝트 설정을 읽게 한다', en: "read this folder's project config" },
@@ -89,6 +90,12 @@ export const 깃발들 = [
   { 이름: '--yes', 뜻: '물어보지 않고 진행', en: 'do not ask, just proceed', 값: false },
   { 이름: '--hard', 뜻: 'reset all 에서 되돌리기·감사기록까지', en: 'with reset all: undo snapshots and the audit log too', 값: false },
   { 이름: '--json', 뜻: '결과를 JSON 으로', en: 'output JSON', 값: false },
+  { 이름: '--check', 뜻: 'run: 끝내기 전에 돌릴 검사 명령', en: 'run: check command to pass before finishing', 값: null },
+  { 이름: '--repeat', 뜻: 'eval: 과제마다 몇 번 돌릴까', en: 'eval: runs per task', 값: null },
+  { 이름: '--init', 뜻: 'eval: 예제 과제를 만든다', en: 'eval: write the example tasks', 값: false },
+  { 이름: '--only', 뜻: 'eval: 고른 과제만 (쉼표) · sbom: 한 가지만', en: 'eval: only these tasks (comma); sbom: only one part', 값: null },
+  { 이름: '--keep', 뜻: 'eval: 작업 폴더를 남긴다', en: 'eval: keep the work folders', 값: false },
+  { 이름: '--timeout', 뜻: 'eval: 과제 하나의 제한 시간(초)', en: 'eval: time limit per task (seconds)', 값: null },
   { 이름: '--days', 뜻: 'stats 에서 볼 기간(일)', en: 'stats: how many days back', 값: null },
   { 이름: '--all', 뜻: 'stats 에서 기간을 안 자름', en: 'stats: no time window', 값: false },
   // 값이 파일이라 셸이 파일을 완성해 줘야 한다. 목록으로 못 준다 —

package/src/configexplain.js

@@ -25,6 +25,7 @@ import { homeDir, 집설정파일인가, 열쇠환경이름 } from './config.js'
 import { 믿나, 프로젝트거르기, BOM떼기, 연결칸 } from './safety/trust.js';
 import { 정책읽기, 정책자리 } from './safety/policy.js';
 import { 받기설정 } from './safety/authcmd.js';
+import { 주소가리기 } from './safety/secrets.js';
 
 /*
  * 이 PC 프로필에 겹치는 저장소 프로필에서 연결 칸(baseUrl·kind·auth·제공자)을 걷는다.
@@ -78,7 +79,23 @@ const 환경변수 = {
  * 하는 것이 이런 자리에서 제일 흔한 사고다.
  */
 const 비밀표시 = '(적혀 있음 — 값은 안 보여 줍니다)';
-const 지운값 = (칸, v) => (v !== undefined && 가릴칸.has(칸) ? 비밀표시 : v);
+/*
+ * **끝 칸 이름만** 보면 안 된다. `profiles.사내` 처럼 한 칸 위에서 멈추면 값이 객체이고,
+ * 그 안의 apiKey · 인증서 passphrase 가 통째로 그려졌다. 그래서 객체·배열은 안으로 파고들어
+ * 칸마다 같은 자로 본다.
+ *
+ * 주소 꼴의 글(`http://사람:암호@프록시:8080`)은 doctor 와 같은 자(주소가리기)로 가린다 —
+ * 호스트·포트는 남는다. 어디로 가는지는 사람이 봐야 한다.
+ */
+const 주소꼴 = /^[a-z][a-z0-9+.-]*:\/\//i;
+const 지운값 = (칸, v) => {
+  if (v === undefined) return v;
+  if (가릴칸.has(칸)) return 비밀표시;
+  if (typeof v === 'string') return 주소꼴.test(v.trim()) ? 주소가리기(v) : v;
+  if (Array.isArray(v)) return v.map((x) => 지운값('', x));
+  if (v && typeof v === 'object') return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, 지운값(k, x)]));
+  return v;
+};
 
 const 값보이기 = (칸, v) => {
   if (v === undefined) return null;

package/src/doctor.js

@@ -32,7 +32,7 @@ import { 에이전트읽기, 에이전트줄들 } from './agent/agents.js';
 import { headersFor } from './backend/http.js';
 import { 열쇠출처, 집설정파일인가 } from './config.js';
 import { 받기설정, 쓸수있나 as 받기쓸수있나 } from './safety/authcmd.js';
-import { 정책읽기 } from './safety/policy.js';
+import { 정책읽기, 승인바닥 } from './safety/policy.js';
 import { 설정읽기 as MCP설정읽기 } from './backend/mcp.js';
 
 /** 한 줄. `상태` 는 ok · warn · no · unknown 넷뿐이다. */
@@ -100,6 +100,16 @@ export async function 진찰(o = {}) {
     줄들.push(줄('no', '설정 파일', 설정탈.자리 ?? 설정자리 ?? '(어느 파일인지 모름)',
       `못 읽었습니다 — ${String(설정탈.까닭 ?? '').replace(/\s+/g, ' ').trim()}`));
   } else if (설정자리) 줄들.push(줄(existsSync(설정자리) ? 'ok' : 'warn', '설정 파일', 설정자리));
+  /*
+   * 관리 정책이 승인 바닥을 걸었나 (safety/policy.js 의 승인바닥). 걸렸으면 적는다 — 사람은
+   * `/mode auto` 가 왜 안 먹는지를 여기서 찾는다. 모르는 값이면 strict 로 친다는 것도 적는다.
+   */
+  {
+    const 바닥 = 승인바닥();
+    if (바닥.탈) 줄들.push(줄('warn', '승인 바닥', 'strict', `정책 파일을 못 읽어 제일 좁게 칩니다 — ${바닥.곳} · ${바닥.탈}`));
+    else if (바닥.모름) 줄들.push(줄('warn', '승인 바닥', 'strict', `정책의 approval "${바닥.모름}" 을 몰라 제일 좁게 칩니다 — ${바닥.곳}`));
+    else if (바닥.바닥 !== 'auto') 줄들.push(줄('ok', '승인 바닥', 바닥.바닥, `관리 정책이 걸었습니다 — ${바닥.곳}`));
+  }
   const 프로젝트설정 = join(root, '.deel', 'config.json');
   // 집 폴더에서 켜면 이 파일이 곧 이 PC 설정이다. 두 번 적으면 제 설정에 「deel trust」 를 권한다.
   if (existsSync(프로젝트설정) && !집설정파일인가(프로젝트설정)) {