deel-local-cli 1.1.1 → 1.4.0

package/src/agent/loop.js

@@ -6,11 +6,13 @@ import { isMutating } from '../safety/guard.js';
 import { effortFor, tokensFor, fullCap, wasCut, shiftLevel } from './effort.js';
 import { 살린쓰기 } from './salvage.js';
 import { 배울것, 길이문제인가 } from '../backend/learn.js';
-import { compact, shouldCompact } from './compact.js';
+import { compact, shouldCompact, shouldFold, foldToolResults } from './compact.js';
 import { 걸음수, 하위걸음수, 요약길이 } from './budget.js';
 import { Session } from './session.js';
 import { 최대깊이, 하위모드, 하위요약 } from '../tools/task.js';
-import { isOffline } from '../safety/network.js';
+import { 프로필찾기, 쓸수있나, 연결만들기, 알릴말, 목록보기 } from './models.js';
+import { allowTemporarily, isOffline } from '../safety/network.js';
+import { 가리기, 훑기, 가렸다는말, 봤다는말, 가릴도구 } from '../safety/secrets.js';
 import { get as workMode } from './modes.js';
 
 /**
@@ -57,16 +59,20 @@ export function 묶기(calls) {
 }
 
 export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 } = {}) {
-  session.push({ role: 'user', content: userText });
-  ctx.audit.turn(깊이 ? `[하위작업 ${깊이}겹] ${userText}` : userText);
   /*
    * 되돌리기 턴은 **부모만** 연다.
    *
    * 하위 작업이 제 턴을 열면 `/undo` 한 번이 하위가 만든 것만 되돌리고
    * 부모가 만든 것은 남긴다 — 반쪽만 되돌아간 폴더가 된다. 사람 눈에는
    * 한 번 시킨 일이니 한 번에 되돌아가야 맞다.
+   *
+   * 턴을 **사람 말을 넣기 전에** 연다. 그래야 그 말 자체가 이 턴의 첫 말로
+   * 표시되고, 되감을 때 시킨 말까지 같이 걷힌다. 시킨 말만 남으면 모델은
+   * 되돌린 일을 또 하려 든다.
    */
-  if (!깊이) ctx.history.nextTurn();
+  if (!깊이) session.턴시작(ctx.history.nextTurn());
+  session.push({ role: 'user', content: userText });
+  ctx.audit.turn(깊이 ? `[하위작업 ${깊이}겹] ${userText}` : userText);
 
   /*
    * 중단 신호를 도구도 볼 수 있게 여기 걸어 둔다.
@@ -95,7 +101,15 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
    * '헛도는 작업' 을 구분하지 못한다. 여기서는 같은 자리를 반복하는 것만 본다.
    */
   const 막힘 = new Map();
