deel-local-cli 1.6.3 → 1.8.0

package/src/backend/price.js

@@ -0,0 +1,197 @@
+/**
+ * 요금 셈 — 쓴 토큰을 돈으로 옮긴다.
+ *
+ * ── 이 파일에는 값이 박힌 요금표가 없다 ────────────────────────────────
+ *
+ * 일부러 안 넣었다. 요금은 회사가 아무 때나 바꾸는 값이고, 소스에 박아 두면
+ * 고칠 사람이 없다. 그러면 이 도구는 **틀린 금액을 자신 있게 찍는 도구**가
+ * 된다. 토큰 수를 안 보여 주는 것보다 그쪽이 훨씬 나쁘다 — 사람은 화면에
+ * 뜬 숫자를 믿고 예산을 잡는다.
+ *
+ * 그래서 값의 출처는 둘뿐이다.
+ *
+ *   1. 사람이 설정에 적은 값  (.deel/config.json 의 `요금`)
+ *   2. 제공자 서술 파일이 들고 있는 값 (src/providers/*.js 의 `요금`)
+ *
+ * 2번은 지금 전부 비어 있다. 확인한 값만 넣기로 했고, 확인하지 못했다.
+ * 비어 있는 표는 「모른다」 고 말하지만, 지어낸 표는 거짓말을 한다.
+ *
+ * 모르면 돈을 안 찍는다. 토큰만 찍고 「요금 모름」 이라고 적는다.
+ *
+ * ── 단위 ───────────────────────────────────────────────────────────────
+ *
+ * 100만 토큰당 달러로 적는다. 회사들이 요금표를 그 단위로 내놓기 때문이다.
+ * 사람이 요금표에서 본 숫자를 그대로 옮겨 적을 수 있어야 한다. 여기서
+ * 1000토큰당으로 받으면 1000배 틀린 값이 조용히 들어온다.
+ */
+import { 제공자고르기 } from '../providers/index.js';
+
+// 100만 토큰당. 요금표에 적힌 숫자를 그대로 받기 위한 단위다.
+export const 단위 = 1000000;
+
+/*
+ * 기준 날짜가 이만큼 지나면 「오래됨」 이라고 덧붙인다.
+ *
+ * 값을 버리지는 않는다. 오래된 값도 자릿수는 맞으므로 안 보여 주는 것보다
+ * 낫다. 다만 그대로 믿게 두면 안 된다. 반년이면 회사가 요금을 한 번쯤
+ * 손대는 기간이라 이렇게 잡았다.
+ */
+export const 낡는날 = 180;
+
+/**
+ * 설정에 적힌 값이 쓸 수 있는 요금인가.
+ *
+ * 문자열로 적어도 받는다 — 사람이 JSON 에 "2.5" 라고 적는 일은 흔하고,
+ * 그걸 튕기면 조용히 「요금 모름」 이 되어 왜 안 나오는지 알 길이 없다.
+ * 대신 숫자가 아닌 것·음수는 받지 않고, 왜 못 받았는지 말로 남긴다.
+ */
+function 값읽기(x) {
+  if (x == null || x === '') return null;
+  const v = typeof x === 'string' ? Number(x.trim()) : Number(x);
+  if (!Number.isFinite(v) || v < 0) return null;
+  return v;
+}
+
+/**
+ * 모델 이름이 이 열쇠에 걸리나.
+ *
+ * 딱 맞는 이름이 먼저다. `*` 를 쓴 열쇠(`gpt-4o*`)는 사람이 **일부러**
+ * 적었을 때만 걸린다 — 우리가 알아서 앞머리를 잘라 맞추면, 값이 다른
+ * 형제 모델(`-mini`)에 비싼 요금이 붙어도 아무도 모른다.
+ */
+function 걸리나(열쇠, 모델) {
+  if (열쇠 === 모델) return { 맞나: true, 딱: true };
+  if (!열쇠.includes('*')) return { 맞나: false };
+  const 무늬 = new RegExp(`^${열쇠.split('*').map((s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('.*')}$`);
+  return { 맞나: 무늬.test(모델), 딱: false };
+}
+
+function 한칸읽기(열쇠, 값, 어디서) {
+  const 입 = 값읽기(값?.입력 ?? 값?.in ?? 값?.input);
+  const 출 = 값읽기(값?.출력 ?? 값?.out ?? 값?.output);
+  if (입 == null || 출 == null) {
+    return { 탈: `${어디서} 의 '${열쇠}' 요금이 숫자가 아닙니다 (입력·출력 둘 다 필요합니다)` };
+  }
+  const 기준 = 값?.기준 ?? 값?.asOf ?? null;
+  return { 입력: 입, 출력: 출, 기준: 기준 ? String(기준) : null, 어디서, 열쇠 };
+}
+
+/**
+ * 이 모델의 요금을 찾는다.
+ *
+ * 사람이 적은 값이 먼저다. 딸려 온 표가 낡았을 때 사람이 고칠 방법이
+ * 그것뿐이라 그렇다. 못 찾으면 null 을 준다 — 0 이 아니다. 0 을 주면
+ * 「공짜」 와 「모름」 이 화면에서 같아진다.
+ *
+ * @param {string} 모델
+ * @param {{설정?: object|null, 제공자?: object|null, 이제?: number}} o
+ */
+export function 요금찾기(모델, { 설정 = null, 제공자 = null, 이제 = Date.now() } = {}) {
+  const 이름 = String(모델 ?? '').trim();
+  if (!이름) return null;
+  const 탈들 = [];
+
+  for (const [표, 어디서] of [[설정, '설정'], [제공자?.요금, '딸려 온 표']]) {
+    if (!표 || typeof 표 !== 'object') continue;
+    // 딱 맞는 이름 먼저, 그다음에 사람이 `*` 로 적어 둔 것.
+    for (const 딱먼저 of [true, false]) {
+      for (const [열쇠, 값] of Object.entries(표)) {
+        const g = 걸리나(열쇠, 이름);
+        if (!g.맞나 || !!g.딱 !== 딱먼저) continue;
+        const 읽은 = 한칸읽기(열쇠, 값, 어디서);
+        if (읽은.탈) { 탈들.push(읽은.탈); continue; }
+        const 기준 = 읽은.기준 ?? (어디서 === '딸려 온 표' ? 제공자?.요금기준 ?? null : null);
+        return { ...읽은, 기준, 낡았나: 낡았나(기준, 이제), 탈들 };
+      }
+    }
+  }
+  return 탈들.length ? { 없음: true, 탈들 } : null;
+}
+
+/**
+ * 이 대화에 걸린 요금값.
+ *
+ * 상태줄은 글자를 칠 때마다 다시 그려진다. 그때마다 표를 훑으면 아까우니
+ * 모델 이름이 그대로인 동안은 찾은 것을 들고 있는다. 모델을 갈아타면
+ * (/model) 이름이 달라지므로 저절로 다시 찾는다 — 갈아탈 때 이걸 지워
+ * 달라고 부탁하는 방식은 언젠가 한 군데를 빠뜨린다.
+ */
+export function 세션요금(session, { 이제 = Date.now() } = {}) {
+  const 모델 = String(session?.conn?.model ?? '');
+  if (session?.요금캐시 && session.요금캐시.모델 === 모델) return session.요금캐시.값;
+  const 값 = 요금찾기(모델, {
+    설정: session?.요금표 ?? null,
+    제공자: session?.제공자 ? 제공자고르기(session.제공자) : null,
+    이제,
+  });
+  if (session) session.요금캐시 = { 모델, 값 };
+  return 값;
+}
+
+/** 기준 날짜가 반년보다 오래됐나. 날짜가 없으면 「모른다」 — 오래됐다고 치지 않는다. */
+export function 낡았나(기준, 이제 = Date.now()) {
+  if (!기준) return false;
+  const t = Date.parse(기준);
+  if (!Number.isFinite(t)) return false;
+  return (이제 - t) / 86400000 > 낡는날;
+}
+
+/**
+ * 토큰을 달러로.
+ *
+ * 요금을 모르면 null 이다. 여기서 0 을 돌려주면 부르는 쪽이 「$0.00」 을
+ * 찍게 되고, 그건 공짜라는 뜻이 되어 버린다.
+ */
+export function 돈셈({ in: 입 = 0, out: 출 = 0 } = {}, 값) {
+  if (!값 || 값.없음 || 값.입력 == null || 값.출력 == null) return null;
+  const 입돈 = (Number(입) || 0) / 단위 * 값.입력;
+  const 출돈 = (Number(출) || 0) / 단위 * 값.출력;
+  return { 달러: 입돈 + 출돈, 입력: 입돈, 출력: 출돈 };
+}
+
+/**
+ * 돈을 사람이 읽는 글로.
+ *
+ * 아주 작은 값을 `$0.00` 으로 반올림하면 안 된다. 로컬에서 한두 턴 돌린
+ * 뒤 화면에 `$0.00` 이 서 있으면 「공짜네」 로 읽히고, 그 상태로 백 턴을
+ * 돌린다. 자릿수가 안 되면 반올림하지 말고 미만이라고 적는다.
+ */
+export function 돈말(달러) {
+  const v = Number(달러);
+  if (!Number.isFinite(v) || v < 0) return null;
+  if (v === 0) return '$0';
+  if (v < 0.0001) return '<$0.0001';
+  if (v < 1) return `$${v.toFixed(4)}`;
+  if (v < 1000) return `$${v.toFixed(2)}`;
+  return `$${Math.round(v).toLocaleString()}`;
+}
+
+/**
+ * 이 금액이 어디서 온 값인지 한 줄로.
+ *
+ * 금액만 찍으면 사람은 그게 오늘 요금표에서 온 값이라고 믿는다. 어디서
+ * 왔는지·언제 기준인지를 같이 적어야 의심할 거리가 생긴다.
+ */
+export function 어디서온값(값) {
+  if (!값 || 값.없음) return null;
+  const 조각 = [값.어디서];
+  if (값.열쇠 && 값.열쇠.includes('*')) 조각.push(`'${값.열쇠}' 로 맞춤`);
+  if (값.기준) 조각.push(`${값.기준} 기준${값.낡았나 ? ' · 오래됨' : ''}`);
+  else 조각.push('기준 날짜 없음');
+  return 조각.join(' · ');
+}
+
+/**
+ * 요금을 모를 때 사람에게 할 말.
+ *
+ * 「모릅니다」 로 끝내면 사람이 할 수 있는 일이 없다. 어디에 무엇을 적으면
+ * 되는지까지 적는다. 요금표 주소를 아는 제공자면 그것도 같이 준다.
+ */
+export function 요금적는법(모델, { 제공자 = null, 설정파일 = '.deel/config.json' } = {}) {
+  const 줄 = [
+    `요금을 모릅니다. ${설정파일} 에 100만 토큰당 달러로 적으면 셈합니다.`,
+    `  "요금": { "${모델 || '모델이름'}": { "입력": 0, "출력": 0, "기준": "${new Date().toISOString().slice(0, 10)}" } }`,
+  ];
+  if (제공자?.요금표주소) 줄.push(`  요금표: ${제공자.요금표주소}`);
+  return 줄;
+}

