deel-local-cli 1.16.0 → 1.17.2

package/src/backend/probe.js

@@ -12,6 +12,7 @@ import {
   assistantMessage, toolMessage,
 } from './adapter.js';
 import { 벤더 } from './toolfit.js';
+import { 세션이름짓기 } from './wire.js';
 import { 말 } from '../i18n/index.js';
 
 const READ_TOOL = {
@@ -96,6 +97,19 @@ const SKIPPED = [
   ['ctx', '컨텍스트 길이'],
 ];
 
+/**
+ * 이 진단 한 번을 가리키는 번호.
+ *
+ * agent/store.js 의 대화 번호와 **같은 모양**으로 짓는다(YYYYMMDD-HHMMSS).
+ * 모양이 다르면 세션이름짓기 가 안전한 꼴이 아니라고 보고 지문으로 바꾸는데,
+ * 지문은 사람이 대시보드에서 「아까 그 진단」 을 못 찾게 만든다.
+ */
+function 진단번호(at = new Date()) {
+  const 두 = (n) => String(n).padStart(2, '0');
+  return `${at.getFullYear()}${두(at.getMonth() + 1)}${두(at.getDate())}`
+    + `-${두(at.getHours())}${두(at.getMinutes())}${두(at.getSeconds())}`;
+}
+
 export async function probe(conn, onStep = () => {}) {
   const { kind: shape, base, auth, model } = conn;
   const key = conn.key ?? '';
@@ -106,7 +120,19 @@ export async function probe(conn, onStep = () => {}) {
    * 멀쩡해도 그렇다. 진단 화면은 그 400 을 「연결 실패」 로 적고, 사람은
    * 열쇠를 다시 받으러 간다 — 여덟 칸이 전부 그 한 줄 때문에 빨개진다.
    */
-  const H = () => headersFor(auth, key, 더할머리(shape));
+  /*
+   * 진단도 **제 이름을 달고 나간다.**
+   *
+   * 여기서 나가는 것은 여덟아홉 번의 진짜 채팅 완성이다. 이름이 없으면
+   * 게이트웨이가 그 하나하나를 새 대화로 연다 — 대시보드에는 정체 모를
+   * 단발 요청이 아홉 줄 쌓이고, 그 줄들은 무엇을 하다 생긴 것인지 아무도
+   * 모른다. 「붙는지 봤다」 와 「누가 몰래 두드렸다」 가 화면에서 같아진다.
+   *
+   * 대화가 아니므로 이어받을 이름이 없다. 이 진단 한 번을 한 대화로 묶는
+   * 이름을 여기서 짓는다 — 담기는 것은 여전히 번호 하나뿐이다.
+   */
+  const 진단이름 = 세션이름짓기(진단번호());
+  const H = () => headersFor(auth, key, 더할머리(shape, 진단이름));
   /*
    * 물음표 뒤를 끝에 남겨야 한다 (adapter.js 의 주소붙이기).
    *

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';
@@ -242,6 +244,18 @@ export async function handle(line, session, ctx) {
       // 물어보러 가는 자리에도 전선 카드를 달아 준다 (backend/wire.js) —
       // 없으면 이 한 번만 생각 칸이 짐작으로 나가고, Opus 5 계열에서는 400 이다.
       전선붙이기(새conn, ctx?.배움);
+      /*
+       * 대화 이름도 이어받는다.
+       *
+       * 이건 남에게 한 번 물어보는 것이지 **다른 대화가 아니다.** 안 옮기면
+       * 게이트웨이가 이 한 번을 새 대화로 열고, 대시보드에서는 진행 중인
+       * 대화와 아무 관계 없는 줄로 떨어져 나간다 — 나중에 「이 답이 어디서
+       * 나왔나」 를 따라갈 실이 끊긴다.
+       *
+       * conn 을 새로 짓는 자리는 언제나 이걸 빠뜨린다. 열쇠받기·vision 을
+       * 연결적용()에서 빠뜨렸던 것과 같은 자리다.
+       */
+      새conn.세션이름 = session.세션이름 ?? null;
       const 알림 = 알릴말(session.conn, 새conn);
       say('');
       say(알림.밖으로
@@ -1036,6 +1050,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 +1293,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 +1330,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 +2927,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 } = {}) {