-  const MAX_SAME = 3;
+  /*
+   * 몇 번까지 봐 줄까는 **이 모델을 겪어 본 만큼** 정한다 (agent/card.js).
+   *
+   * 되풀이가 버릇인 모델에서는 세 번까지 기다릴 이유가 없다. 되풀이한 만큼
+   * 컨텍스트가 차고 그만큼 요약이 빨리 온다 — 걸음만 태우는 것이 아니다.
+   * 겪은 것이 모자라면 여태 쓰던 3 그대로다.
+   */
+  const 이카드 = ctx?.카드 ?? null;
+  const MAX_SAME = 이카드?.조정?.같은것한계 ?? 3;
   let 멈출까 = null;
   const 막힘셈 = (call, 이유) => {
     // 파일 하나가 아니라 **그 파일** 을 센다. 이름만 세면 서로 다른 파일 세 개를
@@ -194,6 +208,9 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
     work: session.effectiveWork(),                // 작업 모드가 쓰는 것만 (modes.js)
     // 밖에서 붙인 도구(MCP). 붙은 것이 없으면 아무것도 안 는다.
     mcp: ctx.mcp ?? null,
+    // 이 자리에 언어 서버가 있을 때만 Def·Refs 를 보여 준다 (tools/lsp.js).
+    // 없는 자리에서 목록에 세워 두면 모델이 부르고, 실패를 받고, 또 부른다.
+    lsp: session.lsp === true,
     // 창이 좁으면 도구 설명을 줄여 싣는다 (budget.js 의 설명길이).
     // 도구를 빼는 게 아니라 설명만 줄이므로 할 수 있는 일은 안 달라진다.
     ctx: conn.ctx ?? null,
@@ -240,6 +257,7 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
      * 세기만 한다 — 판단은 grade.js 가 하고, 프롬프트는 다음 걸음부터 달라진다.
      */
     session.본것?.걸음셈();
+    ctx.배움?.모델본것(conn.model, '걸음');
     // 단계마다 필요한 생각의 양이 다르다. effort.js 가 그 배분을 갖고 있다.
     const stage = steps === 1 ? 'plan' : lastToolFailed ? 'fix' : 'work';
     const level = effortFor(think, effort, stage);
@@ -247,7 +265,16 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
     // 출력 상한을 아는 값이 둘 있다 — 사용자가 정한 것(/out)과 서버에서 알아낸 것.
     // 사람이 정한 것이 먼저다. 둘 다 없으면 null 이고, 그때만 effort.js 의 MAX_CAP 에 선다.
     const room = { ctx: conn.ctx ?? 0, used: session.breakdown().used, max: conn.maxTokens ?? conn.maxOut ?? null };
-    const cap = tokensFor(effort, stage, room);
+    /*
+     * 이 모델이 인자를 자주 잘라 먹는다면 처음부터 넉넉히 준다 (agent/card.js).
+     *
+     * 지금은 잘린 **뒤에야** 상한을 올려 다시 부른다. 한 번은 반드시 버리는 셈이다.
+     * 잘리는 것이 이 모델의 버릇으로 재어졌다면 그 한 번을 매번 버릴 이유가 없다.
+     * 상한은 최댓값이지 정해진 길이가 아니라서, 짧게 답하는 턴에는 값이 안 든다.
+     */
+    const cap = 이카드?.조정?.상한먼저올리기
+      ? Math.max(tokensFor(effort, stage, room), fullCap(room))
+      : tokensFor(effort, stage, room);
     yield { type: 'stage', stage, level, cap, step: steps };
 
     const ask = (maxTokens, think) => ({
@@ -332,6 +359,7 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
       }
       if (빈답인가(msg)) {
         session.본것?.본것('빈답');
+        ctx.배움?.모델본것(conn.model, '빈답');
         yield {
           type: 'error',
           text: '서버가 빈 답을 보냈습니다.\n'
@@ -403,6 +431,16 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
     session.usage.out += msg.usage?.out ?? 0;
     session.usage.calls++;
 
+    /*
+     * 방금 보낸 것이 실제로 몇 토큰이었는지 서버가 알려 줬다. 우리 추정과
+     * 견줘서 배운다 — 여기가 유일하게 정답을 아는 자리다.
+     *
+     * 답을 push 하기 **전**이어야 한다. 지금 이력이 곧 방금 보낸 프롬프트다.
+     */
+    const 새보정 = session.배운다?.(msg.usage?.in);
+    // 배운 배수를 디스크에도 남긴다. 다음에 켤 때 이 값으로 시작한다.
+    if (새보정) ctx.배움?.보정본것(conn.model, 새보정);
+
     session.push(assistantMessage(conn.kind, msg));
 
     if (!msg.toolCalls?.length) {
@@ -438,6 +476,7 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
         // 모델은 고칠 게 없다고 보고 똑같이 다시 시도한다. 그래서 끝없이 돈다.
         if (call.argsBroken) {
           session.본것?.본것('잘린인자');
+          ctx.배움?.모델본것(conn.model, '잘린인자');
           // ── 버리기 전에, 건질 수 있는지 먼저 본다 ──────────────────────
           //
           // 잘린 JSON 안에는 이미 받아 놓은 내용이 들어 있다. 경로도 대개 온전하다.
@@ -579,7 +618,43 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
         }
 
         const 자식모드 = 하위모드(call.args?.모드 ?? call.args?.mode, 모드.id);
-        const 자식 = new Session(conn, {
+
+        /*
+         * ── 다른 모델에게 떼어 주기 ─────────────────────────────────────
+         *
+         * 안 적으면 지금 쓰는 것 그대로다. 적었으면 **사람이 설정에 적어 둔
+         * 프로필**에서만 찾는다 — 모델이 주소를 지어내면 그 자리로 나갈 뻔하고,
+         * 그건 이 프로그램이 하는 약속을 그 자리에서 깨는 것이다.
+         *
+         * 못 찾으면 조용히 지금 모델로 돌지 않는다. 시킨 쪽은 작은 모델에게
+         * 넘긴 줄 알고 창을 아끼고 있는데 실제로는 큰 모델이 다 받는 셈이라,
+         * 원인을 못 찾는 쪽으로 어긋난다. 무엇이 있는지 적어 되돌려 준다.
+         */
+        let 자식conn = conn;
+        let 자리닫기 = null;
+        let 모델알림 = null;
+        const 부른모델 = String(call.args?.모델 ?? call.args?.model ?? '').trim();
+        if (부른모델) {
+          const 찾음 = 프로필찾기(부른모델);
+          if (!찾음.ok) {
+            const 있는것 = 목록보기().map((x) => x.id).join(' · ') || '(설정에 프로필이 없습니다)';
+            거절(call, `${찾음.why}. 쓸 수 있는 이름: ${있는것}`);
+            yield { type: 'tool', name: 'Task', args: call.args, result: { error: 찾음.why }, showLabel: true };
+            continue;
+          }
+          const 되나 = 쓸수있나(찾음.prof);
+          if (!되나.ok) {
+            거절(call, `${부른모델} 은 지금 못 씁니다 — ${되나.why}`);
+            yield { type: 'tool', name: 'Task', args: call.args, result: { error: 되나.why }, showLabel: true };
+            continue;
+          }
+          자식conn = 연결만들기(찾음.prof);
+          모델알림 = 알릴말(conn, 자식conn);
+          // 그 일이 도는 동안만 연다. 끝나면 반드시 닫는다 — 아래 finally.
+          if (모델알림.다른자리) 자리닫기 = allowTemporarily(자식conn.base);
+        }
+
+        const 자식 = new Session(자식conn, {
           root: session.root,
           // 승인 방식은 그대로 물려준다. 하위가 승인을 우회하면 strict 가 거짓말이 된다.
           mode: session.mode,
@@ -591,7 +666,9 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
           // 부모보다 적게 준다 (budget.js). 사람이 직접 정한 값이 있으면 그 절반.
           maxSteps: session.stepsSet
             ? Math.max(4, Math.floor(session.maxSteps / 2))
-            : 하위걸음수(자식모드, conn.ctx),
+            // 걸음 수는 **하위가 쓸 창**으로 잰다. 부모 창으로 재면, 작은 모델에게
+            // 떼어 준 일이 제 창보다 큰 걸음 수를 받아 중간에 창이 찬 채로 돈다.
+            : 하위걸음수(자식모드, 자식conn.ctx),
         });
         // 스킬·명령·기억은 부모가 켤 때 한 번 찾아 든 것이다. 하위도 같은 것을 본다.
         자식.skills = session.skills;
@@ -609,8 +686,19 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
          * 미리 +1 을 해 두면 두 겹째에서 1이 두 번 붙어 3이 된다.
          * 경계선은 부모 자리에 그어야 어디부터가 떼어 낸 일인지 보인다.
          */
-        yield { type: 'task_start', 목적, 모드: 자식모드, steps: 자식.maxSteps };
-        ctx.audit.tool('Task', { 목적, 모드: 자식모드 }, { summary: `하위 작업 시작 (${깊이 + 1}겹)` });
+        /*
+         * 다른 모델을 쓰면 **어디로 나가는지까지** 적는다.
+         *
+         * 조용히 여는 것이 제일 나쁘다. 상태줄의 ⌂ 는 이 세션의 연결을 보고
+         * 있어서 하위가 딴 데로 나가는 것을 모른다. 그러니 이 줄과 감사기록이
+         * 그 사실을 남기는 유일한 자리다.
+         */
+        yield {
+          type: 'task_start', 목적, 모드: 자식모드, steps: 자식.maxSteps,
+          모델: 모델알림?.말 ?? null, 밖으로: 모델알림?.밖으로 ?? false,
+        };
+        ctx.audit.tool('Task', { 목적, 모드: 자식모드, 모델: 모델알림?.말 ?? null },
+          { summary: `하위 작업 시작 (${깊이 + 1}겹)${모델알림 ? ` · ${모델알림.말}` : ''}` });
 
         let 끝 = null;
         try {
@@ -634,6 +722,10 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
         } catch (err) {
           // 하위가 터져도 부모 턴은 살린다. 무엇 때문에 터졌는지는 요약에 실린다.
           끝 = { type: 'stuck', why: String(err?.message ?? err), steps: 0, files: [] };
+        } finally {
+          // 잠깐 열어 둔 자리는 무슨 일이 있어도 닫는다. 안 닫으면 그 세션이
+          // 끝날 때까지 그 주소가 열린 채로 남는다 — '한 자리만 연다' 가 깨진다.
+          try { 자리닫기?.(); } catch { /* 닫다 터져도 이번 턴은 이어간다 */ }
         }
 
         /*
@@ -651,13 +743,13 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
         session.usage.ms += 자식.usage.ms;
 
         const 글 = 하위요약({
-          목적, 모드: 자식모드, 끝,
+          목적, 모드: 자식모드, 끝, 모델: 모델알림?.말 ?? null,
           글자수: 요약길이(conn.ctx),
           보인이름: (경로) => ctx.scope?.show?.(경로) ?? 경로,
         });
         session.push(toolMessage(conn.kind, { callId: call.id, name: 'Task', content: 글 }));
         ctx.audit.tool('Task', { 목적 }, { summary: 글.slice(0, 300) });
-        yield { type: 'task_done', 목적, 모드: 자식모드, 끝 };
+        yield { type: 'task_done', 목적, 모드: 자식모드, 끝, 모델: 모델알림?.말 ?? null };
 
         // 사용자가 중단했으면 부모도 여기서 멈춘다. 하위만 끊고 이어가면
         // 무엇이 중단된 것인지 알 수 없는 화면이 된다.
@@ -704,6 +796,18 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
         if (call.name === 'Edit' && result.error) session.본것?.본것('편집실패');
         else if (!result.error) session.본것?.본것('도구성공');
 
+        /*
+         * 겪은 것을 디스크에도 쌓는다 (agent/evolve.js).
+         *
+         * 위의 지켜본것은 이 대화가 끝나면 사라진다. 그래서 어제 알아낸 것을
+         * 오늘 또 알아내야 했다 — `pnpm` 이 이 PC 에 없다는 걸 매일 다시 겪는다.
+         * 명령의 성패는 이 폴더의 사실이므로 폴더 쪽에 남긴다.
+         */
+        if (call.name === 'Bash' && call.args?.command) {
+          ctx.배움?.명령본것(call.args.command, !result.error, result.error ?? '');
+        }
+        if (call.name === 'Edit' && result.error) ctx.배움?.모델본것(conn.model, '편집실패');
+
         if (result.error) {
           lastToolFailed = true;
           // 같은 도구가 같은 이유로 계속 실패하면 헛돌고 있는 것이다.
@@ -735,12 +839,54 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
           }
         }
 
+        /*
+         * ── 비밀 가리기 ─────────────────────────────────────────────────
+         *
+         * 여기가 도구 결과가 대화로 들어가는 **유일한** 자리다. 여기서 막으면
+         * 모델에게도 안 가고 `.deel/sessions/*.jsonl` 에도 안 적힌다. 한 번
+         * 새면 두 벌이 되는 것을 한 곳에서 끊는다.
+         *
+         * 새는 자리는 거의 항상 명령 출력이다 — env · git remote -v · curl -v ·
+         * 검사 실패 로그. 그래서 그런 도구만 가린다.
+         *
+         * 파일에서 읽어 온 글은 **안 가린다.** 가리면 모델이 가려진 글을 보고
+         * 그대로 되돌려 써서, 진짜 열쇠가 있던 자리에 표가 적힌다 — 비밀을
+         * 지키려다 비밀을 지우는 셈이다. 대신 무엇이 들어왔는지 알린다.
+         */
+        const 아는열쇠들 = [conn.key, process.env.DEEL_API_KEY].filter(Boolean);
+        let 비밀 = [];
+        if (가릴도구.has(call.name)) {
+          const 가린 = 가리기(실을것, { 열쇠들: 아는열쇠들 });
+          if (가린.가린것.length) {
+            비밀 = 가린.가린것;
+            실을것 = 가린.글 + 가렸다는말(가린.가린것);
+          }
+        } else if (result.content) {
+          // 안 고치고 보기만 한다. 사람이 알아야 손을 쓸 수 있다.
+          비밀 = 훑기(실을것, { 열쇠들: 아는열쇠들 });
+        }
+        if (비밀.length) {
+          ctx.audit?.write?.('secret', {
+            tool: call.name,
+            가렸나: 가릴도구.has(call.name),
+            무엇: 비밀.map((x) => `${x.종류}×${x.몇번}`).join(' '),
+          });
+        }
+
         session.push(toolMessage(conn.kind, {
           callId: call.id,
           name: call.name,
           content: 실을것,
         }));
-        yield { type: 'tool', name: call.name, args: call.args, result, ms, parallel: 함께 };
+        yield {
+          type: 'tool',
+          name: call.name,
+          args: call.args,
+          result,
+          ms,
+          parallel: 함께,
+          ...(비밀.length ? { 비밀: { 가렸나: 가릴도구.has(call.name), 말: 봤다는말(비밀) } } : {}),
+        };
       }
     }
 
@@ -755,6 +901,18 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
       return;
     }
 
+    /*
+     * 요약해서 접기 **전에** 도구 결과부터 접는다.
+     *
+     * 자리를 먹는 것은 대개 사람 말이 아니라 옛날에 읽어 둔 파일이다. 그쪽을
+     * 먼저 비우면 요약 압축을 한참 미룰 수 있고, 미루는 동안 대화는 한 글자도
+     * 안 잃는다. 그래도 차면 아래에서 통째로 요약한다.
+     */
+    if (shouldFold(session)) {
+      const f = foldToolResults(session);
+      if (f.접은것) yield { type: 'folded', ...f };
+    }
+
     // 컨텍스트가 차오르면 오래된 대화를 '요약해서' 접는다. 그냥 자르면 하던 일을 잊는다.
     if (shouldCompact(session)) {
       yield { type: 'compacting' };

package/src/agent/models.js

@@ -0,0 +1,169 @@
+/**
+ * 한 세션 안에서 여러 모델 쓰기.
+ *
+ * ── 왜 필요한가 ────────────────────────────────────────────────────────
+ *
+ * 로컬에서는 모델 하나를 골라도 늘 어딘가 아쉽다. 7B 는 계획을 잘 세우는데
+ * 파일 열 개를 고치다 보면 창이 차고, 1.5B 는 창은 넉넉한데 무엇을 할지를
+ * 못 정한다. 클라우드였으면 큰 것 하나로 끝날 일인데, 8GB 램에서는 둘 다
+ * 올려 두고 **나눠 쓰는 것**이 실제로 가능한 유일한 길이다.
+ *   7B q4 (약 4.4GB) + 1.5B q4 (약 1.3GB) ≒ 5.7GB — 8GB 안에 들어간다.
+ *
+ * 그래서 두 자리를 연다.
+ *   Task 에 `모델`     큰 것이 계획을 쥐고, 잔일 한 덩이를 작은 것에 떼어 준다.
+ *   /ask <프로필>      지금 쓰던 것을 안 바꾸고 다른 모델에게 한 번 물어본다.
+ *
+ * ── 안 하는 것 ─────────────────────────────────────────────────────────
+ *
+ * 요약(compact)을 작은 모델에게 안 넘긴다. 요약은 '무엇을 버려도 되는가' 를
+ * 정하는 일이라 대화 전체를 제일 잘 아는 쪽이 해야 하는데, 그게 작은 모델이면
+ * 버려선 안 될 것을 버린다. 그 손해는 몇 턴 뒤에야 드러나고, 그때는 원인을
+ * 못 찾는다. 토큰 몇 푼 아끼자고 낼 값이 아니다.
+ *
+ * ── 경계선은 어떻게 되나 ───────────────────────────────────────────────
+ *
+ * 이게 이 파일에서 제일 조심한 자리다. deel 은 나갈 수 있는 자리를 **하나만**
+ * 연다(safety/network.js). 둘째 모델을 쓴다는 것은 그 자리를 하나 더 연다는
+ * 뜻이고, 그 자리가 바깥 게이트웨이면 "이 컴퓨터 안" 이 조용히 거짓이 된다.
+ *
+ *   1) 모델이 주소를 지어낼 수 없다. **사람이 설정에 적어 둔 프로필**만 쓴다.
+ *   2) 그 일이 도는 동안만 열고 끝나면 닫는다 (allowTemporarily).
+ *   3) 주소가 지금 쓰는 것과 다르면 **화면과 감사기록에 그렇게 적는다.**
+ *      조용히 열면 그게 제일 나쁘다.
+ *   4) 오프라인 잠금이면 이 컴퓨터 밖 프로필은 아예 못 쓴다.
+ */
+import { load, activeProfile, resolveKey } from '../config.js';
+import { isLocalHost, isOffline } from '../safety/network.js';
+
+// 컨텍스트를 못 알아냈을 때 쓰는 값. repl.js 와 같은 값을 봐야 한다.
+export const CTX_DEFAULT = 32768;
+
+/**
+ * 프로필 하나로 연결을 만든다.
+ *
+ * repl.js 도 이걸 쓴다. 두 군데서 따로 만들면 한쪽에만 손이 가고, 그러면
+ * `/ask` 로 부른 모델만 스트리밍이 꺼져 있다거나 하는 일이 생긴다 —
+ * 화면에는 "느리네" 로만 보이고 원인은 안 보인다.
+ */
+export function 연결만들기(prof, { ctx = null, maxTokens = null } = {}) {
+  if (!prof) return null;
+  return {
+    kind: prof.kind,
+    base: prof.baseUrl,
+    auth: prof.auth,
+    key: resolveKey(prof),
+    model: prof.model,
+    ctx: ctx ?? prof.ctx ?? CTX_DEFAULT,
+    maxTokens: maxTokens ?? prof.maxTokens ?? null,
+    streaming: prof.streaming ?? false,
+    tools: prof.tools ?? false,
+    json: prof.json ?? false,
+    think: prof.think ?? false,
+  };
+}
+
+/** 설정에 있는 프로필들. */
+export function 프로필들(cfg = load()) {
+  return Array.isArray(cfg?.profiles) ? cfg.profiles : [];
+}
+
+/**
+ * 이름으로 프로필 찾기.
+ *
+ * id → 이름 → 모델 이름 → 앞부분 일치 순으로 본다. 사람은 `/ask small ...`
+ * 처럼 기억나는 대로 치지, 설정에 적은 id 를 외우고 있지 않다.
+ *
+ * 앞부분 일치에서 **둘 이상 걸리면 고르지 않는다.** 아무거나 골라 주면
+ * 물어본 사람은 어느 모델이 답했는지 모른 채로 그 답을 믿게 된다.
+ */
+export function 프로필찾기(이름, cfg = load()) {
+  const q = String(이름 ?? '').trim().toLowerCase();
+  if (!q) return { ok: false, why: '없음', 후보: [] };
+  const 목록 = 프로필들(cfg);
+  if (!목록.length) return { ok: false, why: '설정에 프로필이 하나도 없습니다', 후보: [] };
+
+  const 딱 = 목록.find((p) => String(p.id).toLowerCase() === q)
+    ?? 목록.find((p) => String(p.name ?? '').toLowerCase() === q)
+    ?? 목록.find((p) => String(p.model ?? '').toLowerCase() === q);
+  if (딱) return { ok: true, prof: 딱, 후보: [딱] };
+
+  const 걸린것 = 목록.filter((p) => [p.id, p.name, p.model]
+    .some((v) => String(v ?? '').toLowerCase().includes(q)));
+  if (걸린것.length === 1) return { ok: true, prof: 걸린것[0], 후보: 걸린것 };
+  if (걸린것.length > 1) {
+    return { ok: false, why: `'${이름}' 에 여러 개가 걸립니다`, 후보: 걸린것 };
+  }
+  return { ok: false, why: `'${이름}' 이라는 프로필이 없습니다`, 후보: [] };
+}
+
+/**
+ * 이 프로필로 나가도 되는가.
+ *
+ * 오프라인 잠금은 여기서도 지킨다. 잠갔는데 하위 작업만 밖으로 나가면,
+ * 잠금은 화면에만 있고 실제로는 안 잠긴 것이 된다.
+ */
+export function 쓸수있나(prof) {
+  if (!prof?.baseUrl) return { ok: false, why: '주소가 없는 프로필입니다' };
+  let 로컬 = false;
+  try { 로컬 = isLocalHost(new URL(prof.baseUrl).hostname); } catch {
+    return { ok: false, why: `주소를 읽을 수 없습니다: ${prof.baseUrl}` };
+  }
+  if (isOffline() && !로컬) {
+    return { ok: false, why: '오프라인 잠금 중입니다 — 이 컴퓨터 밖 프로필은 못 씁니다' };
+  }
+  return { ok: true, 로컬 };
+}
+
+/** 두 주소가 같은 자리인가. 다르면 사람에게 알려야 한다. */
+export function 같은자리(a, b) {
+  try { return new URL(a).origin === new URL(b).origin; } catch { return false; }
+}
+
+/**
+ * 다른 모델을 쓸 때 화면과 감사기록에 남길 한 줄.
+ *
+ * 같은 자리면 모델 이름만, 다른 자리면 **어디로 나가는지**까지 적는다.
+ * 이 줄이 없으면 사람은 제 소스가 어느 서버로 갔는지 알 방법이 없다.
+ * @returns {{말: string, 밖으로: boolean, 다른자리: boolean}}
+ */
+export function 알릴말(지금conn, 새conn) {
+  const 다른자리 = !같은자리(지금conn?.base, 새conn?.base);
+  let 밖으로 = false;
+  try { 밖으로 = !isLocalHost(new URL(새conn.base).hostname); } catch { 밖으로 = true; }
+  if (!다른자리) return { 말: `모델 ${새conn.model}`, 밖으로, 다른자리 };
+  let 어디 = 새conn.base;
+  try { 어디 = new URL(새conn.base).host; } catch { /* 못 읽으면 통째로 */ }
+  return {
+    말: `모델 ${새conn.model} · ${밖으로 ? '바깥' : '이 컴퓨터 안'} ${어디}`,
+    밖으로,
+    다른자리,
+  };
+}
+
+/**
+ * 지금 붙어 있는 프로필. `/ask` 가 '나 자신에게 묻기' 를 걸러낼 때 쓴다.
+ */
+export function 지금프로필(cfg = load()) {
+  return activeProfile(cfg);
+}
+
+/**
+ * 화면에 낼 프로필 한 줄들.
+ * @returns {{id:string, name:string, model:string, 어디:string, 로컬:boolean, 지금:boolean}[]}
+ */
+export function 목록보기(cfg = load()) {
+  const 지금 = 지금프로필(cfg);
+  return 프로필들(cfg).map((p) => {
+    let 어디 = String(p.baseUrl ?? '');
+    let 로컬 = false;
+    try { const u = new URL(p.baseUrl); 어디 = u.host; 로컬 = isLocalHost(u.hostname); } catch { /* 못 읽으면 통째로 */ }
+    return {
+      id: p.id,
+      name: p.name ?? p.id,
+      model: p.model ?? '',
+      어디,
+      로컬,
+      지금: 지금?.id === p.id,
+    };
+  });
+}

package/src/agent/modes.js

@@ -13,7 +13,9 @@
 // 읽기만 하는 도구. 무엇을 바꾸지 않는다.
 // Recall 은 지난 대화를 찾는다 — 파일은 안 건드리므로 읽기 쪽이다.
 // 묻기 모드에도 준다: "저번에 이거 어떻게 했더라" 가 딱 묻기 모드의 일이다.
-const 읽기 = ['Read', 'Outline', 'Glob', 'Grep', 'WebFetch', 'Skill', 'Recall'];
+// Def·Refs 도 읽기다 — 아무것도 안 바꾼다. 언어 서버가 없는 자리에서는
+// toolSchemas 가 알아서 빼므로 여기서는 갈래만 정한다.
+const 읽기 = ['Read', 'Outline', 'Glob', 'Grep', 'Def', 'Refs', 'WebFetch', 'Skill', 'Recall'];
 // 계획을 적는 도구. 파일을 안 건드리므로 읽기 전용 모드에서도 준다.
 //
 // Remember 도 여기 있다. 기억은 사용자의 소스를 안 건드리고 .deel/memory.md
@@ -43,6 +45,8 @@ const 확인 = ['Verify'];
  */
 const 쪼개기 = ['Task'];
 
+import { 언어 } from '../i18n/index.js';
+
 export const MODES = {
   // 처음에는 여기서 시작한다.
   //
@@ -54,6 +58,9 @@ export const MODES = {
   // 뒤집지 않는다. 다시 맡기려면 /work 종합 이다.
   auto: {
     id: 'auto',
+    hintEn: "picks the right mode for what you ask",
+    sayEn: "You are in **Auto** mode. What comes next is not fixed.\n\n- Work out what kind of job this is first, then do it that way.\n  If it is an edit, read before editing. If it is a diagnosis, confirm before concluding.\n  If it is an explanation, back it with the files.\n- For a large job, break it into steps with TodoWrite and **finish everything you wrote down.**\n  Do not write the list and then ask. If there are several chunks, hand them off with Task —\n  a subtask runs in its own window, so yours does not fill up.\n- For code you did not write, look at the shape with Outline first. Do not Read whole files.\n- Making several files: one Write call (files array). Do not call it once per file.\n  Several places to edit: one Edit call the same way (edits array).\n- Commands that never end (dev servers, watch) need background: true on Bash. Called plainly\n  they die on timeout. After starting one, read its output with Jobs, and end it with Jobs when done.\n- Verify what can be verified — call Verify. Do not call something done that you did not check.\n- Do what the job needs. Do not start work the job did not ask for.",
+    say짧게En: "**Auto** mode. What comes next is not fixed.\n- Work out what kind of job this is, then do it that way.\n- Large job: break it up with TodoWrite and **finish it all.** Several chunks: hand off with Task.\n- Code you did not write: Outline for the shape first. Do not Read whole files.\n- Several files: one Write (files array). Several edits: one Edit (edits array).\n- Commands that never end (dev server, watch): background: true on Bash. Read with Jobs, end with Jobs.\n- Verify before you finish. Do not call something done that you did not check.",
     name: '종합',
     en: 'Auto',
     glyph: '◎',
@@ -91,6 +98,9 @@ export const MODES = {
 
   code: {
     id: 'code',
+    hintEn: "edits and builds",
+    sayEn: "This is **implementation**. Follow this order.\n\n1. For code you did not write, look at the **shape first** with Outline. Do not Read whole\n   files — a folder through Outline is a fraction of the size.\n   Pick the places to change there, then Read **only those files**.\n2. Always Read a file before editing it. The tool refuses an edit to a file you have not read.\n3. Follow the conventions of the surrounding code — naming, error handling, comment density.\n   Do not import a new convention. Do what this code already does.\n4. Make and change every file the job needs. Do not touch one file and stop.\n   For something new, lay out the folder structure first and create **several files in one Write**\n   (files array). Several places to change go in **one Edit** (edits array).\n   One call per item adds that many round trips, and minutes go with them.\n5. If the work splits into separate strands, hand a chunk off with Task.\n   A subtask runs in its own window and returns only a summary — your window does not fill up.\n6. **Call Verify before you finish.** A file existing and a file working are different things.\n   Fix what comes back and call it again. Say \"I could not verify this\" for anything you did not check.\n   For things you only learn by running (dev servers, watch), give Bash **background: true**.\n   Called plainly they never end and die on timeout. Read output with Jobs, and always end it\n   with Jobs when done — otherwise that server keeps holding the port.\n7. When done, say what you changed and why in a line or two. Do not paste the code back.",
+    say짧게En: "**Implementation.** Follow this order.\n1. Code you did not write: Outline for the shape. Pick the places, then Read **only those files**.\n2. Always Read a file before editing it.\n3. Follow the surrounding conventions. Do not import a new one.\n4. Several files: one Write (files array). Several edits: one Edit (edits array).\n5. Several strands: hand off with Task.\n6. **Verify before you finish.** Fix what comes back and call it again.\n   If it must be run, Bash with background: true — called plainly it dies on timeout. Read with Jobs, end with Jobs.\n7. Say what changed and why in a line or two. Do not paste code.",
     name: '코드',
     en: 'Code',
     glyph: '◆',
@@ -137,6 +147,8 @@ export const MODES = {
 
   architect: {
     id: 'architect',
+    hintEn: "shapes the structure · touches no files",
+    sayEn: "This is **design**. You have not been given the tools that change files.\n\nRead first. Designing without knowing the current structure is imagining, not designing.\n  - Start with Outline for the shape of the folder. Narrow with Glob/Grep,\n    then actually Read only the files you need\n  - Work out what depends on what, and in which direction\n\nThen answer in this order.\n  1. Current structure — files, their roles, where the boundaries are (point with path:line)\n  2. What is wrong — why the current shape does not hold\n  3. Two or three options — what each gains, what each costs, how much work it is\n  4. One recommendation with the reason, and why you dropped the others\n  5. The files this affects\n\nFind the answer inside the conventions this code already uses. Bringing in a new framework is\nthe last resort, and if you go there, first say why the existing conventions cannot do it.",
     name: '설계',
     en: 'Architect',
     glyph: '◈',
@@ -166,6 +178,8 @@ export const MODES = {
 
   ask: {
     id: 'ask',
+    hintEn: "explains only · changes nothing",
+    sayEn: "This is **explanation**. You change nothing.\n\n- Back it with the files. Give the path and line number (src/a.js:42).\n- If you do not know, say so. Do not invent a plausible answer.\n- Keep it short. Answer what was asked.\n- Do not propose fixes unless asked to fix something. Do not start work you were not asked for.",
     name: '묻기',
     en: 'Ask',
     glyph: '◇',
@@ -185,6 +199,8 @@ export const MODES = {
 
   debug: {
     id: 'debug',
+    hintEn: "finds the cause",
+    sayEn: "This is **finding the cause**. Do not fix by guessing.\n\nFollow this order.\n  1. Restate the symptom in one sentence — what happens when you do what.\n  2. Get a reproduction. If there is none, build one. Without it you cannot tell whether you fixed it.\n  3. Form two or three hypotheses. For each, write down what you should see if it is true.\n  4. Check them one at a time, for real — read the logs, run something small, print the value.\n     Only what you checked is fact. What you did not check is still a hypothesis.\n  5. When you name the cause, bring the evidence. A cause that starts with \"probably\" is not a cause.\n  6. After fixing, run the reproduction from step 2 again. If it is not fixed, go back to step 3.\n\nDo not change several places at once. You will not know which one fixed it.",
     name: '디버그',
     en: 'Debug',
     glyph: '◉',
@@ -210,6 +226,8 @@ export const MODES = {
 
   plan: {
     id: 'plan',
+    hintEn: "plan first · run it after approval",
+    sayEn: "This is **planning**. You have not been given the tools that change files.\nDo not try to edit code. Produce a plan and stop.\n\nConfirm first — a plan built without knowing the current state is a wish, not a plan.\n  Start with Outline for the shape, narrow with Glob/Grep, then Read only what you must.\n\nThen write it in this order.\n  1. Goal — what does \"done\" look like (as a sentence you can check)\n  2. Current state — the files involved and what they do now (point with path:line)\n  3. What changes — per file, what and why\n  4. Order — step by step. Each step small enough to check on its own\n  5. Risks — what could break, and how to get back if it does\n  6. How to check — what do you run to know it worked\n\nWrite the steps into TodoWrite as well. After approval you continue straight from them.\n  The number of steps is not fixed — match it to the size of the job. Do not force it to three.\n  A small job ends in two or three; a large one lists all ten or more.\nIf something is unknown, do not invent it — write \"this needs to be confirmed\".\n\nEnd with \"Shall I go ahead with this?\". Once approved, switch to /code and run it.",
     name: '계획',
     en: 'Plan',
     glyph: '☰',
@@ -233,6 +251,8 @@ export const MODES = {
       "  6. 확인 방법 — 무엇을 돌려 보면 됐는지 알 수 있는가",
       "",
       "단계는 TodoWrite 로도 적어라. 승인 뒤 그대로 이어서 하게 된다.",
+      "  단계 수는 정해져 있지 않다 — 일의 크기에 맞춰라. 세 개로 맞추지 마라.",
+      "  작은 일이면 두세 개로 끝내고, 큰 일이면 열 개가 넘어도 그대로 다 적어라.",
       "모르는 것이 있으면 지어내지 말고 \"이건 확인이 필요하다\" 고 적어라.",
       "",
       "마지막에 \"이대로 진행할까요?\" 로 끝내라. 승인을 받으면 /code 로 바꿔 실행한다.",
@@ -241,6 +261,9 @@ export const MODES = {
 
   orchestrator: {
     id: 'orchestrator',
+    hintEn: "splits a big job and sees it through",
+    sayEn: "This is **carrying a large job through to the end**.\n\n  1. Right at the start, break the whole thing into steps with TodoWrite. Do not keep it in your head.\n     Each step must be small enough to check on its own.\n  2. **Hand every single step off with Task.** This is the point of this mode —\n     if you do it all yourself, every file's contents pile up in your window, and by the third or\n     fourth step the earlier turns fold away and you forget what you were doing.\n     Give the subtask the background, the decisions, and the file paths. It cannot see this conversation.\n  3. Keep only one step in progress at a time. Mark it done and move on immediately.\n  4. Verify at the end of each step. Skipping it means you cannot find where things went wrong.\n  5. If you get stuck, stop and report what you are stuck on. Do not quietly take a detour.\n  6. If you learn the plan was wrong, fix the list. Do not push a wrong plan to the end.\n\nWhen it is all done, summarise what you did **and** what you did not.\nDo not leave the unfinished parts out of the summary.",
+    say짧게En: "**Carrying a large job through.**\n1. Break the whole thing into steps with TodoWrite right at the start.\n2. **Hand every step off with Task.** Doing it all yourself fills your window and you forget the job.\n   The subtask cannot see this conversation — give it the background, decisions, and file paths.\n3. One step in progress at a time. Mark it done and move on.\n4. Verify at the end of every step.\n5. If you get stuck, stop and report. Do not quietly take a detour.\nWhen done, summarise what you did and what you did not. Do not leave the unfinished parts out.",
     name: '총괄',
     en: 'Orchestrator',
     glyph: '❋',
@@ -314,9 +337,34 @@ export function get(id) {
 export function 말(id, ctx) {
   const m = get(id);
   const 좁은가 = Number(ctx) > 0 && Number(ctx) < 24000;
+  /*
+   * 화면 말이 영어면 **모델이 읽는 글도** 영어로 간다.
+   *
+   * 화면만 영어로 갈아 끼우고 이 글을 한국어로 두면, 모델은 계속 한국어로
+   * 답한다 — 영어권 사람에게는 아무것도 안 고친 것과 같다.
+   *
+   * 영어 글이 없는 모드는 한국어 글로 되돌아간다. 빈 글을 보내면 그 모드는
+   * 아무 지시도 없는 채로 도는데, 그게 화면 빈칸보다 훨씬 나쁘다 —
+   * 모드가 있는 것처럼 보이면서 실제로는 아무 일도 안 한다.
+   */
+  if (언어() === 'en') {
+    if (좁은가 && m.say짧게En) return m.say짧게En;
+    if (m.sayEn) return m.sayEn;
+  }
   return (좁은가 && m.say짧게) ? m.say짧게 : m.say;
 }
 
+/** 화면에 낼 모드 이름·한 줄 설명. 영어 것이 없으면 한국어로 되돌아간다. */
+export function 보일이름(id) {
+  const m = get(id);
+  return 언어() === 'en' ? (m.en ?? m.name) : m.name;
+}
+
+export function 보일한줄(id) {
+  const m = get(id);
+  return 언어() === 'en' ? (m.hintEn ?? m.hint) : m.hint;
+}
+
 /** Ctrl+O 로 돌릴 때 다음 모드. (Shift+Tab 은 승인 방식이 가져갔다) */
 export function next(id) {
   const i = ORDER.indexOf(normalize(id) ?? DEFAULT);