deel-local-cli 1.5.7 → 1.6.0

package/src/oneshot.js

@@ -11,13 +11,16 @@
 //   그래서 '묻는 자리' 를 전부 없앤 길을 따로 낸다. 에이전트 루프는 그대로 쓴다 —
 //   여기서 루프를 다시 짜면 두 벌이 되고, 언젠가 한쪽만 고쳐진다.
 import { c, mark, clip } from './ui/ansi.js';
+import { 규칙모으기 } from './safety/policy.js';
 import { run } from './agent/loop.js';
 import { Session } from './agent/session.js';
 import { makeScope } from './safety/guard.js';
 import { 모두끄기 as 언어서버다끄기 } from './lsp/client.js';
 import { History } from './safety/undo.js';
 import { Audit } from './safety/audit.js';
-import { activeProfile, load, resolveKey } from './config.js';
+import { activeProfile, load, resolveKey, 잠금소식 } from './config.js';
+import { 말 as 옮긴말 } from './i18n/index.js';
+import { 알림채움 } from './backend/retry.js';
 import { discover } from './skills/discover.js';
 import { allowEndpoint, setOffline } from './safety/network.js';
 import { probeCtx, 기본값 as CTX_DEFAULT } from './backend/ctxsize.js';
@@ -123,7 +126,7 @@ export async function runOnce(opts = {}) {
     삐끗(`  ${c.red('✗')} ${message}`);
     return 내놓기({
       ok: false, reason, code: EXIT.error, text: '', why: message,
-      tools: 0, steps: 0, usage: { in: 0, out: 0, calls: 0, ms: 0 }, ms: 0,
+      tools: 0, steps: 0, usage: { in: 0, out: 0, calls: 0, ms: 0, retries: 0 }, ms: 0,
     });
   };
 
