deel-local-cli 1.20.13 → 2.0.1

package/src/ui/prompt.js

@@ -1,5 +1,5 @@
 // 입력 받기 — 한 줄, 비밀번호(가림), 목록 선택, 예/아니오.
-import { c, say } from './ansi.js';
+import { c, say, width } from './ansi.js';
 
 function raw() {
   return process.stdin.isTTY ? process.stdin.setRawMode.bind(process.stdin) : null;
@@ -24,18 +24,87 @@ function readKeys(onKey) {
   });
 }
 
+/*
+ * ── ESC 로 시작하는 순서는 **통째로** 뗀다 ──────────────────────────────
+ *
+ * 예전에는 ESC 한 글자만 버리고 뒤따르는 것은 글자로 담았다. 화살표 하나가 `[D`, Delete 가
+ * `[3~`, 붙여넣기 표시가 `[200~` … `[201~` 로 남았다. `deel setup` 의 API 키 물음은 ● 로 가려
+ * 있어서 사람은 그걸 볼 수가 없다 — 오타를 고치려고 왼쪽 화살표를 한 번 누르면 열쇠가 조용히
+ * 틀어져 저장되고, 붙을 때 401 이 난다. 무엇이 틀렸는지는 아무 데도 안 남는다.
+ *
+ * 이 물음은 커서를 옮기는 편집기가 아니다(끝에 붙이고 끝에서 지우기만 한다). 그래서 화살표·Home·
+ * Delete 는 **아무 일도 안 하는 것**이 맞고, 붙여넣기 표시는 벗기고 알맹이만 받는다.
+ *
+ * 돌려주는 값: 순서의 마지막 글자 자리. 순서가 이 토막 끝에서 끊겼으면 -1 — 느린 원격 터미널은
+ * `ESC [` 와 `3~` 를 두 토막으로 보낸다. 그때는 남겨 뒀다가 다음 토막 앞에 붙여 다시 본다.
+ */
+function 순서끝(글자들, i) {
+  const 둘째 = 글자들[i + 1];
+  if (둘째 === undefined) return -1;
+  if (둘째 === '[') {
+    // CSI — 매개 글자(0x30–0x3F)·사이 글자(0x20–0x2F) 뒤에 마침 글자(0x40–0x7E) 하나.
+    for (let j = i + 2; j < 글자들.length; j++) {
+      const k = 글자들[j].charCodeAt(0);
+      if (k >= 0x40 && k <= 0x7e) return j;
+      // 순서에 올 수 없는 글자(엔터·한글 …)가 끼었다. 거기서 끊고 그 글자는 제대로 읽게 둔다.
+      if (k < 0x20 || k > 0x3f) return j - 1;
+    }
+    return -1;
+  }
+  // SS3 — 일부 터미널의 화살표·F1~F4 (ESC O A).
+  //
+  // 셋째 글자를 무엇이든 끝 글자로 먹었다. ESC 를 누르고 O 를 치고 엔터를 치면 엔터가 순서의 끝으로
+  // 사라져 물음이 안 끝났다. SS3 의 끝 글자는 0x40–0x7E 뿐이다 — 아니면 홑 ESC(Alt+O)로 본다.
+  if (둘째 === 'O') {
+    const 셋째 = 글자들[i + 2];
+    if (셋째 === undefined) return -1;
+    const k = 셋째.charCodeAt(0);
+    return k >= 0x40 && k <= 0x7e ? i + 2 : i;
+  }
+  // 홑 ESC (ESC 키 · Alt+글자). 여태처럼 ESC 만 떼고 뒤 글자는 글자로 둔다.
+  return i;
+}
+
+/*
+ * ── 앞 물음이 덩이 끝의 \r 에서 끝났나 (Gemini 화면4) ──────────────────────
+ *
+ * CRLF 로 적은 답 파일을 파이프로 흘리면 `ans1\r` | `\nans2\r\n` 처럼 \r 과 \n 이 **두 덩이에
+ * 갈려** 올 수 있다. 첫 물음은 \r 에서 끝나고, 그 \n 은 다음 물음이 받아 **엔터로** 읽었다 —
+ * 빈 답이 끼고 뒤의 답이 한 칸씩 밀린다(주소 물음에 모델 이름이 들어간다). 한 덩이 안의 CRLF
+ * 는 이미 한 번으로 친다(아래). 덩이 사이는 물음이 바뀌므로 이 모듈이 기억한다.
+ *
+ * 다음 덩이의 **맨 앞 \n 하나만** 삼키고, **파이프일 때만** 기억한다. 터미널(raw)은 엔터를 늘 덩이 끝
+ * \r 하나로 보내 CRLF 가 갈릴 일이 없다 — 거기서도 기억하면 엔터 뒤 첫 키로 친 Ctrl+J(\n)가 먹혀
+ * 물음이 안 끝났다(Gemini 화면5).
+ */
+let 덩이끝CR = false;
+
 // 한 줄 입력. mask=true 면 ● 로 가린다.
 export function ask(label, { mask = false, def = '' } = {}) {
   const prefix = `  ${c.gray('›')} ${label} `;
   process.stdout.write(prefix + (def ? c.gray(`[${def}] `) : ''));
   let buf = '';
+  // 앞 토막 끝에서 끊긴 ESC 순서. 다음 토막 앞에 붙여 다시 본다.
+  let 꼬리 = '';
   return readKeys((ch, done) => {
     // 글자 단위로 훑되 자리를 기억한다. 엔터에서 멈출 때 '남은 것' 을 알아야 해서다.
-    const 글자들 = [...ch];
-    for (let i = 0; i < 글자들.length; i++) {
+    const 글자들 = [...(꼬리 + ch)];
+    꼬리 = '';
+    let 시작 = 0;
+    if (덩이끝CR) {
+      덩이끝CR = false;
+      if (글자들[0] === '\n') 시작 = 1;
+    }
+    for (let i = 시작; i < 글자들.length; i++) {
       const ch1 = 글자들[i];
       const code = ch1.charCodeAt(0);
       if (code === 3) { say(''); process.exit(130); }            // Ctrl+C
+      if (code === 27) {                                         // ESC 순서
+        const 끝 = 순서끝(글자들, i);
+        if (끝 === -1) { 꼬리 = 글자들.slice(i).join(''); break; }
+        i = 끝;
+        continue;
+      }
       if (code === 13 || code === 10) {                          // Enter
         say('');
         // 한 덩어리에 여러 줄이 실려 올 수 있다 — 붙여넣기, 파이프 입력, 느린 터미널.
@@ -45,14 +114,32 @@ export function ask(label, { mask = false, def = '' } = {}) {
         // 그래서 되돌려 놓는다 — 다음에 읽는 쪽이 받아 간다.
         let 다음 = i + 1;
         if (code === 13 && 글자들[다음] === '\n') 다음++;         // CRLF 는 한 번으로 친다
+        else if (code === 13 && 다음 === 글자들.length && !process.stdin.isTTY) 덩이끝CR = true; // \n 이 다음 덩이로 갈렸을 수 있다 (덩이끝CR 머리말)
         const 남은것 = 글자들.slice(다음).join('');
+        /*
+         * **먼저 손을 떼고** 되돌린다.
+         *
+         * 거꾸로 했었다 — 되돌리고 나서 done 으로 손을 뗐다. 그런데 흐르는 중인 입력에
+         * unshift 하면 그 자리에서 곧바로 'data' 가 다시 난다. 그걸 받는 것은 **아직 붙어
+         * 있는 이 물음**이라, `first\nsecond\n` 이 한 덩어리로 오면 첫 물음이 「firstsecond」
+         * 를 받고 둘째 물음은 영영 답을 못 받았다. `echo … | deel setup` 이 그 길이다.
+         * 손을 떼면(멈춤) 되돌린 것은 버퍼에 가만히 있다가 다음 물음이 받아 간다.
+         */
+        const 끝남 = done(buf.length ? buf : def);
         if (남은것) { try { process.stdin.unshift(남은것); } catch { /* 못 돌려놔도 이 줄은 살린다 */ } }
-        return done(buf.length ? buf : def);
+        return 끝남;
       }
       if (code === 127 || code === 8) {                          // Backspace
         if (buf.length) {
-          buf = buf.slice(0, -1);
-          process.stdout.write('\b \b');
+          /*
+           * 코드 단위가 아니라 **글자 하나**를 지운다. 그림글자는 UTF-16 두 토막이라
+           * 한 토막만 떼면 반쪽 글자가 열쇠·이름에 남는다 — 화면에는 안 보이고 값만 깨진다.
+           * 지운 칸 수도 글자 폭만큼이다 — 한글 하나를 한 칸만 지우면 반쪽이 화면에 남는다.
+           */
+          const 뗀것 = [...buf].pop();
+          buf = buf.slice(0, -뗀것.length);
+          const 칸 = mask ? 1 : Math.max(1, width(뗀것));
+          process.stdout.write('\b'.repeat(칸) + ' '.repeat(칸) + '\b'.repeat(칸));
         }
         continue;
       }
@@ -63,6 +150,21 @@ export function ask(label, { mask = false, def = '' } = {}) {
   });
 }
 
+/*
+ * 지금 암호를 받는 중인 readline 들.
+ *
+ * 암호는 **일하는 도중에** 묻는다(엑셀 도구). 그 동안 repl 의 입력 상자는 rl.line 을 「미리
+ * 쳐 둔 글」 로 그리고, Enter 친 줄을 「예약된 다음 말」 로 다룬다 — 둘 다 암호를 글자 그대로
+ * 다룬다는 뜻이다. 가로챌 것은 되비추기(_writeToOutput)만이 아니었다. 그래서 가리는 중인지를
+ * 밖에서 물어볼 수 있게 둔다(가림중).
+ */
+const 가리는rl = new WeakSet();
+
+/** 이 readline 이 지금 암호를 받는 중인가. repl 이 입력 상자에 그 글을 그릴지 정할 때 본다. */
+export function 가림중(rl) {
+  return !!rl && typeof rl === 'object' && 가리는rl.has(rl);
+}
+
 /**
  * REPL 안에서 암호를 받는다. 화면에 안 찍히게.
  *
@@ -80,23 +182,61 @@ export async function askHidden(rl, label, nextLine) {
   const 원래 = typeof rl?._writeToOutput === 'function' ? rl._writeToOutput : null;
   if (원래) {
     rl._writeToOutput = function (s) {
-      // 줄바꿈·지우기 같은 제어는 그대로 두고, 글자만 가린다.
-      if (/^[\r\n]+$/.test(s) || s.startsWith('\x1b')) return 원래.call(this, s);
-      this.output.write(c.gray('●'.repeat([...s].length)));
+      /*
+       * 줄바꿈·제어 순서는 그대로 두고, 글자만 가린다 — **한 덩이 안에서** 갈라서.
+       *
+       * 첫 글자가 ESC 면 통째로 제어로 보고 흘렸었다. 그런데 readline 은 지우개·화살표에서 줄을
+       * 새로 그리며 「프롬프트 + 지금까지 친 글」 을 한 번에 넘긴다. 프롬프트에 색이 입혀져 있으면
+       * 그 첫 글자가 ESC 라, 친 암호가 글자 그대로 화면에 찍혔다(Gemini 화면4). 맨 프롬프트면
+       * 거꾸로 프롬프트까지 ● 로 덮였다.
+       *
+       * 그래서 앞의 프롬프트는 가리지 않고 떼어 두고, 나머지에서 제어 순서·줄바꿈만 살리고 글자는
+       * 전부 ● 로 바꾼다.
+       */
+      const 글 = String(s);
+      const 프롬프트 = typeof this.getPrompt === 'function' ? String(this.getPrompt() ?? '') : '';
+      const 앞 = 프롬프트 && 글.startsWith(프롬프트) ? 프롬프트 : '';
+      const 가림 = 글.slice(앞.length).replace(/(\x1b\[[0-?]*[ -/]*[@-~])|([\r\n]+)|([^\x1b\r\n]+)/g,
+        (통, 순서, 줄, 글자) => (글자 ? c.gray('●'.repeat([...글자].length)) : 통));
+      return 원래.call(this, 앞 + 가림);
     };
   } else {
     process.stdout.write(c.gray('(입력해도 화면에 안 보입니다) '));
   }
 
+  /*
+   * ── 입력 이력에 안 남긴다 ────────────────────────────────────────────
+   *
+   * readline 은 Enter 친 줄을 이력(historySize)에 쌓는다. 암호도 한 줄이라 그대로 쌓였다 —
+   * 암호를 넣고 나서 다음 입력칸에서 위 화살표를 한 번 누르면 암호가 글자 그대로 되살아났다.
+   * 어깨너머로 보이는 것은 물론이고, 그 줄을 모르고 Enter 치면 모델에게 간다.
+   *
+   * 받은 줄을 이력에서 **도로 뺀다.** 받는 동안 이력을 끄는 길(historySize = 0)은 못 쓴다 — Node 의
+   * readline 은 historySize 를 읽기만 하게 막아 두었다(대입하면 던진다). readline 은 줄을 이력
+   * **맨 앞**에 끼운 뒤에 'line' 을 쏘고, 우리는 그 줄을 받은 바로 그 자리에서 빼므로 그 사이에
+   * 다른 줄이 끼어들 틈이 없다.
+   */
+  const 이력 = Array.isArray(rl?.history) ? rl.history : null;
+  const 표시할수있나 = !!rl && typeof rl === 'object';
+  if (표시할수있나) 가리는rl.add(rl);
+
   try {
     const a = await nextLine();
+    if (이력 && a !== null && 이력[0] === a) 이력.shift();
     return a === null ? null : a.trim();
   } finally {
     if (원래) rl._writeToOutput = 원래;
+    if (표시할수있나) 가리는rl.delete(rl);
     say('');
   }
 }
 
+// 전각 숫자(０–９)를 보통 숫자로. 일본어·중국어 입력기는 번호를 이렇게 낸다.
+const 숫자펴기 = (s) => String(s ?? '').replace(/[０-９]/g, (d) => String.fromCharCode(d.charCodeAt(0) - 0xfee0));
+
+// 없는 번호를 몇 번까지 되묻나. 끝이 있어야 같은 틀린 답이 계속 오는 자리에서 안 멈춘다.
+const 되묻기 = 2;
+
 // 목록에서 번호로 고르기.
 // REPL 안에서는 readline 이 stdin 을 쥐고 있으므로 ask 를 갈아끼워 쓴다.
 export async function pick(label, items, { def = 0, ask: askFn = ask } = {}) {
@@ -109,10 +249,33 @@ export async function pick(label, items, { def = 0, ask: askFn = ask } = {}) {
     say(`    ${c.cyan(String(i + 1).padStart(2))}  ${line}${note}${tag}`);
   });
   say('');
-  const raw = await askFn('번호', { def: String(def + 1) });
-  const n = parseInt(raw, 10);
-  if (!Number.isFinite(n) || n < 1 || n > items.length) return def;
-  return n - 1;
+  /*
+   * ── 없는 번호는 말없이 기본값으로 가지 않는다 ──────────────────────────
+   *
+   * `9` 나 `abc` 를 치면 아무 말 없이 기본값을 골랐다. 사람은 친 번호가 먹은 줄 알고 넘어가고,
+   * 붙는 것은 고른 적 없는 모델·리전이다. 화면 어디에도 「그건 없는 번호」 라는 말이 없다.
+   *
+   * `되묻기 = 2` 라 **두 번까지 더 묻는다** — 처음까지 세면 사람은 세 번 친다. 여기를
+   * 부르는 자리(모델 40개·리전·제공자 고르기)는 목록이 길어 손이 미끄러지기 쉽고, 잘못
+   * 고르면 고른 적 없는 모델에 붙는다. 그래서 기회를 한 번이 아니라 두 번 준다.
+   * 그래도 틀리면 기본값으로 가되 **그렇게 했다고 적는다.** 되묻는 횟수에
+   * 끝을 둔다 — 답을 파이프로 흘려 넣는 자리에서 같은 틀린 답이 계속 오면 영영 안 끝난다.
+   * 빈 답(그냥 Enter)은 틀린 답이 아니라 「기본으로」 라는 답이라 되묻지 않는다.
+   */
+  for (let 번째 = 0; ; 번째++) {
+    const 받은것 = await askFn('번호', { def: String(def + 1) });
+    const 글 = 숫자펴기(받은것).trim();
+    const n = parseInt(글, 10);
+    if (Number.isFinite(n) && n >= 1 && n <= items.length) return n - 1;
+    if (!글) return def;
+    if (번째 >= 되묻기) {
+      const 기본 = items[def];
+      const 이름 = typeof 기본 === 'string' ? 기본 : 기본?.label ?? '';
+      say(`  ${c.yellow('!')} ${c.gray(`목록에 없는 번호라 기본값 ${def + 1}번${이름 ? `(${이름})` : ''}으로 둡니다.`)}`);
+      return def;
+    }
+    say(`  ${c.yellow('!')} ${c.gray(`「${글}」 은 목록에 없습니다 — 1~${items.length} 사이 번호를 넣어 주세요.`)}`);
+  }
 }
 
 export async function confirm(label, def = true) {

package/src/ui/screen.js

@@ -371,7 +371,8 @@ export class BoxScreen extends LineScreen {
     // '생각 중… 1,234자' 에서 숫자만 떼어 곁정보로 붙인다. 진짜로 늘어나는
     // 숫자가 하나 있어야 '살아 있다' 가 표시가 아니라 사실이 된다.
     const m = /([\d,]+)자/.exec(String(s ?? ''));
-    this.상자.일바꿈('생각', m ? `생각 ${m[1]}자` : null);
+    // 「생각」 은 상자 왼쪽 문구가 이미 말한다 — 곁에 또 붙이면 한 줄에 두 번 나온다.
+    this.상자.일바꿈('생각', m ? `${m[1]}자` : null);
   }
 
   /**

package/src/ui/spinner.js

@@ -1,4 +1,9 @@
-// 진행 중 표시. TTY가 아니면 조용히 한 줄만 남긴다.
+// 진행 중 표시. TTY가 아니면 돌리지 않고 줄로만 남긴다.
+//
+// 「한 줄만」 이 아니다. 시작할 때 무엇을 하는 중인지 한 줄, 끝맺음 글을 받으면 그때 한 줄 —
+// 부르는 열아홉 자리 중 열넷이 끝맺음 글을 준다(찾음 개수·연결됨·못 물어봤습니다…). 시작 줄을
+// 빼면 로그에 결과만 남아 무엇을 하다 그리 됐는지가 사라지고, 끝맺음 줄을 빼면 그 열넷이
+// 통째로 말을 잃는다. 끝맺음 글을 안 주는 다섯 자리에서만 한 줄로 끝난다.
 import { c, cursor } from './ansi.js';
 
 const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];

package/src/ui/status.js

@@ -2,13 +2,13 @@
 //
 // 남의 패키지를 붙이지 않는다. 필요한 숫자는 전부 session 이 이미 갖고 있고,
 // 화면 그리기는 ansi.js 만 쓴다. 반입 심사에 새로 설명할 것이 늘지 않게 하려는 뜻이다.
-import { c, 눈금게이지, width, clip, cols, mark } from './ansi.js';
+import { c, 눈금게이지, width, clip, cols, mark, 화면글거르기 } from './ansi.js';
 import { 마지막할당량, 할당량말, 아슬아슬한가 } from '../backend/quota.js';
 import { 세션요금, 돈셈, 돈말 } from '../backend/price.js';
 import { PROFILES } from '../agent/effort.js';
 import { get as workMode, canWrite, 보일이름 } from '../agent/modes.js';
 import { isLocalHost, isOffline } from '../safety/network.js';
-import { 프록시고르기, 프록시설정 } from '../backend/proxy.js';
+import { 프록시고르기, 프록시설정, 프록시비켜가나 } from '../backend/proxy.js';
 import { COMPACT_AT, FOLD_AT } from '../agent/compact.js';
 import { 말, 언어 } from '../i18n/index.js';
 import { 표시 as 승인표시, 고르기 as 승인고르기 } from './approve.js';
@@ -155,8 +155,10 @@ export const SEGMENTS = {
     },
   },
 
-  // 지금 무슨 일을 하는 중인가. 파일을 못 바꾸는 모드면 자물쇠를 같이 그린다 —
-  // 계획만 세우는 중인지 실제로 고치는 중인지 한눈에 보여야 한다.
+  // 지금 무슨 일을 하는 중인가. 파일을 못 바꾸는 모드면 이름을 초록으로 바꾸고
+  // 뒤에 「읽기만」(영어는 read-only)을 덧붙인다 — 계획만 세우는 중인지 실제로
+  // 고치는 중인지 한눈에 보여야 한다. 자물쇠 같은 기호는 안 쓴다: 터미널마다
+  // 한 칸이 되기도 두 칸이 되기도 해서 상태줄 폭 셈이 어긋난다(ui/motion.js 머리말).
   work: {
     get desc() { return 말('seg.work'); },
     make: (s) => {
@@ -338,6 +340,37 @@ export const SEGMENT_GROUPS = [
 // 옛 이름. 조각 이름을 직접 넘기던 자리(검사·설정)가 그대로 돌게 남긴다.
 export const DEFAULT_SEGMENTS = SEGMENT_GROUPS.flat();
 
+/*
+ * 자리가 모자랄 때 **접는 차례.** 한 칸이 조각 이름 **배열**이고, 그 칸에 적힌
+ * 이름은 다 같이 빠진다(아래 statusLine 의 뺄것). 덩이를 그대로 옮겨 적은 칸도
+ * 있고 덩이의 일부만 적은 칸도 있다 — 마지막 `['work','think']` 이 그렇다.
+ * 첫 이름 하나로 덩이를 가리키는 것이 아니다. 그랬다면 같이 빠져야 할 `verify`·
+ * `undoable` 이 남아, 한 덩이가 반만 접힌 줄(`✓3 ↩2` 만 남은 줄)이 나온다.
+ *
+ * 여태는 차례가 없었다 — 그냥 뒤에서부터 떨궜다. 그런데 덩이 순서는 '읽기
+ * 좋은 순서' 로 정한 것이지 '덜 급한 순서' 가 아니다. 그래서 40~60칸으로
+ * 좁힌 창(screen.js 가 받는 폭이다)에서 이렇게 됐다 —
+ *
+ *   ▏⌂ 내폴더 · 모델 ▏ ▰▰▱▱▱┆▱▱┆▱ 18%
+ *
+ * 컨텍스트 게이지는 남고 `⏵⏵ 자동` 이 사라진다. 그 한 조각이 **내 파일이
+ * 안 물어보고 바뀌는가**를 말하는 자리다. 게이지는 지금 몰라도 되고 아래
+ * contextWarning 이 급해지면 따로 말해 주는데, 승인 방식은 여기 말고 적히는
+ * 데가 없다. 이 파일이 두 군데(seg.mode 머리말·아래 급 접기)에 「둘 중 하나를
+ * 접어야 하면 언제나 이쪽」 이라고 적어 두고, 정작 떨구는 고리만 그 반대였다.
+ *
+ * 그래서 급·게이지가 승인 방식보다 **먼저** 접힌다. 폴더·모델은 늘 남는다.
+ * `mode` 는 이 차례에 아예 없다 — 제 발로는 안 접힌다.
+ */
+export const 접는차례 = [
+  ['tok', 'cost'],
+  ['edits', 'verify', 'undoable'],
+  ['ctx', 'grade'],
+  // 같은 덩이라도 여기까지다. 무슨 판인지·얼마나 생각하는지는 지금 몰라도
+  // 되고, 승인 방식은 이 줄 말고는 적히는 데가 없다.
+  ['work', 'think'],
+];
+
 /**
  * 이 급을 화면에 낼 값어치가 있나.
  *
@@ -376,8 +409,11 @@ function 참값(s) {
 /**
  * 경계 한 글자.
  *
- * 못 읽는 주소면 아무것도 안 그린다. 여기서 애매하면 **초록을 안 쓴다** —
- * 초록은 '안 나간다' 는 약속이고, 확인 못 한 것을 확인한 낯으로 내밀면 안 된다.
+ * 못 읽는 주소면 회색 `?` 를 그린다 — 자리를 비우지는 않는다. 비우면 한 칸이
+ * 사라져 옆 조각이 통째로 밀리고, 무엇보다 '경계를 아직 모른다' 는 말을 할
+ * 자리가 없어진다(창 크기를 모를 때 `32k?` 로 적는 것과 같은 규칙이다).
+ * 여기서 애매하면 **초록을 안 쓴다** — 초록은 '안 나간다' 는 약속이고,
+ * 확인 못 한 것을 확인한 낯으로 내밀면 안 된다.
  */
 function 경계표(s) {
   let 로컬 = null;
@@ -413,7 +449,11 @@ function base(p) {
   return parts[parts.length - 1] ?? '~';
 }
 
-// 12345 → 12.1k.  상태줄은 자리가 없다.
+// 5678 → 5.5k · 12345 → 12k · 131072 → 128k.  상태줄은 자리가 없다.
+//
+// 10k 아래에서만 소수 한 자리를 붙인다. 넷째 자리가 붙는 순간(10240 부터)
+// 소수까지 적으면 다섯 칸이 되고, 좁은 터미널에서 그 한 칸이 승인 방식을
+// 밀어낸다. 그래서 12345 는 '12.1k' 가 아니라 '12k' 다.
 //
 // 1000 이 아니라 1024 로 나눈다. 컨텍스트 길이는 죄다 2의 거듭제곱이라
 // 1000 으로 나누면 131,072 가 '131k' 로 나온다 — 아무도 그렇게 안 부른다.
@@ -446,7 +486,11 @@ export function statusLine(session, { segments = null, max = cols() - 2 } = {})
         if (뺄것?.has(k)) return null;
         const seg = SEGMENTS[k];
         if (!seg) return null;
-        return 짧게 && seg.short ? seg.short(session) : seg.make(session);
+        /*
+         * 조각에는 바깥 글자가 실린다 — 서버가 알려 준 모델 이름, 사람이 지은 폴더·갈래 이름. 상태줄은 say 를
+         * 안 지나고 입력 상자가 곧장 그리므로 여기서 뗀다(ansi.js 화면글거르기). 조각마다 떼야 폭을 뗀 뒤로 잰다.
+         */
+        return 화면글거르기(짧게 && seg.short ? seg.short(session) : seg.make(session), { 색남김: true });
       })
       .filter((x) => x != null && x !== '')
       .join(안쪽))