package/src/backend/retry.js

@@ -17,6 +17,9 @@
 //   · 세 번까지. 그 뒤로는 사실대로 말한다. 열 번 두드리는 것은 할당량을 더 빨리
 //     태우는 짓이다.
 //   · 400·401·403·404 는 다시 불러 봐야 같다. 한 번만 부르고 서버가 한 말을 보여 준다.
+//     401 에 딱 하나 예외가 있는데, 그것도 여기가 아니라 backend/adapter.js 가 한다 —
+//     열쇠받기(safety/authcmd.js)가 걸려 있으면 **같은 열쇠로 다시 부르는 것이 아니라**
+//     새 열쇠를 받아서 부르는 것이라, 「불러 봐야 같다」 에 해당하지 않는다. 딱 한 번이다.
 //   · ECONNREFUSED 는 서버가 꺼진 것이고, 시간 초과는 5분을 또 기다릴 일이 아니다.
 //     둘 다 안 부른다.
 //

package/src/backend/scanui.js

@@ -3,6 +3,7 @@ import { c, say, rule, pad, mark, clip, width } from '../ui/ansi.js';
 import { pick } from '../ui/prompt.js';
 import { spin } from '../ui/spinner.js';
 import { scanLocal, toProfiles, KNOWN } from './scan.js';