@@ -140,6 +143,11 @@ export async function runOnce(opts = {}) {
   const prof = activeProfile(cfg);
   if (!prof) return 못함('no-config', '저장된 연결이 없습니다. deel setup 을 먼저 실행하세요.');
 
+  // 열쇠를 방금 잠갔으면 알린다. 여기서는 stdout 을 안 쓴다 —
+  // 배치로 부르는 쪽이 stdout 을 JSON 으로 읽고 있을 수 있다.
+  const 잠금 = 잠금소식();
+  if (잠금) { try { process.stderr.write(`  ${잠금}\n`); } catch { /* 못 써도 그만 */ } }
+
   const root = opts.root ? String(opts.root) : process.cwd();
   const conn = {
     kind: prof.kind, base: prof.baseUrl, auth: prof.auth,
@@ -149,12 +157,14 @@ export async function runOnce(opts = {}) {
     maxTokens: opts.maxTokens ?? prof.maxTokens ?? null,
     streaming: prof.streaming ?? false,
     tools: prof.tools ?? false, json: prof.json ?? false, think: prof.think ?? false,
+    vision: prof.vision ?? false,
   };
 
   // 자물쇠는 대화 화면과 똑같이 건다. 비대화라고 느슨해질 이유가 없다 —
   // 오히려 배치는 아무도 안 보는 자리라 더 단단해야 한다.
   allowEndpoint(conn.base);
-  if (opts.offline ?? prof.offline) setOffline(true);
+  // 관리 정책이 offline 을 못박아 뒀으면 옵션과 상관없이 켠다 (safety/policy.js).
+  if (opts.offline ?? prof.offline ?? cfg?.offline) setOffline(true);
 
   const session = new Session(conn, {
     root,
@@ -185,6 +195,10 @@ export async function runOnce(opts = {}) {
     // 도구가 한 번에 돌려줄 양을 이 값에서 뽑는다 (agent/budget.js).
     // /model 로 갈아타면 conn 이 통째로 바뀌므로 그때마다 다시 읽는다.
     get 모델컨텍스트() { return conn.ctx ?? null; },
+    // 이 모델이 그림을 볼 수 있나 — Read 가 그림을 만났을 때 무슨 말을 할지가 여기서 갈린다.
+    get 눈있나() { return !!conn.vision; },
+    // 적어 둔 허락·금지 규칙 (safety/policy.js). 승인 모드보다 먼저 본다.
+    규칙들: 규칙모으기(cfg),
     history: new History(root),
     audit: new Audit(root),
     seen: new Set(),
@@ -337,10 +351,20 @@ export async function runOnce(opts = {}) {
           곁(`  ${c.yellow('↻')} ${c.gray(`${ev.why} — 상한을 ${ev.from} → ${ev.to} 로 올려 다시 부릅니다`)}`);
           break;
 
+        // 서버가 잠깐 막아서 기다렸다 다시 부른 자리 (backend/retry.js).
+        // 배치 기록에 남아야 "그날 밤 왜 12분이 걸렸나" 를 나중에 읽을 수 있다.
+        case 'backoff':
+          곁(`  ${c.yellow('↻')} ${c.gray(옮긴말('loop.backoff', 알림채움(ev)))}`);
+          break;
+
         case 'folded':
           곁(`  ${c.cyan('◲')} ${c.gray(`오래된 도구 결과 ${ev.접은것}개를 접었습니다 (${ev.아낀토큰.toLocaleString()} 토큰을 비움)`)}`);
           break;
 
+        case 'images_folded':
+          곁(`  ${c.cyan('◲')} ${c.gray(`오래된 그림 ${(ev.뺀것들 ?? []).reduce((a3, x) => a3 + x.장수, 0)}장을 뺐습니다`)}`);
+          break;
+
         case 'compacted':
           곁(`  ${c.cyan('◱')} ${c.gray(`대화 ${ev.folded}개를 요약으로 접었습니다 (${ev.before.toLocaleString()} → ${ev.after.toLocaleString()} 토큰)`)}`);
           break;
@@ -405,6 +429,7 @@ export async function runOnce(opts = {}) {
     usage: {
       in: session.usage.in, out: session.usage.out,
       calls: session.usage.calls, ms: session.usage.ms,
+      retries: session.usage.retries ?? 0,
     },
     model: conn.model,
     ms: Date.now() - t0,

package/src/pack/sbom.js

@@ -24,6 +24,7 @@
 // 검사에서 확인한다 (test/sbom.test.js) — Audit 이 실제로 남긴 줄에 여기
 // 적어 둔 칸이 다 있는지 본다.
 import { randomUUID } from 'node:crypto';
+import { 보관방식 } from '../safety/keystore.js';
 
 /** 우리가 내놓는 SBOM 규격. 스캐너가 이 숫자를 보고 읽는 법을 정한다. */
 export const CDX판 = '1.5';
@@ -102,6 +103,7 @@ export function 통신명세(a) {
         어디로: 'deel setup 에서 정한 주소 딱 한 곳',
         무엇이: '오간 말과, 모델이 읽은 파일 내용',
         막는법: 'src/safety/network.js 가 요청마다 허용 목록을 확인합니다. 목록에 없으면 요청 자체를 만들지 않습니다.',
+        프록시: 'HTTPS_PROXY(또는 설정의 proxy)가 있으면 그 프록시를 거칩니다(CONNECT 터널). 목적지 허용 목록은 그대로이고, 이 컴퓨터 안 주소는 프록시를 안 탑니다.',
         소스: 자리('net'),
       },
       {
@@ -146,6 +148,28 @@ export function 통신명세(a) {
   };
 }
 
+/**
+ * 열쇠를 어디에 어떻게 두나.
+ *
+ * 심사에서 거의 언제나 나오는 질문이고, 전에는 이 문서에 답이 없었다.
+ * "홈 폴더에 평문" 이면 그 자리에서 끝나는 질문이라 더 그렇다.
+ * 지금 이 PC 에서 실제로 되는 방식을 그대로 적는다 — 되는 척은 안 한다.
+ */
+export function 열쇠명세() {
+  return {
+    어디: '~/.deel/config.json (또는 DEEL_HOME) 의 profiles[].apiKey',
+    이PC에서: 보관방식(),
+    방식: [
+      { 운영체제: '윈도우', 방법: 'DPAPI ProtectedData (CurrentUser) — 이 PC 의 이 계정만 풉니다. 파일을 복사해 가도 못 풉니다.' },
+      { 운영체제: '맥', 방법: '로그인 키체인 (security add-generic-password)' },
+      { 운영체제: '그 밖', 방법: '파일 권한 0600. 잠금장치가 없으므로 그렇게 적습니다.' },
+    ],
+    넘길때: '열쇠는 명령줄에 안 올립니다 — 언제나 stdin 으로 넘깁니다. 같은 PC 의 다른 사용자가 프로세스 목록으로 못 봅니다.',
+    안쓰려면: 'DEEL_API_KEY (또는 DEEL_KEY_<프로필>) 환경변수를 쓰면 파일에 아예 안 남습니다. 환경변수가 파일보다 우선합니다.',
+    끄려면: 'DEEL_KEYSTORE=off — 잠금장치를 안 씁니다(파일 권한만).',
+  };
+}
+
 /**
  * 감사기록 사양.
  *
@@ -201,6 +225,7 @@ export function 심사명세(a, { at = new Date() } = {}) {
         : '외부 모듈이 있습니다 — 위 목록을 확인하세요.',
     },
     통신: 통신명세(a),
+    열쇠보관: 열쇠명세(),
     감사기록: 감사명세(),
     파일: a.files.map((f) => ({ 경로: f.path, 바이트: f.bytes, sha256: f.sha })),
   };

package/src/pack/selfpack.js

@@ -45,8 +45,10 @@ const sha256 = (buf) => createHash('sha256').update(buf).digest('hex');
 // 앞에 점이나 글자가 붙은 것은 뺀다. 그러지 않으면 정규식의 .exec( 까지
 // '외부 명령 실행' 으로 세어 심사서가 거짓말을 한다.
 const PROBES = [
-  { id: 'net', label: '네트워크 요청', re: /(?<![.\w])fetch\s*\(/g,
-    note: '사용자가 setup 에서 넣은 주소로만 나갑니다' },
+  // fetch 말고도 http.js 의 프록시 터널(httpRequest·httpsRequest·tlsConnect)이 있다.
+  // 그것을 안 세면 심사서가 "네트워크 요청 N건" 을 거짓으로 적는다.
+  { id: 'net', label: '네트워크 요청', re: /(?<![.\w])fetch\s*\(|(?:globalThis|window|self)\s*\.\s*fetch\s*\(|\bnew\s+WebSocket\s*\(|(?<![.\w])(?:httpRequest|httpsRequest|tlsConnect)\s*\(/g,
+    note: '사용자가 setup 에서 넣은 주소로만 나갑니다 (HTTPS_PROXY 가 있으면 그 프록시를 거쳐서)' },
   { id: 'exec', label: '외부 명령 실행', re: /(?<![.\w])(execFile|execFileSync|execSync|spawn|spawnSync|exec)\s*\(/g,
     note: '사용자·모델이 지시한 명령, 그리고 플러그인 받을 때의 git' },
   { id: 'listen', label: '포트 열기', re: /(?<![.\w])(createServer)\s*\(/g,
@@ -83,7 +85,8 @@ const MODULE_NAME = /^[@\w./:-]+$/;
 
 export function importSpecs(text) {
   const out = [];
-  const re = /(?:^|[\s;{(])(?:import[^'"()]*from\s*|import\s*|require\s*\(\s*)(['"])([^'"]+)\1/g;
+  // 동적으로 부르는 import 도 문이다 — from 이 없어서 못 잡던 것을 잡는다.
+  const re = /(?:^|[\s;{(])(?:import[^'"()]*from\s*|import\s*\(\s*|import\s*|require\s*\(\s*)(['"])([^'"]+)\1/g;
   for (const m of text.matchAll(re)) {
     const spec = m[2];
     if (MODULE_NAME.test(spec)) out.push(spec);
@@ -171,6 +174,9 @@ export function reviewSheet(a, at) {
   L.push('       · 그 한 자리만 허용 목록에 오릅니다. 모델을 바꾸면 앞의 자리는 닫힙니다.');
   L.push('       · src/safety/network.js 가 요청마다 확인하고, 목록에 없으면 요청 자체를');
   L.push('         만들지 않습니다.');
+  L.push('       · HTTPS_PROXY(또는 설정의 proxy)가 있으면 그 프록시를 **거쳐** 갑니다 (CONNECT');
+  L.push('         터널). 목적지는 그대로 그 한 자리이고, 거치는 프록시는 켤 때 화면과 /status 에');
+  L.push('         적힙니다. 이 컴퓨터 안(127.*, localhost)으로 가는 요청은 프록시를 안 탑니다.');
   L.push('');
   L.push('   [B] 웹 읽기 (WebFetch 도구) — 받아 오기만 하는 길');
   L.push('       · GET 만 씁니다. 본문을 실어 보내지 않습니다 (소스·대화가 나갈 수 없음).');

package/src/plugins/manage.js

@@ -11,7 +11,19 @@ import {
 } from 'node:fs';
 import { untargz, stripTop } from '../pack/tar.js';
 import { makeZip } from '../pack/zip.js';
-import { allowTemporarily, checkUrl, isOffline } from '../safety/network.js';
+import { allowTemporarily, isOffline, NetBlocked } from '../safety/network.js';
+import { 원시요청, 몸읽기 } from '../backend/http.js';
+
+/**
+ * 플러그인을 받다 되돌림(redirect)이 오면 따라가도 되는 곳인가. 던지면 안 따라간다.
+ * github 가 제 다른 집으로 보내는 것만 따라간다 — https 이고, github.com · githubusercontent.com 뿐.
+ */
+export function 플러그인되돌림(다음) {
+  if (다음.protocol !== 'https:') throw new Error(`${다음.protocol} 로 되돌립니다 — 따라가지 않습니다`);
+  if (!/(^|\.)github\.com$|(^|\.)githubusercontent\.com$/i.test(다음.hostname)) {
+    throw new Error(`github 밖(${다음.hostname})으로 되돌립니다 — 따라가지 않습니다`);
+  }
+}
 import { copyDir } from '../tools/fsutil.js';
 
 export const pluginsDir = (home = homedir()) => join(home, '.deel', 'plugins');
@@ -63,12 +75,27 @@ async function fetchInto(spec, dest, onStep) {
     const url = `https://codeload.github.com/${spec.owner}/${spec.repo}/tar.gz/refs/heads/${branch}`;
     // 사용자가 이 명령을 친 동안만 github 를 연다. 끝나면 바로 닫는다.
     const close = allowTemporarily(url);
-    let res;
-    try { checkUrl(url); res = await fetch(url, { signal: AbortSignal.timeout(120000) }); }
-    catch (err) { continue; }
-    finally { close(); }
-    if (!res.ok) continue;
-    const gz = Buffer.from(await res.arrayBuffer());
+    let gz;
+    // 한 문(backend/http.js)으로 나간다 — 프록시를 거치고, 되돌림은 홉마다 문지기를 지난다.
+    // github 는 받기 주소를 제 다른 집(githubusercontent 등)으로 되돌리므로 그 홉은 열어 준다 —
+    // 그 밖의 집이면 안 따라가고, 왜 못 받았는지를 말한다 (조용히 '주소를 확인하세요' 로 끝내지 않는다).
+    // 상한까지만 받는다. 플러그인 묶음이 64MB 를 넘을 일은 없고, 넘는 것을 다 받아 줄 이유도 없다.
+    const 열어둔 = [];
+    try {
+      const res = await 원시요청(url, {
+        timeout: 120000, stream: true,
+        되돌림: (다음) => { 플러그인되돌림(다음); 열어둔.push(allowTemporarily(다음.origin)); },
+      });
+      if (!res.ok) { await res.버리기?.(); continue; }
+      gz = await 몸읽기(res.res.body, 64 * 1024 * 1024);
+    } catch (err) {
+      if (err instanceof NetBlocked || /되돌립니다/.test(String(err?.message))) return { error: `받지 못했습니다 — ${err.message}` };
+      continue;
+    } finally {
+      close();
+      for (const 닫기 of 열어둔) 닫기();
+    }
+    if (!gz) return { error: '받은 묶음이 너무 큽니다 (64MB 넘음) — 플러그인 저장소가 맞는지 확인하세요' };
     const files = stripTop(untargz(gz));
     if (!files.length) return { error: '받은 묶음이 비어 있습니다' };
     rmSync(dest, { recursive: true, force: true });

package/src/repl.js

@@ -1,5 +1,7 @@
 // 대화 화면. 루프가 보내는 이벤트를 Claude Code 풍으로 그린다.
 import { createInterface, emitKeypressEvents } from 'node:readline';
+import { 규칙모으기 } from './safety/policy.js';
+import { 주소가리기 } from './safety/secrets.js';
 import { homedir } from 'node:os';
 import { resolve, basename } from 'node:path';
 import { c, say as 바로쓰기, mark, clip } from './ui/ansi.js';
@@ -7,6 +9,7 @@ import { headerLines } from './ui/status.js';
 import { 종, 창제목, 제목되돌리기, 알릴까, 제목글 } from './ui/notify.js';
 import { 보이기 as 인트로, 기본곁말 } from './ui/intro.js';
 import { 언어잡기, 말 as 옮긴말 } from './i18n/index.js';
+import { 알림채움 } from './backend/retry.js';
 import { 화면고르기 } from './ui/screen.js';
 import { STAGES } from './agent/effort.js';
 import { handle, COMMANDS, 미리보기끄기, 적용하기 as 그림적용 } from './commands.js';
@@ -19,7 +22,7 @@ import { 언어서버있나 } from './tools/index.js';
 import { 모두끄기 as 언어서버다끄기 } from './lsp/client.js';
 import { History } from './safety/undo.js';
 import { Audit } from './safety/audit.js';
-import { activeProfile, load, resolveKey, save as saveCfg, homeDir } from './config.js';
+import { activeProfile, load, resolveKey, save as saveCfg, homeDir, 잠금소식 } from './config.js';
 import { discover } from './skills/discover.js';
 import { allowEndpoint, setOffline, isOffline, isLocalHost } from './safety/network.js';
 import { Store, latest, prune } from './agent/store.js';
@@ -36,6 +39,7 @@ import { 접어쓰기 } from './ui/wrap.js';
 import { probeCtx, 기본값 as CTX_DEFAULT } from './backend/ctxsize.js';
 import { renderDiff, shortStat } from './ui/diff.js';
 import { expand as expandMentions } from './agent/mention.js';
+import { 크기말 } from './backend/vision.js';
 import { 다붙이기 } from './backend/mcp.js';
 import { 읽기 as 기억읽기 } from './agent/memory.js';
 import { 갈래고르기 } from './ui/working.js';
@@ -150,6 +154,14 @@ export async function chatLoop(opts = {}) {
     return 1;
   }
 
+  // 평문으로 있던 열쇠를 방금 잠갔으면 그렇다고 한 줄. 조용히 바꾸면
+  // 나중에 설정 파일을 열어 본 사람이 제 열쇠가 사라진 줄 안다.
+  const 잠금 = 잠금소식();
+  if (잠금) {
+    바로쓰기('');
+    바로쓰기(`  ${mark.ok} ${잠금}`);
+  }
+
   /*
    * 여기서부터 화면에 나가는 것은 전부 `화면` 을 거친다.
    *
@@ -178,11 +190,14 @@ export async function chatLoop(opts = {}) {
     maxTokens: opts.maxTokens ?? prof.maxTokens ?? null,
     streaming: prof.streaming ?? false,
     tools: prof.tools ?? false, json: prof.json ?? false, think: prof.think ?? false,
+    // 그림을 볼 수 있는 모델인지. 못 보면 바이트를 아예 안 싣는다 (backend/vision.js).
+    vision: prof.vision ?? false,
   };
 
   // 이 자리 하나만 연다. 다른 어디로도 나가지 못한다.
   allowEndpoint(conn.base);
-  if (opts.offline ?? prof.offline) setOffline(true);
+  // 관리 정책이 offline 을 못박아 뒀으면 옵션과 상관없이 켠다 (safety/policy.js).
+  if (opts.offline ?? prof.offline ?? cfg?.offline) setOffline(true);
 
   /*
    * ── 끝났을 때 알리기 ─────────────────────────────────────────────────
@@ -259,7 +274,7 @@ export async function chatLoop(opts = {}) {
     }
   }
   if (!store) store = new Store(root);
-  store.begin({ model: conn.model, base: conn.base, root });
+  store.begin({ model: conn.model, base: 주소가리기(conn.base), root });
   try { prune(root); } catch {}
 
   /*
@@ -361,6 +376,15 @@ export async function chatLoop(opts = {}) {
    * 잘못 읽힌다. 백틱은 그럴 일이 없다.
    */
   let 이어쓰기줄들 = null;
+  /*
+   * 쌓인 줄을 이미 화면에 찍어 두었나.
+   *
+   * 줄 끝 백틱으로 이어 쓸 때는 줄쌓기() 가 치는 족족 찍는다. 붙여넣기는
+   * 일부러 안 찍는다(스무 줄이 주르륵 지나가지 않게). 보낼 때 무엇을 다시
+   * 찍을지가 그것으로 갈린다 — 이걸 안 가르면 같은 줄이 두 번 보이거나
+   * 붙여넣은 앞부분이 통째로 안 보인다.
+   */
+  let 이어쓴것 = false;
 
   /*
    * ── 상자 안에서 줄을 바꾼다 ────────────────────────────────────────────
@@ -412,6 +436,7 @@ export async function chatLoop(opts = {}) {
   /** 줄을 쌓아 두고 "다음 줄" 이라고 알린다. 백틱 표시와 Alt+Enter 가 같이 쓴다. */
   const 줄쌓기 = (줄) => {
     const 첫줄 = 이어쓰기줄들 === null;
+    이어쓴것 = true;   // 아래에서 바로 찍는다
     (이어쓰기줄들 ??= []).push(줄);
     화면.입력지움();
     say(`${첫줄 ? ` ${c.hcyan('❯')} ` : '   '}${c.white(줄)}`);
@@ -449,13 +474,29 @@ export async function chatLoop(opts = {}) {
         // 올렸을 때 답만 있고 무엇을 물었는지가 없다.
         const 이었나 = 이어쓰기줄들 !== null;
         보낼것 = 이었나 ? [...이어쓰기줄들, l].join('\n') : l;
-        이어쓰기줄들 = null;
+        이어쓰기줄들 = null; 이어쓴것 = false;
         화면.입력지움();
-        // 여러 줄이면 줄마다 찍는다. 한 번에 던지면 둘째 줄부터 왼쪽 끝에
-        // 붙어서, 사람이 보낸 글인지 프로그램이 뱉은 글인지 알 수 없다.
-        if (l.trim() || 이었나) {
-          for (const [i, 한줄] of l.split('\n').entries()) {
-            say(`${i === 0 && !이었나 ? ` ${c.hcyan('❯')} ` : '   '}${c.white(한줄)}`);
+        /*
+         * ── 보낸 것을 **보낸 그대로** 남긴다 ──────────────────────────────
+         *
+         * 여기서 `l` 만 찍고 있었다. 그런데 `l` 은 **마지막 줄**뿐이다 —
+         * 앞줄들은 이어쓰기줄들 에 쌓여 있다. 줄 끝 백틱으로 이어 쓸 때는
+         * 줄쌓기() 가 치는 족족 화면에 찍어 두었으니 그걸로 맞았는데,
+         * 붙여넣기는 일부러 안 찍는다(스무 줄이 주르륵 지나가지 않게).
+         *
+         * 그래서 붙여넣고 Enter 를 치면 **보낸 것의 마지막 조각만** 화면에
+         * 남았다. 사람은 앞부분이 안 갔다고 생각하고 다시 붙여넣는다.
+         *
+         * 찍을 것은 보낼것 이다. 화면에 남는 것과 모델에게 가는 것이 같아야
+         * 나중에 스크롤을 올려서 무엇을 시켰는지 알아볼 수 있다.
+         *
+         * 백틱으로 이어 쓴 경우에는 앞줄이 이미 찍혀 있으므로 마지막 줄만
+         * 이어 찍는다 — 안 그러면 같은 줄이 두 번 보인다.
+         */
+        const 찍을것 = 이어쓴것 ? l : 보낼것;
+        if (찍을것.trim() || 이었나) {
+          for (const [i, 한줄] of String(찍을것).split('\n').entries()) {
+            say(`${i === 0 && !이어쓴것 ? ` ${c.hcyan('❯')} ` : '   '}${c.white(한줄)}`);
           }
         }
       } else if (l.trim() || 이어쓰기줄들 !== null) {
@@ -483,7 +524,7 @@ export async function chatLoop(opts = {}) {
         }
         if (이어쓰기줄들 !== null) {
           보낼것 = [...이어쓰기줄들, l].join('\n');
-          이어쓰기줄들 = null;
+          이어쓰기줄들 = null; 이어쓴것 = false;
         }
         화면.대기갱신('', queue.length + 1);
       }
@@ -706,7 +747,7 @@ export async function chatLoop(opts = {}) {
      * y 를 쳐도 화면에 아무것도 안 나타난다 — 먹은 건지 안 먹은 건지 모른다.
      */
     묻는중 = 상자쓰나 ? 앞 : null;
-    이어쓰기줄들 = null;   // 되묻는 사이에 걸쳐 있던 미완성 이어쓰기는 버린다
+    이어쓰기줄들 = null; 이어쓴것 = false;   // 되묻는 사이에 걸쳐 있던 미완성 이어쓰기는 버린다
     try {
       const a = await nextLine();
       if (a === null) return o.def ?? '';
@@ -760,6 +801,10 @@ export async function chatLoop(opts = {}) {
     // 도구가 한 번에 돌려줄 양을 이 값에서 뽑는다 (agent/budget.js).
     // /model 로 갈아타면 conn 이 통째로 바뀌므로 그때마다 다시 읽는다.
     get 모델컨텍스트() { return conn.ctx ?? null; },
+    // 이 모델이 그림을 볼 수 있나 — Read 가 그림을 만났을 때 무슨 말을 할지가 여기서 갈린다.
+    get 눈있나() { return !!conn.vision; },
+    // 적어 둔 허락·금지 규칙 (safety/policy.js). 승인 모드보다 먼저 본다.
+    규칙들: 규칙모으기(cfg),
     history: new History(root),
     audit: new Audit(root),
     seen: new Set(),
@@ -948,7 +993,7 @@ export async function chatLoop(opts = {}) {
    * 대화 갈래. 연결·도구·되돌리기는 같이 쓰고 오간 말만 여러 벌 갖는다.
    * 갈래마다 저장 파일을 따로 열어서, 나중에 `/sessions` 로 각각 찾아갈 수 있다.
    */
-  ctx.갈래 = new Threads(session, ctx, () => new Store(root).begin({ model: conn.model, base: conn.base, root }), store);
+  ctx.갈래 = new Threads(session, ctx, () => new Store(root).begin({ model: conn.model, base: 주소가리기(conn.base), root }), store);
 
   // ── 컨텍스트 길이를 모델에서 긁어온다 ─────────────────────────────────
   //
@@ -1087,7 +1132,7 @@ export async function chatLoop(opts = {}) {
      * 더는 '/' 로 시작하지 않아 명령으로 안 읽히고 모델에게 넘어간다.
      */
     if (이어쓰기줄들 !== null) {
-      이어쓰기줄들 = null;
+      이어쓰기줄들 = null; 이어쓴것 = false;
       say('');
       say(`  ${c.gray('이어쓰던 것을 버렸습니다.')}`);
     }
@@ -1173,15 +1218,19 @@ export async function chatLoop(opts = {}) {
     // 붙인 것은 화면에 반드시 알린다. 사람이 안 보낸 줄 아는 글이 대화에
     // 들어가 있으면 안 된다 — 컨텍스트가 왜 줄었는지도 모르게 된다.
     let 보낼글 = toSend;
+    let 보낼그림 = null;
     if (toSend.includes('@')) {
       const 예산 = Math.min(20000, Math.floor((session.conn.ctx ?? CTX_DEFAULT) * 0.25));
       const r = expandMentions(toSend, {
         scope: ctx.scope, budget: 예산, seen: ctx.seen,
         onRead: (p, t) => session.noteRead(p, t),
+        눈있나: !!session.conn.vision,
       });
       보낼글 = r.text;
+      보낼그림 = r.그림들?.length ? r.그림들 : null;
       for (const a of r.attached) {
-        say(`  ${c.blue('◧')} ${c.gray('붙임')} ${c.white(a.show)}${a.full ? '' : c.gray(' (앞부분만)')}`);
+        const 꼬리 = a.그림 ? c.gray(` (그림 · ${크기말(a.bytes)})`) : (a.full ? '' : c.gray(' (앞부분만)'));
+        say(`  ${c.blue('◧')} ${c.gray('붙임')} ${c.white(a.show)}${꼬리}`);
       }
       for (const b of r.blocked) {
         say(`  ${mark.warn} ${c.gray(`${b.path} 는 작업 범위 밖이라 안 붙였습니다.`)}`);
@@ -1287,7 +1336,23 @@ export async function chatLoop(opts = {}) {
     // '겪을수록 나아진다' 가 이번 대화 안에서도 참이 된다.
     ctx.카드다시?.();
     try {
-      for await (const ev of run(session, ctx, 보낼글, { signal: turn.signal })) {
+      /*
+       * 일하는 중에 친 말을 걸음마다 건네준다 (agent/loop.js 의 끼어들기).
+       *
+       * **슬래시 명령은 안 건넨다.** /mode 나 /undo 는 설정과 파일을 건드리는
+       * 것이라, 도는 턴 한가운데서 먹으면 무엇이 어느 설정으로 돌았는지가
+       * 흐려진다. 그건 큐에 그대로 두고 턴이 끝난 뒤에 평소대로 처리한다.
+       *
+       * 큐에서 **빼서** 넘긴다 — 넘기고 큐에도 남기면 같은 말이 두 번 나간다.
+       */
+      const 끼어들기 = () => {
+        const i = queue.findIndex((x) => !String(x ?? '').trimStart().startsWith('/'));
+        if (i < 0) return null;
+        const [것] = queue.splice(i, 1);
+        화면.대기갱신('', queue.length);
+        return String(것).trim() || null;
+      };
+      for await (const ev of run(session, ctx, 보낼글, { signal: turn.signal, 그림들: 보낼그림, 끼어들기 })) {
         /*
          * 하위 작업 안쪽에서 온 것이면 한 단 들여 그린다.
          *
@@ -1296,6 +1361,15 @@ export async function chatLoop(opts = {}) {
          */
         화면.들여쓰기(ev.depth ?? 0);
         switch (ev.type) {
+          /*
+           * 도중에 낀 말. **화면에 그대로 보여 준다.**
+           *
+           * 안 보여 주면 사람은 제가 친 말이 먹혔는지 모른 채 기다린다.
+           * 그러면 한 번 더 치게 되고, 같은 말이 두 번 나간다.
+           */
+          case 'steer':
+            say(` ${c.hcyan('❯')} ${c.white(ev.text)}  ${c.gray('(도중에 낀 말 — 다음 걸음부터 반영됩니다)')}`);
+            break;
           // 어느 단계를 어떤 강도로 도는지 — 추론 강도 조절이 실제로 먹는지 눈으로 보인다.
           case 'stage':
             stage = ev;
@@ -1311,6 +1385,14 @@ export async function chatLoop(opts = {}) {
               : `  ${c.yellow('↻')} ${c.gray(`${ev.why} — 상한을 ${ev.from} → ${ev.to} 로 올려 다시 부릅니다`)}`);
             break;
 
+          // 서버가 잠깐 막아서 기다렸다 다시 부르는 자리 (backend/retry.js).
+          // 상태 코드·몇 초·몇 번째를 그대로 적는다 — 왜 느린지가 여기서만 읽힌다.
+          // 쉬움 수준에서도 숫자를 뺀 채 내지 않는다. 429 는 설명이 필요한 숫자가 아니다.
+          case 'backoff':
+            clearThinking();
+            say(`  ${c.yellow('↻')} ${c.gray(옮긴말('loop.backoff', 알림채움(ev)))}`);
+            break;
+
           case 'waiting':
             화면.기다림(c.gray(꼬리표(stage) + '생각 중…'));
             // 지워야 할 줄이 화면에 있다고 표시해 둔다.
@@ -1475,6 +1557,15 @@ export async function chatLoop(opts = {}) {
                     say(`      ${c.red('✗')} ${c.white(f.보인이름 ?? '(경로 없음)')} ${c.gray(`— ${clip(String(f.error), 60)}`)}`);
                   }
                 }
+              } else if (ev.result?.바뀐것들?.length) {
+                /*
+                 * 폴더를 옮겼다. 옮겨진 파일을 **하나씩** 적어 둔다.
+                 *
+                 * 「이 폴더가 바뀌었다」 로 적으면 나중에 /commit 이 그 폴더를
+                 * 통째로 담고, 같은 폴더에 있던 남의 변경까지 실린다.
+                 * 줄 수는 0 이다 — 옮긴 것이지 고친 것이 아니다.
+                 */
+                for (const f of ev.result.바뀐것들) session.noteChange(f, { added: 0, removed: 0 });
               }
             }
             flush();   // 도구가 하나 끝날 때마다 적어 둔다
@@ -1575,6 +1666,13 @@ export async function chatLoop(opts = {}) {
             break;
           }
 
+          case 'images_folded': {
+            clearThinking();
+            const 장수 = (ev.뺀것들 ?? []).reduce((a2, x) => a2 + x.장수, 0);
+            say(`  ${c.cyan('◲')} ${c.gray(`오래된 그림 ${장수}장을 뺐습니다 — 사람이 쓴 말은 그대로입니다.`)}`);
+            break;
+          }
+
           case 'compacted': {
             접기멈춤();
             const 줄인 = ev.before - ev.after;

package/src/report.js

@@ -1,5 +1,23 @@
 // 진단 결과를 화면에 표로 그리고, "이걸로 돌릴 수 있는지" 판정한다.
 import { c, say, rule, pad, width, mark } from './ui/ansi.js';
+import { 주소가리기 } from './safety/secrets.js';
+import { 프록시고르기, 프록시설정 } from './backend/proxy.js';
+import { 보관방식 } from './safety/keystore.js';
+import { load, activeProfile } from './config.js';
+
+// 열쇠를 어디에 두고 있나. 심사 담당자가 꼭 묻는 줄이라 보고서에 박아 둔다.
+function 열쇠줄() {
+  try { return 보관방식(activeProfile(load())?.apiKey ?? null); } catch { return 보관방식(); }
+}
+
+// 이 주소로 갈 때 거칠 프록시를 한 줄로. 안 거치면 null — 그때는 줄 자체를 안 만든다.
+// 적어 놨는데 못 쓰는 것(socks5 등)이면 그 까닭을 적는다 — 진단 보고서에서 제일 먼저 볼 줄이다.
+function 프록시줄(base) {
+  const p = 프록시고르기(base);
+  if (p) return `${p.url} (${p.출처})`;
+  const 탈 = 프록시설정().탈;
+  return 탈 ? `못 씀 — ${탈}` : null;
+}
 
 const ICON = { ok: mark.ok, no: mark.no, warn: mark.warn, skip: c.gray('·') };
 const WORD = { ok: c.green('됨'), no: c.red('안됨'), warn: c.yellow('조건부'), skip: c.gray('확인불가') };
@@ -17,10 +35,14 @@ export function renderHeader(facts) {
   const kindName = facts.shape === 'ollama' ? 'Ollama 자체 규격' : 'OpenAI 호환';
   const rows = [
     ['규격', kindName],
-    ['주소', facts.base],
+    ['주소', 주소가리기(facts.base)],
     ['인증', facts.auth === 'none' ? '없음' : facts.auth],
     ['모델', facts.model],
   ];
+  // 프록시를 거치면 그 줄도 적는다. "연결 실패" 가 프록시 탓인지 게이트웨이 탓인지는
+  // 이 한 줄이 있어야 갈린다 — 진단 보고서를 받는 사내 담당자가 제일 먼저 보는 자리다.
+  const 프록시 = 프록시줄(facts.base);
+  if (프록시) rows.push(['프록시', 프록시]);
   for (const [k, v] of rows) say(`  ${c.gray(pad(k, 8))} ${v}`);
   say('');
   rule('검사', 74);
@@ -103,8 +125,10 @@ export function plainReport(facts, results, v) {
     `생성 시각   ${at}`,
     '',
     `규격        ${facts.shape === 'ollama' ? 'Ollama 자체 규격' : 'OpenAI 호환'}`,
-    `주소        ${facts.base}`,
+    `주소        ${주소가리기(facts.base)}`,
+    ...(프록시줄(facts.base) ? [`프록시      ${프록시줄(facts.base)}`] : []),
     `인증        ${facts.auth === 'none' ? '없음' : facts.auth}`,
+    `열쇠 보관   ${열쇠줄()}`,
     `모델        ${facts.model}`,
     `컨텍스트    ${facts.ctx ? facts.ctx.toLocaleString() + ' 토큰' : '미상'}`,
     '',