@@ -486,7 +530,23 @@ export function statusLine(session, { segments = null, max = cols() - 2 } = {})
    */
   if (!맞나(parts) && !segments) parts = 그리기(true, new Set(['grade']));
 
-  // 여전히 모자라면 뒤에서부터 떨군다. 앞쪽(폴더·모델·컨텍스트)이 마지막까지 남는다.
+  /*
+   * 여전히 모자라면 덩이를 통째로 뺀다. **뺄 차례는 위 접는차례 가 정한다.**
+   *
+   * 여기가 뒤에서부터 떨구던 자리다. 덩이 순서상 `tok/cost` · `edits/…` 다음이
+   * `work/think/mode` 라, 컨텍스트 게이지가 멀쩡히 서 있는 채로 승인 방식이
+   * 먼저 사라졌다 — 바로 위 두 토막이 하지 말라고 적어 둔 바로 그 일이다.
+   */
+  if (!segments) {
+    const 뺄것 = new Set(['grade']);
+    for (const 묶음 of 접는차례) {
+      if (맞나(parts)) break;
+      for (const k of 묶음) 뺄것.add(k);
+      parts = 그리기(true, 뺄것);
+    }
+  }
+
+  // 조각 이름을 직접 준 자리(옛 방식)는 순서를 사람이 정한 것이라 뒤에서 떨군다.
   while (parts.length > 1 && !맞나(parts)) parts.pop();
 
   /*
@@ -571,8 +631,9 @@ export function headerLines(session, found, 상자쓰나 = true) {
     const 프록시 = 프록시고르기(conn.base);
     if (프록시) 목적지 += c.gray(`  ${말('head.viaProxy', { 프록시: `${프록시.host}:${프록시.port}` })}`);
     // 적어 놨는데 못 쓰는 프록시(socks5 등)는 여기서 한 번은 말해야 한다 — 조용히 직접 가면
-    // 사람은 프록시를 탄 줄 알고, 막히면 엉뚱한 데를 고친다.
-    else if (프록시설정().탈) 목적지 += c.yellow(`  ${말('head.proxyBad')}`);
+    // 사람은 프록시를 탄 줄 알고, 막히면 엉뚱한 데를 고친다. 어차피 안 거칠 주소(이 PC · NO_PROXY)면
+    // 말하지 않는다 — 로컬 모델이 안 붙는 까닭을 상관없는 프록시에서 찾게 된다 (2.0.0 6회차 RP1b).
+    else if (프록시설정().탈 && !프록시비켜가나(conn.base)) 목적지 += c.yellow(`  ${말('head.proxyBad')}`);
   } catch { 목적지 = c.gray(String(conn.base)); }
 
   /*
@@ -634,7 +695,14 @@ export function headerLines(session, found, 상자쓰나 = true) {
     lines.push(`${빈자리}${c.gray(말('head.shiftTab'))}${c.gray(말('head.shiftTabHint'))}${c.gray(말('head.tabHint'))}`);
     lines.push(`${빈자리}${c.gray(말('head.newlineHint'))}`);
   }
-  if (found.skills.length || found.commands.length) {
+  /*
+   * 플러그인도 조건에 든다.
+   *
+   * 이 줄이 플러그인 개수를 적는 **유일한 자리**인데, 설 조건에는 스킬·명령만
+   * 있었다. 그래서 스킬도 명령도 없이 플러그인만 깐 사람에게는 깔았다는 사실
+   * 자체가 화면 어디에도 안 나왔다 — 안 읽힌 것인지 없는 것인지 알 길이 없다.
+   */
+  if (found.skills.length || found.commands.length || found.plugins.length) {
     lines.push(`${c.gray(자리(말('head.thisPC')))}${c.white(말('head.skills', { n: found.skills.length }))}${c.gray(' · ')}${c.white(말('head.commands', { n: found.commands.length }))}${c.gray(' · ')}${c.white(말('head.plugins', { n: found.plugins.length }))}`);
   }
   /*

package/src/ui/wrap.js

@@ -2,40 +2,10 @@
 //
 // 전에는 전체화면(tui.js)에만 쓰던 것이라 거기 있었다. 전체화면을 걷어내면서
 // 여기로 옮긴다 — 입력 상자가 긴 입력을 접을 때 같은 것이 필요하다.
-import { width } from './ansi.js';
+// 한덩이 — 보이는 한 덩이 떼기. clip 도 같은 것을 써야 해서 ansi.js 로 옮겼다(그 머리말).
+import { width, 한덩이 } from './ansi.js';
 
-/*
- * i 자리에서 **눈에 보이는 한 덩이**를 통째로 떼어 온다.
- *
- * 글자를 s[i] 로 한 칸씩 읽으면 UTF-16 코드 단위로 잘린다. 😀 같은 글자는
- * 두 칸을 차지하므로 하필 그 사이에서 줄이 접히면 반쪽짜리 서로게이트가
- * 양쪽 줄에 하나씩 남는다 — 접어쓰기("a😀", 2) 가 ["a\ud83d","\ude00"] 를
- * 내놨다. 화면에는 물음표 두 개로 찍히고, 폭 계산도 그때부터 어긋난다.
- *
- * 그래서 코드 포인트로 읽고, 뒤에 붙는 것들(살색 조절·변형 선택자·결합
- * 부호·ZWJ 로 이어붙인 다음 글자)까지 한 덩이로 본다. 완전한 문자소 분할은
- * 아니지만 — 그건 표가 있어야 한다 — 실제로 깨지던 자리는 이걸로 다 막힌다.
- */
-function 한덩이(s, i) {
-  let 끝 = i + String.fromCodePoint(s.codePointAt(i)).length;
-  for (;;) {
-    if (끝 >= s.length) return s.slice(i, 끝);
-    const cp = s.codePointAt(끝);
-    // ZWJ 는 다음 글자까지 끌고 온다 (👨‍👩‍👧 같은 이어붙인 그림글자)
-    if (cp === 0x200d) {
-      const 다음 = 끝 + 1;
-      if (다음 >= s.length) return s.slice(i, 끝);
-      끝 = 다음 + String.fromCodePoint(s.codePointAt(다음)).length;
-      continue;
-    }
-    const 딸린것 = (cp >= 0xfe00 && cp <= 0xfe0f)        // 변형 선택자
-      || (cp >= 0x1f3fb && cp <= 0x1f3ff)               // 살색 조절
-      || (cp >= 0x0300 && cp <= 0x036f)                 // 결합 부호
-      || cp === 0x20e3;                                 // 키캡
-    if (!딸린것) return s.slice(i, 끝);
-    끝 += String.fromCodePoint(cp).length;
-  }
-}
+const 색코드들 = /\x1b\[[0-9;]*m/g;
 
 /**
  * 색을 유지하면서 폭에 맞춰 접는다.
@@ -45,7 +15,16 @@ function 한덩이(s, i) {
  * 마지막으로 켜져 있던 색을 다음 줄 앞에 다시 켜 준다. 안 그러면 접힌 줄부터
  * 색이 풀려 화면이 얼룩덜룩해진다.
  */
-export function 접어쓰기(글, 폭) {
+export function 접어쓰기(글, 폭, 설정 = {}) {
+  /*
+   * `빈칸줄남김` — 빈칸뿐인 마지막 줄을 버리지 않는다.
+   *
+   * 대화 글을 접을 때는 끝의 빈칸이 넘친 줄을 버리는 것이 맞다(보이는 것이 없는 줄이 한 줄
+   * 더 생길 뿐이다). 그런데 입력 상자는 **사람이 친 빈칸**을 그리고 그 뒤에 커서를 세운다.
+   * 터미널은 넘친 빈칸을 다음 줄로 보내 커서를 거기 두는데, 줄을 버리면 상자는 한 줄로 세고
+   * 커서를 윗줄 끝에 세운다 — 친 빈칸이 안 들어간 것처럼 보이고 줄 셈이 한 줄 어긋난다.
+   */
+  const { 빈칸줄남김 = false } = 설정 ?? {};
   const s = String(글 ?? '');
   /*
    * 줄바꿈(\n)이 있으면 그 자리에서 반드시 갈라진다.
@@ -57,7 +36,7 @@ export function 접어쓰기(글, 폭) {
    * 있으면 터미널이 실제로 그린 줄 수와 어긋나 화면이 깨진다. 문단마다
    * 따로 접어서 이 배열이 실제 화면 줄 수와 늘 같게 만든다.
    */
-  if (s.includes('\n')) return s.split('\n').flatMap((줄) => 접어쓰기(줄, 폭));
+  if (s.includes('\n')) return s.split('\n').flatMap((줄) => 접어쓰기(줄, 폭, 설정));
   if (폭 < 2) return [s];
   if (width(s) <= 폭) return [s];
 
@@ -68,8 +47,13 @@ export function 접어쓰기(글, 폭) {
    * 시작한다. 화면에서 세로줄이 끊겨 보이고, 도구 결과의 `    └ …` 도
    * 두 번째 줄부터 갑자기 튀어나온다 — 무엇에 딸린 글인지 알 수 없게 된다.
    * 들여쓴 만큼은 글자 자리에서 빼야 하므로 접는 폭도 같이 줄인다.
+   *
+   * 빈칸을 세기 전에 맨 앞의 색 코드를 건너뛴다. 빈칸만 찾으면 색이 먼저 온 줄
+   * (`c.gray('    └ …')` 처럼 줄 전체에 색을 씌운 자리)에서 들여쓰기를 0 으로 재고,
+   * 접힌 줄이 왼쪽 끝에서 시작한다. 보이는 모양은 민 글과 똑같은데 접은 결과만
+   * 달라지는 자리라 화면으로는 늦게 잡힌다 (2.0.0 8회차 uimisc WR2).
    */
-  const 들여 = (/^ */.exec(s)[0] ?? '').slice(0, Math.max(0, 폭 - 8));
+  const 들여 = ((/^(?:\x1b\[[0-9;]*m)*( *)/.exec(s) ?? [])[1] ?? '').slice(0, Math.max(0, 폭 - 8));
   const 이어폭 = Math.max(2, 폭 - 들여.length);
 
   const 줄들 = [];
@@ -101,6 +85,8 @@ export function 접어쓰기(글, 폭) {
     w += cw;
     i += ch.length;
   }
-  if (지금.trim() !== '' || 줄들.length === 0) 줄들.push(지금 + (색 ? '\x1b[0m' : ''));
+  // 빈칸뿐인지는 색 코드를 떼고 본다. 색이 켜진 채 넘친 빈칸 줄은 코드가 붙어 있어 trim 으로는 안
+  // 비는데, 보이는 것은 똑같이 없다 — 색 없는 글과 줄 수가 달라진다 (2.0.0 6회차 WR1).
+  if (빈칸줄남김 || 지금.replace(색코드들, '').trim() !== '' || 줄들.length === 0) 줄들.push(지금 + (색 ? '\x1b[0m' : ''));
   return 줄들;
 }