deel-local-cli 1.16.0 → 1.17.1

package/src/backend/wire.js

@@ -34,6 +34,7 @@
 // 캐시가 매번 새로 엮인다. 배워서 값이 바뀌는 것은 예외다 — 그건 안 그러면
 // 그 턴이 죽는 자리라, 한 번 흔들리는 값을 치른다.
 import { 벤더 } from './toolfit.js';
+import { 인증서등록 } from './clientcert.js';
 import { 말 } from '../i18n/index.js';
 
 /** 우리 눈금. agent/effort.js 의 LEVELS 와 같은 차례다 (off 는 따로 다룬다). */
@@ -608,6 +609,15 @@ export function 카드합치기(기본, 남긴것) {
  */
 export function 전선붙이기(conn, 배움 = null) {
   if (!conn) return conn;
+  /*
+   * 이 게이트웨이가 우리 인증서를 요구하면 여기서 매어 둔다 (backend/clientcert.js).
+   *
+   * 문이 넷이라 각 문에서 따로 부르면 언젠가 한 곳이 빠진다 — 그런 일이
+   * 실제로 두 번 있었다(vision·열쇠받기). 네 문이 다 지나는 자리는 여기다.
+   * `/model` 로 프로필을 갈아타도 여기를 다시 지나므로, 옛 프로필의 인증서가
+   * 새 창구로 따라가지 않는다.
+   */
+  인증서등록(conn.base, conn.인증서 ?? null);
   const 기본 = 기본카드(conn);
   let 남긴것 = null;
   try { 남긴것 = 배움?.아는전선?.(conn.model, conn.base, conn.kind) ?? null; } catch { 남긴것 = null; }

package/src/cmdnames.js

@@ -54,6 +54,8 @@ export const 명령들 = {
   sessions: { arg: false },
   recall: { arg: true },
   mcp: { arg: false },
+  hooks: { arg: false },
+  agents: { arg: false },
   memory: { arg: true },
   level: { arg: true },
   bell: { arg: true },

package/src/commands.js

@@ -30,6 +30,8 @@ import { 말, 말 as 옮긴말, 언어, 언어들, 언어정하기, 언어고르
 import { 프로필찾기, 쓸수있나, 연결만들기, 알릴말, 목록보기 } from './agent/models.js';
 import { allowTemporarily } from './safety/network.js';
 import { chat, 규격이름, 더할머리 } from './backend/adapter.js';
+import { 잠잠기본 } from './backend/http.js';
+import { 인증서설정, 인증서말 } from './backend/clientcert.js';
 import { 알림채움 } from './backend/retry.js';
 import { 프록시고르기, 프록시설정 } from './backend/proxy.js';
 import { 정한셸 } from './tools/shell.js';
@@ -1036,6 +1038,16 @@ export async function handle(line, session, ctx) {
       } else if (k.auth !== 'none') {
         say(`  ${c.gray(pad(말('status.keyStore'), 10))} ${열쇠보관(load())}`);
       }
+      /*
+       * 우리 인증서로 붙고 있으면 그렇다고 적는다.
+       *
+       * 인증서를 둘 이상 가진 사람은 어느 것이 먹었는지 알 길이 없다 — 붙으면
+       * 조용하고 안 붙으면 TLS 악수 실패 한 줄만 온다. **암호는 절대 안 적는다**
+       * (backend/clientcert.js 의 인증서말).
+       */
+      if (session.conn.인증서) {
+        say(`  ${c.gray(pad(말('status.clientCert'), 10))} ${c.gray(인증서말(session.conn.인증서))}`);
+      }
       say(`  ${c.gray(pad(말('status.rules'), 10))} ${session.rules ? session.rules.name : 말('status.noRules')}`);
       // 파일이 있는데 못 읽은 것을 '없음' 으로 적으면, 규칙을 적어 둔 사람은
       // 걸려 있다고 믿는다. 안 걸린 채로 도는 것이 여기서 제일 나쁜 모양이다.
@@ -1269,12 +1281,30 @@ export async function handle(line, session, ctx) {
       }
 
       for (const s of 붙은것) {
-        const 상태 = s.살아있나() ? c.green('●') : c.red('○');
+        /*
+         * 세 가지 상태를 **갈라서** 적는다 (backend/mcp.js 의 지연 로딩).
+         *
+         *   ● 떠 있다      지금 프로세스가 돌고 있다
+         *   ◐ 대기         적어 둔 목록으로 서 있다 — 그 도구를 부르면 뜬다
+         *   ○ 죽었다       띄웠는데 안 됐거나 도중에 죽었다
+         *
+         * 대기를 죽음으로 뭉개면 사람은 없는 탈을 고치러 간다. 반대로 대기를
+         * 초록으로 적으면 「띄워 봤다」 는 말이 거짓이 된다.
+         */
+        const 상태 = s.살아있나() ? c.green('●') : (s.대기 ? c.yellow('◐') : c.red('○'));
         const 이름들 = s.도구.map((t) => t.name);
         say(`  ${상태} ${c.bold(s.이름)}  ${c.gray(s.정보?.name ? `${s.정보.name} ${s.정보.version ?? ''}` : s.설정.command)}`);
         say(`      ${c.gray('도구 ' + s.도구.length + '개')}  ${c.gray(clip(이름들.join(' · '), 60))}`);
+        if (s.대기) say(`      ${c.gray('아직 안 띄웠습니다 — 적어 둔 목록입니다. 이 도구를 부르면 그때 뜹니다.')}`);
         if (s.잘림) say(`      ${mark.warn} ${c.gray(`${s.잘림}개는 뺐습니다 — 한 서버에 ${도구최대}개까지만 받습니다(컨텍스트가 줄어듭니다)`)}`);
-        if (!s.살아있나()) say(`      ${c.red(s.죽음 ?? '죽었습니다')}`);
+        if (s.달라짐) {
+          const 것 = [
+            s.달라짐.늘어난것?.length ? `늘어남 ${s.달라짐.늘어난것.join(' ')}` : null,
+            s.달라짐.없어진것?.length ? `없어짐 ${s.달라짐.없어진것.join(' ')}` : null,
+          ].filter(Boolean).join(' · ');
+          say(`      ${mark.warn} ${c.gray(`띄워 보니 목록이 달랐습니다 — ${것}`)}`);
+        }
+        if (!s.살아있나() && !s.대기) say(`      ${c.red(s.죽음 ?? '죽었습니다')}`);
       }
       say('');
       say(`  ${c.gray('모델에게는')} ${c.white('mcp__<서버>__<도구>')} ${c.gray('라는 이름으로 보입니다.')}`);
@@ -1288,6 +1318,97 @@ export async function handle(line, session, ctx) {
       return { handled: true };
     }
 
+    /*
+     * 적어 둔 훅을 보여 준다 (safety/hooks.js).
+     *
+     * /mcp 와 같은 자리다. 남의 프로그램을 돌리는 것을 켜 놓았으면, 무엇이
+     * 켜져 있는지 볼 화면이 있어야 한다. 없으면 사람은 제가 무엇을 켜 뒀는지
+     * 모른 채로 쓰게 되고, 그건 켠 적 없는 것과 똑같이 위험하다.
+     *
+     * **이번 판이 실제로 들고 있는 것**을 보여 준다. 파일을 다시 읽지 않는다 —
+     * 파일은 대화 도중에 바뀔 수 있고, 그러면 이 화면과 실제로 도는 것이
+     * 달라진다. 화면이 거짓말을 하느니 옛것을 보여 주는 편이 낫다.
+     */
+    case 'hooks':
+    case '훅': {
+      const { 자리들: 훅자리들, 프로젝트자리: 훅프로젝트자리, 이PC자리: 훅이PC자리 } = await import('./safety/hooks.js');
+      const 것들 = ctx?.훅들 ?? [];
+      rule('적어 둔 훅', 70);
+
+      if (!것들.length) {
+        say(`  ${c.gray('걸린 훅이 없습니다.')}`);
+        say('');
+        say(`  ${c.gray('적는 자리 —')} ${c.white(훅프로젝트자리(session.root))} ${c.gray('(이 프로젝트)')}`);
+        say(`  ${c.gray('           ')} ${c.white(훅이PC자리())} ${c.gray('(이 PC 전체)')}`);
+        say(`  ${c.gray('{ "hooks": [ { "때": "도구전", "도구": "Bash", "명령": "python .deel/gate.py" } ] }')}`);
+        say('');
+        say(`  ${c.gray('걸 수 있는 자리 —')} ${c.white(훅자리들.join(' · '))}`);
+        say(`  ${c.yellow('※')} ${c.gray('프로젝트 파일은 믿는 폴더에서만 읽습니다 (deel trust).')}`);
+        say('');
+        return { handled: true };
+      }
+
+      for (const h of 것들) {
+        const 막나 = h.자리 === '도구전' || h.자리 === '말전';
+        say(`  ${c.bold(h.자리)}  ${c.gray(h.무늬글 === '*' ? '(모든 도구)' : h.무늬글)}  ${c.gray(`· ${h.출처}`)}`);
+        say(`      ${c.white(clip(h.명령, 62))}`);
+        say(`      ${c.gray(`${Math.round(h.제한 / 1000)}초 안에 · `)}${막나
+          ? c.gray(h.지나갈까 ? '고장나면 지나감 (적어 두셨습니다)' : '고장나면 막음')
+          : c.gray('여기서는 못 막습니다 — 말만 전합니다')}`);
+      }
+      say('');
+      say(`  ${c.yellow('※')} ${c.gray('훅은 남의 프로그램을 돌립니다 —')} ${c.white(`작업 범위(${session.root}) 를 안 지킵니다.`)}`);
+      say(`  ${c.gray('  무엇이 돌았고 무엇을 막았는지는')} ${c.white('.deel/audit.jsonl')} ${c.gray('에 남습니다.')}`);
+      say(`  ${c.gray('  이번 판만 끄려면')} ${c.white('deel --no-hooks')} ${c.gray('· 아예 끄려면')} ${c.white('DEEL_HOOKS=off')}`);
+      say('');
+      return { handled: true };
+    }
+
+    /*
+     * 이름 붙인 하위 작업을 보여 준다 (agent/agents.js).
+     *
+     * 모델이 보는 것은 이름과 한 줄 설명뿐이다. 사람은 그 아래 — 어느 모드로,
+     * 어느 모델에게, 어떤 도구만 쥐여 주는지 — 를 볼 수 있어야 한다. 그게
+     * 안 보이면 「리뷰어를 시켰는데 왜 파일을 고쳤지」 를 알아낼 길이 없다.
+     */
+    case 'agents':
+    case '에이전트': {
+      const { 자리들: 에자리들 } = await import('./agent/agents.js');
+      const 것들 = ctx?.에이전트들 ?? [];
+      rule('이름 붙인 하위 작업', 70);
+
+      if (!것들.length) {
+        say(`  ${c.gray('정의해 둔 것이 없습니다.')}`);
+        say('');
+        say(`  ${c.gray('적는 자리 —')} ${c.white(에자리들(session.root)[0])} ${c.gray('(이 프로젝트)')}`);
+        say(`  ${c.gray('파일 하나가 이름 하나입니다.')} ${c.white('리뷰어.json')}`);
+        say(`  ${c.gray('{ "설명": "고친 코드를 훑고 위험한 데만 짚는다",')}`);
+        say(`  ${c.gray('  "모드": "inspect", "도구": ["Read", "Grep", "Glob"] }')}`);
+        say('');
+        say(`  ${c.gray('부를 때는')} ${c.white('Task({ agent: "리뷰어", … })')} ${c.gray('— 모델이 이름으로 고릅니다.')}`);
+        say('');
+        return { handled: true };
+      }
+
+      for (const a of 것들) {
+        say(`  ${c.bold(a.이름)}  ${c.gray(`· ${a.출처}`)}`);
+        say(`      ${c.white(clip(a.설명, 62))}`);
+        const 곁들 = [
+          a.모드 ? `모드 ${a.모드}` : null,
+          a.모델 ? `모델 ${a.모델}` : null,
+          a.걸음 ? `${a.걸음}걸음` : null,
+          a.도구?.length ? `도구 ${a.도구.join(' ')}` : null,
+          a.지침 ? `지침 ${a.지침.length}자` : null,
+        ].filter(Boolean);
+        if (곁들.length) say(`      ${c.gray(곁들.join('  ·  '))}`);
+      }
+      say('');
+      say(`  ${c.gray('모델에게는')} ${c.white('Task({ agent: "<이름>", … })')} ${c.gray('로 보입니다 — 이름과 설명만 실립니다.')}`);
+      say(`  ${c.gray('도구는')} ${c.white('줄이기만')} ${c.gray('합니다. 지금 모드가 안 주는 것을 적어 두면 그것만 빠집니다.')}`);
+      say('');
+      return { handled: true };
+    }
+
     case 'thread':
     case '갈래': return 갈래명령(session, ctx, arg), { handled: true };
 
@@ -2794,6 +2915,10 @@ function 연결적용(session, p, ctx = null) {
     kind: p.kind, base: p.baseUrl, auth: p.auth, key: resolveKey(p), model: p.model,
     ctx: p.ctx, maxTokens: p.maxTokens ?? null,
     streaming: p.streaming, tools: p.tools, json: p.json, think: p.think,
+    // 프로필마다 다를 수 있다 — 사내 게이트웨이는 잠잠 상한이 크고 로컬은 작다.
+    잠잠: p.잠잠 ?? p.streamIdleMs ?? 잠잠기본,
+    // 프로필마다 인증서가 다르다. 안 갈아 끼우면 옛 프로필의 신원으로 붙는다.
+    인증서: 인증서설정(p),
     /*
      * ── 이 두 줄이 없어서 회사 토큰이 남의 창구로 나갔다 ────────────────
      *

package/src/completion.js

@@ -41,6 +41,10 @@ export const 명령들 = [
   { 이름: 'audit', 뜻: '무엇을 했는지 기록을 본다', en: 'show the record of what it did' },
   { 이름: '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" },
+  { 이름: 'stats', 뜻: '이 폴더에서 무엇을 했나 (감사기록 요약)', en: 'what happened in this folder (audit summary)' },
+  { 이름: 'config', 뜻: '설정 값이 어디서 왔는지 (config explain <칸>)', en: 'where a config value comes from (config explain <key>)' },
+  { 이름: 'rules', 뜻: '적어 둔 승인 규칙이 진짜 그렇게 도나 확인한다', en: 'check that the approval rules actually do what they say' },
   { 이름: 'scan', 뜻: '게이트웨이에 어떤 모델이 있나 훑는다', en: 'scan the gateway for available models' },
   { 이름: 'sessions', 뜻: '지난 대화 목록', en: 'list past conversations' },
   { 이름: 'ls', 뜻: 'sessions 와 같다', en: 'same as sessions' },
@@ -85,9 +89,15 @@ 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 },
+  { 이름: '--days', 뜻: 'stats 에서 볼 기간(일)', en: 'stats: how many days back', 값: null },
+  { 이름: '--all', 뜻: 'stats 에서 기간을 안 자름', en: 'stats: no time window', 값: false },
+  // 값이 파일이라 셸이 파일을 완성해 줘야 한다. 목록으로 못 준다 —
+  // 스키마 파일 이름은 사람이 짓는 것이라 우리가 알 수가 없다.
+  { 이름: '--output-schema', 뜻: '답을 이 JSON Schema 모양으로', en: 'answer must match this JSON Schema', 값: '파일' },
   { 이름: '--quiet', 뜻: '군말 없이', en: 'no chatter', 값: false },
   { 이름: '--tui', 뜻: '입력 상자를 켠다', en: 'force the input box on', 값: false },
   { 이름: '--no-tui', 뜻: '입력 상자 없이 줄 화면으로', en: 'plain line output, no input box', 값: false },
+  { 이름: '--no-hooks', 뜻: '이번 판만 훅을 끄고 돌린다', en: 'run this once with hooks off', 값: false },
   { 이름: '--continue', 뜻: '지난 대화 이어서', en: 'continue the last conversation', 값: null },
   { 이름: '--resume', 뜻: '고른 대화 이어서', en: 'resume a chosen conversation', 값: null },
   { 이름: '--version', 뜻: '판 번호', en: 'version number', 값: false },
@@ -102,13 +112,32 @@ const 깃발이름만 = () => 깃발들.map((x) => x.이름);
 /** 셸 문자열 안에 그대로 넣어도 되게. 우리 목록은 다 ASCII 라 넉넉하다. */
 const 홑따옴표 = (s) => `'${String(s).replace(/'/g, `'\\''`)}'`;
 
+/*
+ * 파워셸의 홑따옴표는 **셈법이 다르다.**
+ *
+ * bash 는 따옴표를 닫고 이스케이프한 따옴표를 붙였다 다시 여는 식이지만
+ * (`'\''`), 파워셸에서 그 글자열은 그냥 역슬래시와 따옴표다. 파워셸은
+ * 홑따옴표를 **두 번 적어서** 하나로 친다.
+ *
+ * 여태 안 터진 것은 설명 글에 아포스트로피가 하나도 없었기 때문이다.
+ * `read this folder's project config` 한 줄을 넣자마자 스크립트가 통째로
+ * 문법 오류가 났다 — 저장한 사람은 셸을 켤 때마다 빨간 글을 보고, 그게
+ * deel 때문인 줄도 모른다. 아포스트로피를 피해 글을 쓰는 것으로 때우면
+ * 다음에 적는 사람이 같은 데 빠진다. 따옴표는 따옴표 짓는 자리에서 짓는다.
+ */
+const 파워셸따옴표 = (s) => `'${String(s).replace(/'/g, "''")}'`;
+
 function bash판({ zsh = false } = {}) {
   const 값깃발 = 깃발들.filter((x) => Array.isArray(x.값));
   const 폴더깃발 = 깃발들.filter((x) => x.값 === '폴더').map((x) => x.이름);
+  const 파일깃발 = 깃발들.filter((x) => x.값 === '파일').map((x) => x.이름);
   const 값갈래 = 값깃발.map((x) => `    ${x.이름}) COMPREPLY=( $(compgen -W ${홑따옴표(x.값.join(' '))} -- "$cur") ); return 0 ;;`).join('\n');
   const 폴더갈래 = 폴더깃발.length
     ? `    ${폴더깃발.join('|')}) COMPREPLY=( $(compgen -d -- "$cur") ); return 0 ;;`
     : '';
+  const 파일갈래 = 파일깃발.length
+    ? `    ${파일깃발.join('|')}) COMPREPLY=( $(compgen -f -- "$cur") ); return 0 ;;`
+    : '';
 
   return `# deel 탭 완성 (${zsh ? 'zsh' : 'bash'})
 #
@@ -125,6 +154,7 @@ _deel() {
   case "$prev" in
 ${값갈래}
 ${폴더갈래}
+${파일갈래}
     completion) COMPREPLY=( $(compgen -W ${홑따옴표(셸들.join(' '))} -- "$cur") ); return 0 ;;
   esac
 
@@ -179,11 +209,11 @@ complete -F _deel deel
  * (bash·zsh 완성은 설명을 아예 안 보여 주므로 잃는 것이 없다.)
  */
 function 파워셸판() {
-  const 명령목록 = 명령들.map((x) => `    @{ name = ${홑따옴표(x.이름)}; help = ${홑따옴표(x.en)} }`).join('\n');
-  const 깃발목록 = 깃발들.map((x) => `    @{ name = ${홑따옴표(x.이름)}; help = ${홑따옴표(x.en)} }`).join('\n');
+  const 명령목록 = 명령들.map((x) => `    @{ name = ${파워셸따옴표(x.이름)}; help = ${파워셸따옴표(x.en)} }`).join('\n');
+  const 깃발목록 = 깃발들.map((x) => `    @{ name = ${파워셸따옴표(x.이름)}; help = ${파워셸따옴표(x.en)} }`).join('\n');
   const 값목록 = 깃발들
     .filter((x) => Array.isArray(x.값))
-    .map((x) => `    ${홑따옴표(x.이름)} = @(${x.값.map(홑따옴표).join(', ')})`)
+    .map((x) => `    ${파워셸따옴표(x.이름)} = @(${x.값.map(파워셸따옴표).join(', ')})`)
     .join('\n');
 
   // 파워셸은 완성 후보에 설명을 같이 실을 수 있다. 탭을 누르면 뜻이 같이 뜬다.
@@ -210,7 +240,7 @@ ${깃발목록}
   )
   $values = @{
 ${값목록}
-    'completion' = @(${셸들.map(홑따옴표).join(', ')})
+    'completion' = @(${셸들.map(파워셸따옴표).join(', ')})
   }
 
   # Which word comes before the one being typed?

package/src/config.js

@@ -1,4 +1,5 @@
-// 연결 프로필 저장/읽기.  ~/.deel/config.json  (프로젝트 폴더의 .deel/config.json 이 우선)
+// 연결 프로필 저장/읽기.  ~/.deel/config.json 위에 프로젝트의 .deel/config.json 을 겹친다
+// (믿는 폴더일 때만 — safety/trust.js).
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync } from 'node:fs';
@@ -7,6 +8,7 @@ import { 셸정하기 } from './tools/shell.js';
 import { 애저정하기 } from './backend/azure.js';
 import { 정책읽기 } from './safety/policy.js';
 import { 잠그기, 풀기, 잠긴것인가, 쓸수있나, 보관방식 } from './safety/keystore.js';
+import { 믿나, 프로젝트거르기 } from './safety/trust.js';
 
 // 설정이 놓이는 자리.
 //
@@ -33,9 +35,17 @@ function projectDir() {
  */
 export function homeDir() { return userDir(); }
 
+/**
+ * 지금 실제로 쓰는 설정 파일.
+ *
+ * 프로젝트 설정이 있어도 **믿는 폴더일 때만** 그쪽을 준다 (safety/trust.js).
+ * 안 읽는 파일에 쓰지도 않아야 한다 — 안 믿어서 무시한 파일에 `deel setup`
+ * 이 값을 적으면, 다음에 켤 때 그 값이 또 무시된다. 사람은 두 번 적고 두 번
+ * 다 안 먹는 것을 보는데, 그때 무엇 때문인지 알 길이 없다.
+ */
 export function configPath() {
   const local = join(projectDir(), 'config.json');
-  if (existsSync(local)) return local;
+  if (existsSync(local) && 믿나(process.cwd())) return local;
   return join(userDir(), 'config.json');
 }
 
@@ -133,15 +143,82 @@ function 정책덮기(cfg) {
   return cfg;
 }
 
+function 한장읽기(p) {
+  try { return JSON.parse(readFileSync(p, 'utf8')); }
+  catch (err) { throw new Error(`설정 파일을 읽지 못했습니다: ${p}\n  ${err.message}`); }
+}
+
+/*
+ * ── 두 장을 겹친다 ─────────────────────────────────────────────────────
+ *
+ * 예전에는 프로젝트 설정이 있으면 이 PC 설정을 **통째로 안 읽었다.** 그래서
+ * 저장소에 `.deel/config.json` 한 줄만 들어 있어도 그 폴더에서는 프로필이
+ * 하나도 없는 것이 됐다 — 「이 저장소는 code 모드로 연다」 를 적으려던 사람이
+ * 제 게이트웨이를 통째로 잃는다. 그러면 사람은 프로젝트 설정을 안 쓴다.
+ *
+ * 이제 겹친다. 규칙은 하나다 — **좁히는 쪽만 이긴다.** 금지(deny)는 두 장을
+ * 합치고, 허락(allow)은 애초에 프로젝트에서 안 읽는다(safety/trust.js).
+ */
+function 겹치기(집, 방) {
+  const cfg = { ...집, ...방 };
+
+  // 프로필은 이름으로 맞춘다. 통째로 갈아치우면 이 PC 프로필이 사라진다.
+  const 이름표 = new Map((집.profiles ?? []).map((x) => [x?.name, x]));
+  for (const p of 방.profiles ?? []) {
+    if (!p?.name) continue;
+    이름표.set(p.name, { ...(이름표.get(p.name) ?? {}), ...p });
+  }
+  cfg.profiles = [...이름표.values()];
+
+  // 금지는 합친다. 어느 쪽이 적었든 금지는 금지다.
+  const 금지 = [...(집.permissions?.deny ?? []), ...(방.permissions?.deny ?? [])];
+  cfg.permissions = { ...(집.permissions ?? {}), ...(방.permissions ?? {}) };
+  if (금지.length) cfg.permissions.deny = [...new Set(금지)];
+  // 허락은 이 PC 것만. 프로젝트가 적었어도 위에서 이미 걸러졌지만, 겹치는
+  // 자리에서 한 번 더 못 박는다 — 이 한 줄이 없으면 나중에 누가 프로젝트에
+  // allow 를 허용하도록 고쳤을 때 아무 데서도 안 걸린다.
+  if (Array.isArray(집.permissions?.allow)) cfg.permissions.allow = 집.permissions.allow;
+  else delete cfg.permissions.allow;
+  return cfg;
+}
+
+let 신뢰소식 = null;   // 프로젝트 설정에 대해 할 말. 한 번 읽으면 지워진다.
+
+/**
+ * 프로젝트 설정을 안 읽었거나 일부를 걷어냈으면 그것을 알려 준다.
+ *
+ * 조용히 무시하면 안 된다 — 적어 둔 사람은 걸린 줄 알고, 실제로는 안 걸린
+ * 채로 일이 돈다. 그 어긋남이 설정 전체를 못 믿게 만든다.
+ *
+ * @returns {{갈래:'안믿음', 자리:string, 폴더:string}
+ *          |{갈래:'걸러냄', 자리:string, 걸러낸것:Array<{칸:string,왜:string}>}
+ *          |null}
+ */
+export function 프로젝트설정소식() { const s = 신뢰소식; 신뢰소식 = null; return s; }
+
 function 읽기() {
-  const p = configPath();
-  if (!existsSync(p)) return structuredClone(EMPTY);
-  try {
-    const raw = JSON.parse(readFileSync(p, 'utf8'));
-    return { ...structuredClone(EMPTY), ...raw };
-  } catch (err) {
-    throw new Error(`설정 파일을 읽지 못했습니다: ${p}\n  ${err.message}`);
+  const 집파일 = join(userDir(), 'config.json');
+  const 방파일 = join(projectDir(), 'config.json');
+  const 집 = existsSync(집파일)
+    ? { ...structuredClone(EMPTY), ...한장읽기(집파일) }
+    : structuredClone(EMPTY);
+  if (!existsSync(방파일)) return 집;
+
+  /*
+   * 안 믿는 폴더의 설정은 **안 읽는다.**
+   *
+   * 이 파일은 저장소에 딸려 온다. 남의 저장소 하나를 받은 것만으로 오간 말이
+   * 다른 주소로 가고, 열쇠받기 명령이 이 계정 권한으로 도는 길이 여기다.
+   * 그 명령은 도구 승인 화면보다 **앞**이라 어떤 승인 정책으로도 안 걸린다.
+   */
+  if (!믿나(process.cwd())) {
+    신뢰소식 = { 갈래: '안믿음', 자리: 방파일, 폴더: process.cwd() };
+    return 집;
   }
+
+  const { 값: 방, 걸러낸것 } = 프로젝트거르기(한장읽기(방파일));
+  if (걸러낸것.length) 신뢰소식 = { 갈래: '걸러냄', 자리: 방파일, 걸러낸것 };
+  return 겹치기(집, 방);
 }
 
 export function save(cfg, { toProject = false } = {}) {

package/src/configexplain.js

@@ -0,0 +1,177 @@
+// `deel config explain <칸>` — 이 값은 **어디서 왔나**.
+//
+// ── 왜 필요한가 ────────────────────────────────────────────────────────
+//
+// 설정을 읽는 자리가 넷이다 — 관리 정책 · 환경변수 · 프로젝트 설정 · 이 PC
+// 설정. 겹치는 규칙은 문서에 적어 두었지만, 문서를 읽는 것과 **지금 이 자리에서
+// 무엇이 이겼는지 아는 것**은 다른 일이다.
+//
+// 막히는 모양은 늘 같다. 파일에 분명히 적어 놨는데 안 먹는다. 그러면 사람은
+// 그 파일을 고치고, 또 고치고, 결국 설정이라는 것을 안 믿게 된다. 실제로 값을
+// 쥐고 있던 것은 환경변수 하나이거나, 프로젝트 설정을 안 믿는 폴더여서
+// 읽지도 않은 것이다. 둘 다 **말해 주면 5초에 끝나는** 일이다.
+//
+// 그래서 층을 하나씩 열어서 「이 칸을 적어 둔 곳」 을 다 보여 주고, 어느 것이
+// 이겼는지 표시한다. 값이 겹칠 때만 쓸모 있는 화면이 아니라, **아무 데도 안
+// 적혀 있다**는 것을 보여 줄 때도 똑같이 쓸모 있다.
+//
+// ── 비밀은 안 보여 준다 ────────────────────────────────────────────────
+//
+// 열쇠 칸(apiKey)은 값을 안 적고 「적혀 있음」 만 적는다. 이 화면은 그대로
+// 캡처되어 사내 메신저로 간다.
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homeDir } from './config.js';
+import { 믿나 } from './safety/trust.js';
+import { 정책읽기, 정책자리 } from './safety/policy.js';
+
+/** 값을 안 보여 줄 칸. 이름만 봐도 알 수 있는 것만 넣는다. */
+const 가릴칸 = new Set(['apiKey', 'key', 'passphrase', '암호']);
+
+/**
+ * 이 칸을 정할 수 있는 환경변수.
+ *
+ * 손으로 적는다. 자동으로 긁으면 「무엇이 이 칸을 이길 수 있나」 가 코드를
+ * 읽어야만 아는 것이 되는데, 그건 이 명령이 없애려는 바로 그 상태다.
+ */
+const 환경변수 = {
+  apiKey: ['DEEL_API_KEY', 'DEEL_KEY_<프로필ID>'],
+  shell: ['DEEL_SHELL'],
+  offline: [],
+  proxy: ['HTTPS_PROXY', 'HTTP_PROXY', 'ALL_PROXY', 'NO_PROXY'],
+  lang: ['DEEL_LANG'],
+};
+
+/*
+ * 비밀 칸의 값은 **읽는 자리에서** 바꿔치기한다.
+ *
+ * 그리는 자리에서만 가리면 `--json` 이 날것을 그대로 낸다. 그 출력은
+ * 파이프를 타고 로그로, 사내 티켓으로 간다 — 화면만 가려 놓고 안전하다고
+ * 하는 것이 이런 자리에서 제일 흔한 사고다.
+ */
+export const 비밀표시 = '(적혀 있음 — 값은 안 보여 줍니다)';
+const 지운값 = (칸, v) => (v !== undefined && 가릴칸.has(칸) ? 비밀표시 : v);
+
+const 값보이기 = (칸, v) => {
+  if (v === undefined) return null;
+  if (v === null) return 'null';
+  if (typeof v === 'object') return JSON.stringify(v);
+  return String(v);
+};
+
+/**
+ * 한 칸이 어느 층에 적혀 있나.
+ *
+ * @param {string} 칸  `offline` 처럼 맨 위 칸, 또는 `profiles.사내.model` 처럼
+ *                     프로필 안의 칸
+ * @returns {{칸:string, 층들:Array, 이긴층:object|null, 환경변수:string[]}}
+ */
+export function 설명(칸, { root = process.cwd(), env = process.env } = {}) {
+  const 조각 = String(칸 ?? '').split('.').filter(Boolean);
+  const 층들 = [];
+
+  const 파일읽기 = (자리) => {
+    if (!existsSync(자리)) return { 있나: false };
+    try { return { 있나: true, 값: JSON.parse(readFileSync(자리, 'utf8')) }; }
+    catch (err) { return { 있나: true, 탈: err?.message ?? String(err) }; }
+  };
+
+  const 파고들기 = (덩이) => {
+    let 여기 = 덩이;
+    for (let i = 0; i < 조각.length; i++) {
+      if (여기 == null || typeof 여기 !== 'object') return undefined;
+      const 이름 = 조각[i];
+      /*
+       * `profiles.<이름>.<칸>` 은 배열을 이름으로 뒤진다.
+       *
+       * 사람이 설정에서 프로필을 부르는 이름은 배열 번호가 아니라 name 이다.
+       * 번호로 적게 하면 프로필 하나를 지웠을 때 이 명령이 조용히 딴 것을
+       * 가리킨다.
+       */
+      if (Array.isArray(여기)) {
+        여기 = 여기.find((x) => x?.name === 이름 || x?.id === 이름);
+        continue;
+      }
+      여기 = 여기[이름];
+    }
+    return 여기;
+  };
+
+  const 끝칸이름지금 = 조각[조각.length - 1] ?? '';
+
+  // ── 1. 이 PC 설정 (제일 아래) ───────────────────────────────────────
+  const 집자리 = join(homeDir(), 'config.json');
+  const 집 = 파일읽기(집자리);
+  if (집.있나) {
+    층들.push({
+      층: '이 PC 설정', 자리: 집자리, 읽나: !집.탈,
+      값: 집.탈 ? undefined : 지운값(끝칸이름지금, 파고들기(집.값)), 탈: 집.탈 ?? null,
+    });
+  }
+
+  // ── 2. 프로젝트 설정 (믿는 폴더에서만) ──────────────────────────────
+  const 방자리 = join(root, '.deel', 'config.json');
+  if (existsSync(방자리)) {
+    const 믿나결과 = 믿나(root);
+    const 방 = 파일읽기(방자리);
+    층들.push({
+      층: '프로젝트 설정', 자리: 방자리, 읽나: 믿나결과 && !방.탈,
+      값: 방.탈 ? undefined : 지운값(끝칸이름지금, 파고들기(방.값)), 탈: 방.탈 ?? null,
+      // 읽지도 않는 파일에 적어 둔 것이 이 화면에서 제일 자주 나오는 답이다.
+      왜못읽나: 믿나결과 ? null : '믿는 폴더가 아닙니다 (deel trust)',
+    });
+  }
+
+  // ── 3. 환경변수 ─────────────────────────────────────────────────────
+  const 끝칸 = 조각[조각.length - 1] ?? '';
+  const 볼환경 = 환경변수[끝칸] ?? [];
+  const 켜진환경 = 볼환경.filter((이름) => !이름.includes('<') && env[이름]);
+  if (켜진환경.length) {
+    층들.push({
+      층: '환경변수', 자리: 켜진환경.join(' · '), 읽나: true,
+      값: 지운값(끝칸, env[켜진환경[0]]),
+    });
+  }
+
+  // ── 4. 관리 정책 (제일 위) ──────────────────────────────────────────
+  const 정책 = 정책읽기({ env, 다시: true });
+  if (정책.값 && typeof 정책.값 === 'object') {
+    const 그값 = 정책.값[끝칸];
+    if (그값 !== undefined) {
+      층들.push({ 층: '관리 정책', 자리: 정책.곳 ?? 정책자리(env)[0], 읽나: true, 값: 지운값(끝칸, 그값) });
+    }
+  }
+
+  // 이긴 층 — 뒤에 온 것이 이긴다. 다만 **읽는 층** 중에서만 고른다.
+  const 쓸수있는것 = 층들.filter((x) => x.읽나 && x.값 !== undefined);
+  const 이긴층 = 쓸수있는것.length ? 쓸수있는것[쓸수있는것.length - 1] : null;
+
+  return { 칸, 층들, 이긴층, 환경변수: 볼환경 };
+}
+
+/** 화면에 그릴 줄들. 색은 부르는 쪽이 입힌다. */
+export function 설명줄들(r) {
+  const 줄 = [];
+  if (r.이긴층) 줄.push({ 갈래: '값', 글: `${값보이기(끝칸이름(r.칸), r.이긴층.값)}`, 곁: `${r.이긴층.층}` });
+  else 줄.push({ 갈래: '없음', 글: '아무 데도 안 적혀 있습니다 (기본값으로 돕니다)', 곁: null });
+
+  for (const 층 of r.층들) {
+    const 값 = 값보이기(끝칸이름(r.칸), 층.값);
+    줄.push({
+      갈래: 층 === r.이긴층 ? '이김' : (층.읽나 ? '아래' : '안읽음'),
+      글: `${층.층}`,
+      곁: [
+        층.자리,
+        값 !== null ? `= ${값}` : '(이 칸은 없음)',
+        층.왜못읽나 ? `— ${층.왜못읽나}` : null,
+        층.탈 ? `— 못 읽었습니다: ${층.탈}` : null,
+      ].filter(Boolean).join('  '),
+    });
+  }
+  if (r.환경변수.length) {
+    줄.push({ 갈래: '참고', 글: '이 칸을 이길 수 있는 환경변수', 곁: r.환경변수.join(' · ') });
+  }
+  return 줄;
+}
+
+const 끝칸이름 = (칸) => String(칸 ?? '').split('.').filter(Boolean).pop() ?? '';