+import { 규격이름 } from './adapter.js';
 import { load, save, upsert } from '../config.js';
 
 // 코딩 에이전트로 쓰려면 도구 호출이 되어야 한다. 진단 전이라 확실히는 모르니,
@@ -66,7 +67,7 @@ export async function runScan(flags = {}) {
   const wRun = Math.max(10, ...found.map((f) => width(f.runtime)));
   for (const f of found) {
     const 자리 = `${f.host}:${f.port}`;
-    const 규격 = f.kind === 'ollama' ? 'Ollama 규격' : 'OpenAI 호환';
+    const 규격 = 규격이름(f.kind);
     const 표시 = f.guessed ? c.gray(' (추정)') : '';
     say(`  ${c.hcyan('◆')} ${c.bold(pad(f.runtime, wRun))}${표시}  ${c.gray(pad(자리, 22))}${c.gray(pad(규격, 14))}${c.gray(f.ms + 'ms')}`);
     if (f.locked) {

package/src/backend/vision.js

@@ -13,10 +13,11 @@
 //
 // ── 무엇을 하나 ────────────────────────────────────────────────────────
 //
-// 그림이면 그림으로 싣는다. 규격이 둘이라 모양도 둘이다.
+// 그림이면 그림으로 싣는다. 규격이 셋이라 모양도 셋이다.
 //
 //   OpenAI 호환   content 배열에 { type:'image_url', image_url:{ url:'data:…' } }
 //   Ollama        메시지에 images: ['<base64>'] (data: 머리말 없이)
+//   Anthropic     content 배열에 { type:'image', source:{ type:'base64', media_type, data } }
 //
 // 못 보는 모델에게는 **바이트를 아예 안 보낸다.** 보내 봐야 400 이 오거나,
 // 더 나쁘게는 서버가 조용히 무시하고 답을 지어낸다. 대신 한 줄로 말한다.
@@ -127,11 +128,15 @@ export function 그림읽기(abs, { 한도 = 기본한도 } = {}) {
  */
 export const 그림한장토큰 = 1000;
 
-/** 메시지 하나에 그림이 몇 장 실려 있나. 규격 두 가지를 다 본다. */
+/** 메시지 하나에 그림이 몇 장 실려 있나. 규격 세 가지를 다 본다. */
 export function 그림장수(m) {
   if (!m) return 0;
   if (Array.isArray(m.images)) return m.images.length;           // Ollama
-  if (Array.isArray(m.content)) return m.content.filter((p) => p?.type === 'image_url').length;
+  // image_url 은 OpenAI 호환, image 는 Anthropic. 한쪽만 세면 그림을 실어
+  // 놓고도 안 실은 줄 알고 창 크기를 잘못 잡는다.
+  if (Array.isArray(m.content)) {
+    return m.content.filter((p) => p?.type === 'image_url' || p?.type === 'image').length;
+  }
   return 0;
 }
 
@@ -155,6 +160,23 @@ export function 글만(m) {
  */
 export function 그림메시지(shape, { 글 = '', 그림들 = [] } = {}) {
   const 것들 = 그림들.filter((g) => g?.b64);
+  /*
+   * Anthropic 은 그림을 data: 주소로 안 받는다. 종류와 알맹이를 따로 준다.
+   * image_url 로 보내면 「모르는 블록」 이라고 통째로 거절당한다 — 글까지
+   * 같이 안 간다는 뜻이라, 눈이 없는 것과 달리 대화가 아예 안 이어진다.
+   */
+  if (shape === 'anthropic') {
+    return {
+      role: 'user',
+      content: [
+        { type: 'text', text: 글 },
+        ...것들.map((g) => ({
+          type: 'image',
+          source: { type: 'base64', media_type: g.mime, data: g.b64 },
+        })),
+      ],
+    };
+  }
   if (shape === 'ollama') {
     // Ollama 는 data: 머리말을 안 받는다. base64 알맹이만 준다.
     return { role: 'user', content: 글, images: 것들.map((g) => g.b64) };
@@ -176,7 +198,7 @@ export function 그림메시지(shape, { 글 = '', 그림들 = [] } = {}) {
  */
 export const 한점PNG = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==';
 
-/** 눈 검사에 쓸 메시지. 규격 두 가지 다. */
+/** 눈 검사에 쓸 메시지. 규격 세 가지 다. */
 export function 눈검사메시지(shape) {
   return 그림메시지(shape, {
     글: '이 그림에 무엇이 있습니까? 한 단어로 답하세요.',

package/src/commands.js

@@ -2,23 +2,28 @@
 import { writeFileSync, existsSync, statSync } from 'node:fs';
 import { 볼것, 리뷰받기 } from './agent/review.js';
 import { 마지막할당량, 할당량말, 아슬아슬한가 } from './backend/quota.js';
+import { 세션요금, 돈셈, 돈말, 어디서온값, 요금적는법 } from './backend/price.js';
 import { join } from 'node:path';
 import { c, say, rule, pad, bar, mark, width, clip } from './ui/ansi.js';
 import { compact } from './agent/compact.js';
 import { 증거모으기, 증거적기 } from './agent/evidence.js';
 import { 커밋준비, 커밋실행 } from './agent/commit.js';
 import { allowEndpoint } from './safety/network.js';
+import { 지금모드, 바깥인가, 나갈수있나 } from './safety/runmode.js';
+import { 주소가리기 } from './safety/secrets.js';
 import { pick, confirm } from './ui/prompt.js';
-import { load, save, resolveKey, upsert, 열쇠보관 } from './config.js';
+import { load, save, resolveKey, upsert, 열쇠보관, configPath } from './config.js';
+import { 지금상태 as 지금열쇠상태 } from './safety/authcmd.js';
+import { 제공자고르기 } from './providers/index.js';
 import { 종, 알릴만한초 } from './ui/notify.js';
 import { 말, 언어, 언어들, 언어정하기, 언어고르기, 옮긴만큼, 지시말, 지시말정하기, 지시말따로정했나 } from './i18n/index.js';
 import { 프로필찾기, 쓸수있나, 연결만들기, 알릴말, 목록보기 } from './agent/models.js';
 import { allowTemporarily } from './safety/network.js';
-import { chat } from './backend/adapter.js';
+import { chat, 규격이름 } from './backend/adapter.js';
 import { 알림채움 } from './backend/retry.js';
 import { 프록시고르기, 프록시설정 } from './backend/proxy.js';
 import { 정한셸 } from './tools/shell.js';
-import { TOOLS } from './tools/index.js';
+import { TOOLS, 영어설명 } from './tools/index.js';
 import { 둘러보기, 프로젝트갈래 } from './lsp/servers.js';
 import { 지금것들 } from './lsp/client.js';
 import { 보고서적기 } from './ui/export.js';
@@ -859,9 +864,20 @@ export async function handle(line, session, ctx) {
     case 'serve': return await 미리보기(session, ctx, arg), { handled: true };
 
     case 'tools': {
-      rule('도구', 70);
+      rule(말('scr.tools'), 70);
+      /*
+       * 원본 schema.description 을 그대로 찍으면 안 된다.
+       *
+       * 그 글은 한국어다. 영어 표(tools/desc.en.js)는 **모델에게 줄 때만**
+       * 갈아 끼우고 있어서, 영어로 켠 사람의 `/tools` 는 스물한 줄이 통째로
+       * 한국어로 나왔다. `/lang` 은 그 사이에도 100% 라고 답했다 — 이 글들은
+       * 애초에 말 표에 들어간 적이 없어서 셈에 안 잡혔기 때문이다.
+       *
+       * 여기서는 **화면 말**(언어())로 고른다. 모델에게 주는 글의 말과는
+       * 다른 축이다 — 영어로 시키고 한국어로 보는 조합이 실제로 쓰인다.
+       */
       for (const [n, t] of Object.entries(TOOLS)) {
-        say(`  ${c.cyan(pad(n, 8))} ${c.gray(t.schema.description)}`);
+        say(`  ${c.cyan(pad(n, 8))} ${c.gray(영어설명(t.schema, n, 언어()).description)}`);
       }
       say('');
       return { handled: true };
@@ -869,14 +885,41 @@ export async function handle(line, session, ctx) {
 
     case 'cost': {
       const mins = ((Date.now() - session.startedAt) / 60000).toFixed(1);
-      rule('이번 세션', 70);
-      say(`  ${c.gray(pad('모델 호출', 14))} ${session.usage.calls}회`);
-      say(`  ${c.gray(pad('입력 토큰', 14))} ${session.usage.in.toLocaleString()}`);
-      say(`  ${c.gray(pad('출력 토큰', 14))} ${session.usage.out.toLocaleString()}`);
-      say(`  ${c.gray(pad('도구 시간', 14))} ${(session.usage.ms / 1000).toFixed(1)}초`);
+      rule(말('scr.session'), 70);
+      say(`  ${c.gray(pad(말('cost.calls'), 14))} ${말('unit.calls', { n: session.usage.calls })}`);
+      say(`  ${c.gray(pad(말('cost.tokIn'), 14))} ${session.usage.in.toLocaleString()}`);
+      say(`  ${c.gray(pad(말('cost.tokOut'), 14))} ${session.usage.out.toLocaleString()}`);
+      say(`  ${c.gray(pad(말('cost.toolMs'), 14))} ${말('unit.sec', { n: (session.usage.ms / 1000).toFixed(1) })}`);
       // 서버가 잠깐 막아 다시 부른 횟수. 0 이면 안 적는다 — 없는 일을 줄로 남기면 표만 길어진다.
-      if (session.usage.retries) say(`  ${c.gray(pad(말('cost.retries'), 14))} ${session.usage.retries}회`);
-      say(`  ${c.gray(pad('경과', 14))} ${mins}분`);
+      if (session.usage.retries) say(`  ${c.gray(pad(말('cost.retries'), 14))} ${말('unit.calls', { n: session.usage.retries })}`);
+      say(`  ${c.gray(pad(말('cost.elapsed'), 14))} ${말('unit.min', { n: mins })}`);
+      /*
+       * 돈.
+       *
+       * 이 도구에는 값이 박힌 요금표가 없다(backend/price.js). 지어낸 요금을
+       * 자신 있게 찍는 것보다 모른다고 말하는 편이 낫다고 봤다.
+       *
+       * 그래서 두 갈래다 — 아는 값이 있으면 금액과 **어디서 온 값인지**를
+       * 같이 적고, 모르면 어디에 무엇을 적으면 되는지를 적는다. 「모릅니다」
+       * 한 줄로 끝내면 사람이 할 수 있는 일이 없다.
+       *
+       * 로컬로만 쓰는 사람에게는 아예 안 띄운다. 로컬은 공짜라 그 자리가
+       * 영영 안 채워지고, 그러면 매번 쓸모없는 안내만 보게 된다.
+       */
+      const 요금값 = 세션요금(session);
+      const 쓴돈 = 돈셈(session.usage, 요금값);
+      if (쓴돈) {
+        say(`  ${c.gray(pad(말('cost.money'), 14))} ${c.bold(돈말(쓴돈.달러))}`
+          + ` ${c.gray(`(${어디서온값(요금값)})`)}`);
+      } else if (바깥인가(session.conn.base) && (session.usage.in || session.usage.out)) {
+        const 붙은곳 = session.제공자 ? 제공자고르기(session.제공자) : null;
+        for (const 줄 of 요금적는법(session.conn.model, { 제공자: 붙은곳, 설정파일: configPath() })) {
+          say(`  ${c.gray(줄)}`);
+        }
+      }
+      // 설정에 적어는 뒀는데 숫자가 아니면 조용히 넘어가면 안 된다. 사람은
+      // 적었다고 믿고 있으므로, 안 나오는 까닭을 화면에서 알 수 있어야 한다.
+      for (const 탈 of 요금값?.탈들 ?? []) say(`  ${c.yellow(mark.no)} ${c.gray(탈)}`);
       /*
        * 서버가 남았다고 말해 준 할당량 (backend/quota.js).
        *
@@ -886,8 +929,8 @@ export async function handle(line, session, ctx) {
       const 남은것 = 마지막할당량();
       if (남은것) {
         const 말줄 = 할당량말(남은것);
-        say(`  ${c.gray(pad('서버 할당량', 14))} ${아슬아슬한가(남은것) ? c.yellow(말줄) : 말줄}`
-          + ` ${c.gray(`(${Math.round((Date.now() - 남은것.때) / 1000)}초 전 응답 기준)`)}`);
+        say(`  ${c.gray(pad(말('cost.quota'), 14))} ${아슬아슬한가(남은것) ? c.yellow(말줄) : 말줄}`
+          + ` ${c.gray(`(${말('cost.quotaAge', { 초: Math.round((Date.now() - 남은것.때) / 1000) })})`)}`);
       }
       say('');
       return { handled: true };
@@ -895,29 +938,46 @@ export async function handle(line, session, ctx) {
 
     case 'status': {
       const k = session.conn;
-      rule('연결', 70);
-      say(`  ${c.gray(pad('규격', 10))} ${k.kind === 'ollama' ? 'Ollama' : 'OpenAI 호환'}`);
-      say(`  ${c.gray(pad('주소', 10))} ${k.base}`);
+      rule(말('scr.conn'), 70);
+      say(`  ${c.gray(pad(말('status.kind'), 10))} ${규격이름(k.kind)}`);
+      say(`  ${c.gray(pad(말('status.url'), 10))} ${k.base}`);
       // 프록시를 거치면 어느 것을, 어디서 읽었는지(env · config)까지. 안 거치면 줄 자체가 없다.
       // 적어 놨는데 못 쓰는 것(socks5 등)이면 그 까닭을 — 조용히 직접 가면 사람은 프록시를 탄 줄 안다.
       const 프록시 = 프록시고르기(k.base);
-      if (프록시) say(`  ${c.gray(pad('프록시', 10))} ${프록시.url} ${c.gray(`(${프록시.출처})`)}`);
-      else if (프록시설정().탈) say(`  ${c.gray(pad('프록시', 10))} ${c.yellow('못 씀')} ${c.gray(`— ${프록시설정().탈}`)}`);
-      say(`  ${c.gray(pad('모델', 10))} ${k.model}`);
-      say(`  ${c.gray(pad('작업 폴더', 10))} ${session.root}`);
+      if (프록시) say(`  ${c.gray(pad(말('status.proxy'), 10))} ${프록시.url} ${c.gray(`(${프록시.출처})`)}`);
+      else if (프록시설정().탈) say(`  ${c.gray(pad(말('status.proxy'), 10))} ${c.yellow(말('status.proxyOff'))} ${c.gray(`— ${프록시설정().탈}`)}`);
+      say(`  ${c.gray(pad(말('status.model'), 10))} ${k.model}`);
+      say(`  ${c.gray(pad(말('status.root'), 10))} ${session.root}`);
       // 명령이 어느 셸에서 도는지. "ls 가 왜 안 되지" 의 답이 이 줄에 있다.
-      say(`  ${c.gray(pad('셸', 10))} ${정한셸().표시}`);
+      say(`  ${c.gray(pad(말('status.shell'), 10))} ${정한셸().표시}`);
       // 열쇠를 어디에 두고 있나. 사내 심사에서 제일 먼저 묻는 것이라
       // 「어딘가 잠겨 있겠지」 로 두지 않고 지금 상태를 그대로 적는다.
-      if (k.auth !== 'none') say(`  ${c.gray(pad('열쇠 보관', 10))} ${열쇠보관(load())}`);
-      say(`  ${c.gray(pad('규칙', 10))} ${session.rules ? session.rules.name : '없음 (/init 으로 만들 수 있습니다)'}`);
+      /*
+       * 열쇠를 어디에 두고 있나 — 또는 **어디서 받아 오나.**
+       *
+       * 받아 오는 연결에서는 「보관」 을 적으면 거짓말이 된다. 우리는 그
+       * 열쇠를 갖고 있지 않다. 사내 심사에서 제일 먼저 묻는 자리라
+       * 있는 그대로 적는다 (safety/authcmd.js).
+       */
+      if (session.conn.열쇠받기) {
+        const 상태 = 지금열쇠상태();
+        const 남은말 = 상태
+          ? 말('auth.leftMin', { 분: Math.round(상태.남은초 / 60) })
+          : 말('auth.notYet');
+        say(`  ${c.gray(pad(말('status.keyStore'), 10))} `
+          + `${말(session.conn.열쇠받기.곳 === '정책' ? 'auth.fromPolicy' : 'auth.from')} ${c.gray(`· ${남은말}`)}`);
+        say(`  ${c.gray(pad('', 10))} ${c.gray(clip(session.conn.열쇠받기.명령, 56))}`);
+      } else if (k.auth !== 'none') {
+        say(`  ${c.gray(pad(말('status.keyStore'), 10))} ${열쇠보관(load())}`);
+      }
+      say(`  ${c.gray(pad(말('status.rules'), 10))} ${session.rules ? session.rules.name : 말('status.noRules')}`);
       const caps = [
-        k.tools ? c.green('도구') : c.red('도구'),
-        k.streaming ? c.green('스트림') : c.gray('스트림'),
-        k.json ? c.green('스키마') : c.gray('스키마'),
-        k.think ? c.green('추론') : c.gray('추론'),
+        k.tools ? c.green(말('status.capTools')) : c.red(말('status.capTools')),
+        k.streaming ? c.green(말('status.capStream')) : c.gray(말('status.capStream')),
+        k.json ? c.green(말('status.capSchema')) : c.gray(말('status.capSchema')),
+        k.think ? c.green(말('status.capThink')) : c.gray(말('status.capThink')),
       ].join(c.gray(' · '));
-      say(`  ${c.gray(pad('지원', 10))} ${caps}`);
+      say(`  ${c.gray(pad(말('status.caps'), 10))} ${caps}`);
       say('');
       return { handled: true };
     }
@@ -2188,8 +2248,8 @@ function 배움명령(session, ctx, arg = '') {
 function showContext(session) {
   const b = session.breakdown();
   say('');
-  rule('컨텍스트', 70);
-  say(`  ${c.bold(session.conn.model)} ${c.gray('·')} ${b.total.toLocaleString()} 토큰`);
+  rule(말('scr.context'), 70);
+  say(`  ${c.bold(session.conn.model)} ${c.gray('·')} ${말('unit.tokens', { n: b.total.toLocaleString() })}`);
   say('');
   say(`  ${bar(b.used, b.total, 32)}  ${b.used.toLocaleString()} / ${b.total.toLocaleString()}  ${c.gray(`${Math.round((b.used / b.total) * 100)}%`)}`);
   say('');
@@ -2198,9 +2258,9 @@ function showContext(session) {
     say(`  ${c.gray(pad(r.label, 26))} ${pad(r.n.toLocaleString(), 8, 'right')}`);
   }
   say(`  ${c.gray('─'.repeat(35))}`);
-  say(`  ${c.gray(pad('남음', 26))} ${pad(b.left.toLocaleString(), 8, 'right')}`);
+  say(`  ${c.gray(pad(말('ctx.left'), 26))} ${pad(b.left.toLocaleString(), 8, 'right')}`);
   say('');
-  say(`  ${c.gray('/compact 대화 줄이기   /clear 통째로 비우기')}`);
+  say(`  ${c.gray(`/compact ${말('ctx.compactHint')}   /clear ${말('ctx.clearHint')}`)}`);
   /*
    * 추정이라고만 적어 두면 사람은 얼마나 믿어야 할지 모른다. 서버가 알려 준
    * 실제값에 맞춰 가고 있으면 그 사실을 적는다 — '추정' 과 '맞춰 본 추정' 은
@@ -2208,9 +2268,9 @@ function showContext(session) {
    */
   if (b.보정잰것 > 0) {
     const 차이 = Math.round((b.보정 - 1) * 100);
-    say(`  ${c.gray(`서버가 알려 준 실제값에 맞춰 ${차이 >= 0 ? '+' : ''}${차이}% 보정했습니다 (${b.보정잰것}번 재봄).`)}`);
+    say(`  ${c.gray(말('ctx.calibrated', { 부호: 차이 >= 0 ? '+' : '', 퍼센트: 차이, 번: b.보정잰것 }))}`);
   } else {
-    say(`  ${c.gray('숫자는 추정입니다 — 정확한 토크나이저를 쓰지 않습니다.')}`);
+    say(`  ${c.gray(말('ctx.estimate'))}`);
   }
   say('');
 }
@@ -2555,6 +2615,9 @@ function 연결적용(session, p) {
   // 자물쇠도 같이 옮긴다. 이걸 빼먹으면 옛 주소가 열린 채로 남고 새 주소는 막혀
   // 다음 한마디에서 바로 "허용되지 않은 주소" 가 난다.
   allowEndpoint(p.baseUrl);
+  // 어디 것인지도 같이 옮긴다. 요금표 주소 같은 안내가 옛 회사 것으로 남으면
+  // 사람이 엉뚱한 요금표를 보러 간다.
+  session.제공자 = p.제공자 ?? null;
 }
 
 /**
@@ -2616,7 +2679,7 @@ async function switchModel(session, ctx, arg = '') {
   // 이름으로 바로 바꾸기 — 메뉴를 안 거친다.
   if (말) {
     const 찾은 = 이름으로찾기(cfg.profiles, 말);
-    if (찾은.length === 1) return 골라적용(session, cfg, 찾은[0]);
+    if (찾은.length === 1) return await 골라적용(session, cfg, 찾은[0]);
     if (찾은.length > 1) {
       say(`  ${mark.warn} ${c.white(말)} ${c.gray('에 맞는 것이 여럿입니다.')}`);
       for (const p of 찾은.slice(0, 12)) say(`    ${c.cyan(p.name)}  ${c.gray(p.model)}`);
@@ -2653,7 +2716,7 @@ async function switchModel(session, ctx, arg = '') {
     ask: ctx?.ask,
   });
   if (i === cfg.profiles.length) return await 서버모델고르기(session, ctx, cfg);
-  return 골라적용(session, cfg, cfg.profiles[i]);
+  return await 골라적용(session, cfg, cfg.profiles[i]);
 }
 
 function 이름으로찾기(profiles, 말) {
@@ -2663,7 +2726,44 @@ function 이름으로찾기(profiles, 말) {
   return profiles.filter((p) => `${p.name} ${p.model} ${p.id}`.toLowerCase().includes(q));
 }
 
-function 골라적용(session, cfg, p) {
+/*
+ * 이 프로필로 갈아타면 바깥으로 나가는가. 나가면 한 번 묻는다.
+ *
+ * 켤 때 지나는 문(repl.js)과 **같은 문**이다. 여기를 안 지키면 자물쇠가
+ * 반쪽이 된다 — 로컬로 켜서 물음을 지나친 다음, /model 로 바깥 프로필에
+ * 갈아타는 순간 아무것도 안 묻고 나간다. 실제로 그렇게 쓴다: 한 시간쯤
+ * 로컬로 하다가 「이건 큰 모델이 낫겠다」 하고 옮긴다.
+ *
+ * 허락은 프로필에 적힌다. 갈아탈 때마다 묻지 않는다.
+ */
+async function 나가도되나묻기(session, p) {
+  const 모드 = session.실행모드 ?? 지금모드({});
+  const 나감 = 나갈수있나(모드, { 바깥: 바깥인가(p.baseUrl), 허가: p.online === true });
+  if (나감.되나) return true;
+
+  const 어디 = 주소가리기((() => { try { return new URL(p.baseUrl).host; } catch { return String(p.baseUrl); } })());
+  if (!나감.물어볼까) {
+    // 봉인이다. 여기서 바꿔 주면 다음 한마디에서 막히는데, 그 화면만 보고는
+    // 왜 막혔는지 알 수 없다 — 바꾸기 전에 말하는 편이 언제나 낫다.
+    say(`  ${mark.warn} ${c.gray(`${어디} 는 이 컴퓨터 밖입니다. 지금은`)} ${c.white('봉인(--offline)')} ${c.gray('이라 안 바꿉니다.')}`);
+    say('');
+    return false;
+  }
+  say('');
+  say(`  ${c.yellow('↗')} ${c.bold(어디)} ${c.gray('는 이 컴퓨터 밖입니다.')}`);
+  say(`     ${c.gray('바꾸면 시킨 말과, 모델이 읽은 파일의 내용이 그리로 갑니다.')}`);
+  const 예 = await confirm('나가도 될까요? (한 번 허락하면 이 연결은 다음부터 안 묻습니다)', true);
+  if (!예) {
+    say(`  ${c.gray('안 바꿨습니다. 아무것도 안 보냈습니다.')}`);
+    say('');
+    return false;
+  }
+  p.online = true;
+  return true;
+}
+
+async function 골라적용(session, cfg, p) {
+  if (!await 나가도되나묻기(session, p)) return;
   cfg.active = p.id;
   try { save(cfg); } catch { /* 못 남겨도 이번 세션에는 바뀐다 */ }
   연결적용(session, p);
@@ -2691,6 +2791,9 @@ async function 모델만바꾸기(session, cfg, 모델) {
     // 반대로 큰 데서 작은 데로 옮기면 긴 대화에서 서버가 거절한다. 아래에서 다시 잰다.
     ctx: null,
   };
+  // 서버는 그대로지만 문은 같이 지난다. 등록 안 된 서버로 옮겨 가는 길도
+  // 여기라서, 여기를 열어 두면 자물쇠에 구멍이 하나 남는다.
+  if (!await 나가도되나묻기(session, p)) return;
   if (!이미) { try { save(upsert(cfg, p)); } catch { /* 못 남겨도 이번 세션에는 바뀐다 */ } }
   else { cfg.active = p.id; try { save(cfg); } catch {} }
   연결적용(session, p);

package/src/completion.js

@@ -23,6 +23,10 @@
  */
 import { MODES } from './agent/modes.js';
 import { LEVELS, PROFILES } from './agent/effort.js';
+// 승인 모드(auto·confirm·strict). agent/modes.js 의 MODES 와 헷갈리기 쉬운데,
+// 저쪽은 `--work` 가 받는 '무슨 일을 하는 중인가' 다. 실제로 한 번 뒤바뀌어
+// 있었다 — `--mode` 를 누르면 code·plan 이 나오고 `--work` 는 폴더를 냈다.
+import { 차례 as 승인모드 } from './ui/approve.js';
 
 /** deel 이 받는 명령. bin/deel.js 의 switch 와 같아야 한다(검사가 지킨다). */
 export const 명령들 = [
@@ -39,6 +43,7 @@ export const 명령들 = [
   { 이름: 'scan', 뜻: '게이트웨이에 어떤 모델이 있나 훑는다', en: 'scan the gateway for available models' },
   { 이름: 'sessions', 뜻: '지난 대화 목록', en: 'list past conversations' },
   { 이름: 'ls', 뜻: 'sessions 와 같다', en: 'same as sessions' },
+  { 이름: 'reset', 뜻: '설정·기억·기록을 지운다 (그냥 치면 보여만 준다)', en: 'wipe settings, memory and records (bare: just shows)' },
   { 이름: 'completion', 뜻: '탭 완성 스크립트를 낸다', en: 'print a tab-completion script' },
   { 이름: 'version', 뜻: '판 번호', en: 'version number' },
   { 이름: 'help', 뜻: '도움말', en: 'help' },
@@ -55,15 +60,29 @@ export const 숨은명령 = ['-p'];
  */
 export const 깃발들 = [
   { 이름: '--root', 뜻: '작업 폴더', en: 'working folder', 값: '폴더' },
-  { 이름: '--work', 뜻: '살림 폴더 (.deel 자리)', en: 'state folder (where .deel lives)', 값: '폴더' },
-  { 이름: '--mode', 뜻: '무엇을 할 수 있게 할까', en: 'what the agent is allowed to do', 값: Object.keys(MODES) },
+  /*
+   * 이 둘은 한 번 뒤바뀌어 있었다.
+   *
+   * `--mode` 는 **승인 모드**(auto·confirm·strict)인데 작업 모드 목록이
+   * 붙어 있었고, `--work` 는 **작업 모드**인데 「살림 폴더」 라고 적혀 폴더를
+   * 완성해 주고 있었다. 그래서 `deel --mode <탭>` 을 누르면 받지도 않는
+   * code·plan 이 나왔다.
+   *
+   * 검사도 이걸 못 잡았다 — 완성 목록이 agent/modes.js 에서 온 것이 맞나만
+   * 봤기 때문이다. 베낀 자리가 맞는지는 봤는데, 베껴 온 곳이 맞는지는 안 봤다.
+   * 지금은 도움말에 적힌 값과 맞춰 본다 (test/completion.test.js).
+   */
+  { 이름: '--work', 뜻: '무슨 일을 하는 중인가', en: 'what kind of work this is', 값: Object.keys(MODES) },
+  { 이름: '--mode', 뜻: '무엇까지 물어보지 않고 할까', en: 'how much it may do without asking', 값: 승인모드 },
   { 이름: '--level', 뜻: '화면을 얼마나 자세히', en: 'how much detail on screen', 값: null },
   { 이름: '--ctx', 뜻: '창 크기 (예: 32k)', en: 'context window size (e.g. 32k)', 값: null },
   { 이름: '--max-tokens', 뜻: '한 번에 뱉을 최대 토큰', en: 'max tokens per reply', 값: null },
   { 이름: '--think', 뜻: '생각의 양', en: 'how much thinking', 값: LEVELS },
   { 이름: '--effort', 뜻: '생각을 어디에 몰아줄까', en: 'where to spend the thinking budget', 값: Object.keys(PROFILES) },
+  { 이름: '--online', 뜻: '묻지 않고 바깥으로 나간다', en: 'go outside without asking', 값: false },
   { 이름: '--offline', 뜻: '바깥으로 아예 안 나간다', en: 'never reach the network', 값: false },
   { 이름: '--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 },
   { 이름: '--quiet', 뜻: '군말 없이', en: 'no chatter', 값: false },
   { 이름: '--tui', 뜻: '입력 상자를 켠다', en: 'force the input box on', 값: false },