deel-local-cli 1.20.8 → 1.20.9

package/src/ui/inputbox.js

@@ -72,6 +72,8 @@ const 자가치유주기 = 4000;
 const 앞머리 = 5;
 // 상자가 차지할 최대 줄 수. 긴 글을 붙여넣어도 화면을 다 먹지 않게.
 export const 안쪽최대 = 8;
+// 일하는 중에 미리 쳐 두는 글은 이보다 좁게 보인다 — 위쪽 '일하는 중' 줄을 안 밀어내게.
+export const 대기최대 = 3;
 
 /**
  * 상자를 이룰 줄들과 커서 자리를 값으로 내놓는다.
@@ -117,8 +119,23 @@ export function 프레임({ 글 = '', 커서: 커서자리 = null, 폭 = 80, 상
    */
   if (사무실?.length) 줄들.push(...사무실);
 
-  if (상태) 줄들.push(상태);
-  if (경고) 줄들.push(` ${경고}`);
+  /*
+   * ── 여기 얹는 줄은 **반드시 폭 안에 넣는다** ─────────────────────────
+   *
+   * 상자는 아래 몇 줄을 붙박아 두고 그 자리에서 다시 그린다 — 그 셈이
+   * `줄들.length` 다. 한 줄이 터미널보다 넓으면 터미널은 그것을 두 줄로
+   * 접는데 상자는 한 줄로 세고, 그만큼 커서를 덜 올린다. 그러면 키를 칠
+   * 때마다 위쪽 대화가 한 줄씩 갉여 나가고 테두리 잔상이 쌓인다.
+   *
+   * 실제로 재 본 자리: 폭 80 에서 할당량 경고가 101칸이었다. 상자는 5줄로
+   * 셌고 터미널은 7줄을 썼다.
+   *
+   * 상태줄은 자기 자리에서 이미 줄이지만(ui/status.js), 덩이 하나가 폭보다
+   * 넓으면 그대로 나온다 — 그래서 여기서 한 번 더 자른다. 경고는 뜻이
+   * 뒤쪽에 있는 문장이라 자르지 않고 **접는다.**
+   */
+  if (상태) 줄들.push(clip(상태, 칸));
+  if (경고) for (const 줄 of 접어쓰기(` ${경고}`, 칸)) 줄들.push(줄);
 
   const 가로 = '─'.repeat(칸 - 3);
   줄들.push(테(` ╭${가로}╮`));
@@ -144,8 +161,16 @@ export function 프레임({ 글 = '', 커서: 커서자리 = null, 폭 = 80, 상
     const 왼쪽 = `${c.hcyan(일감.돌림 ?? '⠋')} ${c.white(일감.말 ?? '')}${c.gray('…')}`;
     const 오른쪽 = c.gray(일감.곁 ?? '');
     const 남 = 일안쪽 - width(왼쪽) - width(오른쪽);
-    // 자리가 모자라면 오른쪽(걸린 시간·중단 안내)을 버린다. 왼쪽이 본문이다.
-    const 안 = 남 >= 2 ? `${왼쪽}${' '.repeat(남)}${오른쪽}` : 왼쪽;
+    /*
+     * 자리가 모자라면 오른쪽(걸린 시간·중단 안내)을 버린다. 왼쪽이 본문이다.
+     *
+     * 오른쪽을 버려도 **왼쪽 하나가 폭보다 넓을 수 있다.** 일감의 말은 부르는
+     * 쪽에서 오는 글이라(하위 작업 목적·도구 이름·파일 경로) 길이를 여기서
+     * 정하지 못한다. 안 자르고 내보내면 위 머리글이 적어 둔 그 손해가 그대로
+     * 난다 — 터미널은 두 줄로 접고 상자는 한 줄로 세서, 키를 칠 때마다
+     * 위쪽 대화가 한 줄씩 갉여 나간다.
+     */
+    const 안 = 남 >= 2 ? `${왼쪽}${' '.repeat(남)}${오른쪽}` : clip(왼쪽, 일안쪽);
     줄들.push(` ${테('│')} ${안}${' '.repeat(Math.max(0, 일안쪽 - width(안)))} ${테('│')}`);
 
     /*
@@ -157,22 +182,31 @@ export function 프레임({ 글 = '', 커서: 커서자리 = null, 폭 = 80, 상
      * 아무것도 안 보여서, 쳐도 안 먹는 줄 알았을 뿐이다.
      *
      * 그래서 보여만 준다. 새로 받는 게 아니라 **이미 받고 있던 것**이다.
+     *
+     * 세 줄을 넘으면 **뒤에서 세 줄**을 보인다.
+     *
+     * 앞서는 앞에서 세 줄을 보였다. 사람은 끝에서 치고 있는데 화면에는 처음
+     * 세 줄이 붙어 있으니, 네 줄째부터는 친 글자가 아무 데도 안 나타났다 —
+     * 그리고 커서는 셋째 줄 끝에 서 있었다. 키가 안 먹는 것처럼 보이는데
+     * 실은 다 받고 있었다. 가린 줄이 있으면 ❯ 를 … 로 바꿔 알린다
+     * (아래 본 상자가 쓰는 것과 같은 표시다).
      */
-    if (일감.대기) {
-      const 대기줄들 = 접어쓰기(일감.대기, 안쪽).slice(0, 3);
-      for (const [i, 한줄] of 대기줄들.entries()) {
-        const 표 = i === 0 ? c.hcyan('❯') : ' ';
-        줄들.push(` ${테('│')} ${표} ${한줄}${' '.repeat(Math.max(0, 안쪽 - width(한줄)))} ${테('│')}`);
-      }
+    const 대기줄들 = 일감.대기 ? 접어쓰기(일감.대기, 안쪽) : [];
+    const 대기보일 = 대기줄들.slice(-대기최대);
+    const 대기넘침 = 대기줄들.length > 대기최대;
+    for (const [i, 한줄] of 대기보일.entries()) {
+      const 표 = i === 0 ? (대기넘침 ? c.gray('…') : c.hcyan('❯')) : ' ';
+      줄들.push(` ${테('│')} ${표} ${한줄}${' '.repeat(Math.max(0, 안쪽 - width(한줄)))} ${테('│')}`);
     }
 
     줄들.push(테(` ╰${가로}╯`));
-    if (일감.대기) 줄들.push(` ${c.gray('Enter 를 치면 지금 일이 끝난 뒤에 보냅니다')}`);
-    else if (곁말) 줄들.push(` ${c.gray(곁말)}`);
+    // 이 아래 줄도 폭 안에 넣는다 — 안내 문구는 43칸이라 좁은 창에서 접힌다.
+    if (일감.대기) 줄들.push(clip(` ${c.gray('Enter 를 치면 지금 일이 끝난 뒤에 보냅니다')}`, 칸));
+    else if (곁말) 줄들.push(clip(` ${c.gray(곁말)}`, 칸));
 
     // 커서는 미리 치는 중일 때만 보여 준다. 아니면 칠 자리가 아니다.
     if (일감.대기) {
-      const 마지막 = 접어쓰기(일감.대기, 안쪽).slice(0, 3).at(-1) ?? '';
+      const 마지막 = 대기보일.at(-1) ?? '';
       return { 줄들, 커서: { 위: 2, 열: Math.min(앞머리 + 1 + width(마지막), 칸 - 1) } };
     }
     return { 줄들, 커서: { 위: (곁말 ? 1 : 0), 열: 1 } };
@@ -184,7 +218,24 @@ export function 프레임({ 글 = '', 커서: 커서자리 = null, 폭 = 80, 상
    */
   const 안쪽줄 = 글 ? 접어쓰기(글, 안쪽) : [''];
   const 넘침 = 안쪽줄.length > 안쪽최대;
-  const 보일줄 = 넘침 ? 안쪽줄.slice(안쪽줄.length - 안쪽최대) : 안쪽줄;
+  /*
+   * 보일 자리는 **커서를 따라간다.**
+   *
+   * 앞서는 언제나 마지막 여덟 줄만 보여 줬다. 그래서 열두 줄짜리 글을
+   * 붙여넣고 Ctrl+A 로 맨 앞에 가면, 커서가 든 줄이 화면에 없었다 — 그때
+   * 커서 줄 번호는 0 으로 깎이므로 커서는 **보이는 첫 줄**에 그려지고,
+   * 치는 글자는 안 보이는 줄에 들어간다. 커서 자리에 아무것도 안 나타나니
+   * 키가 안 먹는 것처럼 보인다.
+   *
+   * 끝에서 치는 보통 경우에는 예전과 똑같이 마지막 여덟 줄이 보인다.
+   */
+  const 커서앞줄수 = (커서자리 == null ? 글 : String(글).slice(0, 커서자리))
+    ? 접어쓰기(커서자리 == null ? 글 : String(글).slice(0, 커서자리), 안쪽).length
+    : 1;
+  const 첫줄 = 넘침
+    ? Math.min(Math.max(0, 커서앞줄수 - 안쪽최대), 안쪽줄.length - 안쪽최대)
+    : 0;
+  const 보일줄 = 안쪽줄.slice(첫줄, 첫줄 + 안쪽최대);
 
   for (const [i, 한줄] of 보일줄.entries()) {
     const 표 = i === 0 ? (넘침 ? c.gray('…') : c.hcyan('❯')) : ' ';
@@ -227,7 +278,8 @@ export function 프레임({ 글 = '', 커서: 커서자리 = null, 폭 = 80, 상
     }
   }
 
-  if (곁말) 줄들.push(` ${c.gray(곁말)}`);
+  // 곁말도 폭 안에 넣는다 — 위 머리글의 그 셈(줄 수)이 어긋난다.
+  if (곁말) 줄들.push(clip(` ${c.gray(곁말)}`, 칸));
 
   /*
    * 커서 자리.
@@ -239,9 +291,8 @@ export function 프레임({ 글 = '', 커서: 커서자리 = null, 폭 = 80, 상
   const 앞글 = 커서자리 == null ? 글 : String(글).slice(0, 커서자리);
   const 앞줄들 = 앞글 ? 접어쓰기(앞글, 안쪽) : [''];
 
-  // 넘쳐서 앞부분을 잘라 냈으면 그만큼 줄 번호가 밀린다.
-  const 숨긴줄 = 안쪽줄.length - 보일줄.length;
-  const 커서줄 = Math.min(Math.max(0, 앞줄들.length - 1 - 숨긴줄), 보일줄.length - 1);
+  // 위로 접어 둔 줄만큼 줄 번호가 밀린다 (보일 자리는 커서를 따라 옮긴다).
+  const 커서줄 = Math.min(Math.max(0, 앞줄들.length - 1 - 첫줄), 보일줄.length - 1);
 
   // 커서 아래에 몇 줄이 더 있나 — 닫는 테두리 + 추천 목록 + 곁말.
   const 아래 = 1 + 추천줄수 + (곁말 ? 1 : 0);
@@ -400,7 +451,7 @@ export class InputBox {
   일시작(session, 갈래 = '기본') {
     this.session = session ?? this.session;
     // 대기 = 일하는 도중에 미리 치고 있는 글, 예약수 = 이미 Enter 를 친 것들.
-    this.일감 = { 갈래, 시작: Date.now(), 곁정보: '', 대기: '', 예약수: 0 };
+    this.일감 = { 갈래, 시작: Date.now(), 바뀐때: Date.now(), 곁정보: '', 대기: '', 예약수: 0 };
     this.틱 = 0;
     this.일그리기();
     if (this.박자) clearInterval(this.박자);
@@ -414,7 +465,7 @@ export class InputBox {
     if (!this.일감) return;
     // 갈래가 바뀌면 문구를 그 자리에서 갈아 준다. 4초를 기다리면 이미 다음
     // 일로 넘어가 있어서, 화면이 늘 한 걸음 늦은 말을 하게 된다.
-    if (갈래 && 갈래 !== this.일감.갈래) { this.일감.갈래 = 갈래; this.틱 = 0; }
+    if (갈래 && 갈래 !== this.일감.갈래) { this.일감.갈래 = 갈래; this.일감.바뀐때 = Date.now(); this.틱 = 0; }
     if (곁정보 !== null) this.일감.곁정보 = 곁정보;
     this.일그리기();
   }
@@ -452,7 +503,18 @@ export class InputBox {
      * 「멈추는 중」이 화면에 영영 안 뜨고, 사람은 안 먹었다고 여겨 또 누른다.
      */
     const 멈추나 = this.일감.갈래 === '멈춤';
-    const 갈래 = (!멈추나 && 지난 >= 느긋해질때) ? '느긋' : this.일감.갈래;
+    /*
+     * 느긋으로 넘어가는 셈은 **턴이 시작된 뒤**가 아니라 **갈래가 바뀐 뒤**로
+     * 잰다.
+     *
+     * 시작부터 재면 45초가 지난 순간부터 턴이 끝날 때까지 갈래가 영영
+     * 느긋에 붙박인다 — 그 뒤로 파일을 다섯 개 읽고 세 군데를 고쳐도 화면은
+     * 계속 '아직 하는 중' 만 돈다. 로컬 모델은 한 턴이 몇 분이라 사실상 늘
+     * 그 상태다. 이 문구를 넣은 뜻이 「아까 하던 말을 계속 돌리면 붙박이처럼
+     * 보인다」 였는데, 시작부터 재면 그 붙박이를 이 문구가 만든다.
+     */
+    const 멎은지 = Date.now() - (this.일감.바뀐때 ?? this.일감.시작);
+    const 갈래 = (!멈추나 && 멎은지 >= 느긋해질때) ? '느긋' : this.일감.갈래;
     const 회차 = Math.floor((this.틱 * 돌림주기) / 문구주기);
     this.그리기(this.session, '', 0, {
       // 갈래에 맞는 작은 그림. 무엇을 하는 중인지 글자와 그림이 같이 말한다.
@@ -551,16 +613,34 @@ export class InputBox {
      *
      *   높이만 바뀌었다 — 줄 접힘은 폭이 정한다. 폭이 그대로면 접힘도 그대로라
      *                    그린줄·커서위 가 아직 맞다. 평소처럼 제대로 지운다.
-     *   폭이 바뀌었다   — 옛 수는 다 틀어졌다. 대신 커서 아래를 통째로 쓸어낸다.
-     *                    상자는 늘 맨 아래에 있어서 그 아래에는 아무것도 없다.
-     *                    위로는 안 올라가니 대화를 건드릴 일이 없다.
+     *   폭이 바뀌었다   — 옛 수는 다 틀어졌다. 대신 상자 맨 윗줄로 올라가
+     *                    거기서 아래를 통째로 쓸어낸다. 상자는 늘 맨 아래에
+     *                    있어서 그 아래에는 아무것도 없고, 맨 윗줄보다 위로는
+     *                    안 올라가니 대화를 건드릴 일이 없다.
      */
     const 높이 = process.stdout.rows ?? null;
     if (this.그린폭 !== 폭 || this.그린높이 !== 높이) {
       if (this.그린폭 === 폭) {
         this.지우기();
       } else {
-        if (this.그린줄) process.stdout.write('\r\x1b[J');
+        /*
+         * 쓸어내기 전에 **상자 맨 윗줄로 올라간다.**
+         *
+         * 커서는 상자 한가운데(아래에서 커서위 번째 줄)에 서 있다. 거기서
+         * 곧바로 쓸어내면 커서 아래만 지워지고 **위쪽 절반이 그대로 남는다** —
+         * 사무실·상태줄·윗테두리·그 위 입력 줄이 유령으로 붙어 있고, 새 상자는
+         * 그 아래에 또 그려진다. 상자가 두 개로 보이고 유령은 대화와 함께 위로
+         * 밀려 올라가 영영 안 없어진다. 흉내 화면으로 재 보니 80→60 에서 네 줄
+         * (윗테두리·입력 줄이 접힌 것)이 남았다.
+         *
+         * 올라가는 거리는 **옛 폭에서 세던 그 거리**를 쓴다. 좁아지면 터미널이
+         * 다시 접어 상자가 더 여러 줄을 차지하므로 이 거리는 모자랄 수 있는데,
+         * 모자라면 유령이 몇 줄 남을 뿐이다. 넘치면 대화를 지운다 — 이 저장소가
+         * 제일 나쁜 것으로 꼽는 그 손해다. 그래서 모자라는 쪽으로 잡는다.
+         */
+        if (this.그린줄) {
+          process.stdout.write('\r' + 위로(Math.max(0, this.그린줄 - 1 - this.커서위)) + '\x1b[J');
+        }
         this.앞줄들 = null;
         this.그린줄 = 0;
         this.커서위 = 0;

package/src/ui/level.js

@@ -58,7 +58,15 @@ export function normalize(v) {
     '쉬움': '쉬움', '초보': '쉬움', '초보자': '쉬움', 'beginner': '쉬움', 'easy': '쉬움', 'b': '쉬움',
     '개발자': '개발자', '고급': '개발자', 'developer': '개발자', 'dev': '개발자', 'advanced': '개발자', 'd': '개발자',
   };
-  return 별명[s] ?? (LEVELS[v] ? v : null);
+  /*
+   * 표에 **제 것으로 있는** 열쇠만 본다.
+   *
+   * `별명[s]` 는 물려받은 열쇠에도 값을 준다. `/level constructor` 면 함수
+   * 하나가 수준 이름으로 통과해서, 그 뒤 shows() 가 `lv.show` 를 읽다가
+   * 터진다 — 명령 목록을 그리는 자리라 대화가 통째로 끝난다.
+   */
+  if (Object.hasOwn(별명, s)) return 별명[s];
+  return Object.hasOwn(LEVELS, v) ? v : null;
 }
 
 export function get(id) {

package/src/ui/office.js

@@ -577,7 +577,21 @@ export function 상태만들기(session, 일감, 틱 = 0, 할일들 = [], 도는
   const s = session ?? {};
   const 쓴것 = s.usage ?? {};
   const 총토큰 = (쓴것.in ?? 0) + (쓴것.out ?? 0);
-  const 창크기 = s.conn?.ctx ?? 0;
+  /*
+   * 창밖 하늘은 **지금 창이 얼마나 찼나**다. 상태줄 게이지와 같은 값을 봐야 한다.
+   *
+   * 앞서는 누적 토큰(in+out)으로 셌다. 그건 부를 때마다 늘기만 하는 값이라
+   * 지금 창과 아무 상관이 없다 — 32k 모델에서 도구를 열 번 부르면 42,000 이
+   * 되어 창이 1.00, 하늘이 **밤으로 굳는다.** 같은 화면 아래쪽 게이지는 18%
+   * 초록이었다. 「노을이면 슬슬 접을 때고 밤이면 이미 늦은 것」 이라고 아래
+   * 주석에 뜻을 못 박아 둔 신호가, 켠 직후부터 거짓말을 하고 있었다.
+   * `/clear` 로도 안 밝아진다 — 누적은 지우지 않으니까.
+   *
+   * breakdown() 은 상태줄이 이미 프레임마다 부르는 것이다(ui/status.js).
+   * 여기서 한 번 더 부르는 값은 그 자리에서 본 값과 **어긋나지 않는 것**이다.
+   */
+  const 예산 = typeof s.breakdown === 'function' ? s.breakdown() : null;
+  const 창비율 = 예산 && 예산.total > 0 ? Math.min(1, 예산.used / 예산.total) : 0;
 
   /*
    * 자리에 앉는 사람들.
@@ -658,7 +672,7 @@ export function 상태만들기(session, 일감, 틱 = 0, 할일들 = [], 도는
     할일: 할일들.filter((t) => t.state !== 'done').length,
     부른횟수: 쓴것.calls ?? 0,
     토큰: 총토큰,
-    창: 창크기 ? Math.min(1, 총토큰 / 창크기) : 0,
+    창: 창비율,
     틱,
   };
 }

package/src/ui/status.js

@@ -142,7 +142,11 @@ export const SEGMENTS = {
     get desc() { return 말('seg.ctx'); },
     make: (s) => {
       const { r, pct, tone, b } = 참값(s);
-      return `${눈금게이지(r, 10, [FOLD_AT, COMPACT_AT])} ${tone(pct + '%')} ${c.gray(short(b.used) + '/' + short(b.total))}`;
+      // 창 크기를 서버가 안 알려 줬으면 `32k?` 로 적는다 — 바로 옆 모델 급이
+      // 짐작일 때 `◈ 보통?` 인 것과 같은 규칙이다. 짐작을 잰 것처럼 적으면,
+      // 실제 창이 8k 라서 답이 잘리는 동안에도 게이지는 초록이다.
+      const 창말 = short(b.total) + (b.총잰것 === false ? '?' : '');
+      return `${눈금게이지(r, 10, [FOLD_AT, COMPACT_AT])} ${tone(pct + '%')} ${c.gray(short(b.used) + '/' + 창말)}`;
     },
     // 자리가 모자라면 정확한 숫자를 접는다. 게이지와 %가 이미 같은 말을 하고 있다.
     short: (s) => {
@@ -222,7 +226,17 @@ export const SEGMENTS = {
     make: (s) => {
       const 돈 = 돈셈(s.usage, 세션요금(s));
       if (!돈 || !(돈.달러 > 0)) return null;
-      return c.gray(돈말(돈.달러));
+      /*
+       * 확정된 금액이 아닐 때는 물음표를 붙인다.
+       *
+       * 두 가지가 그렇게 만든다. 창구가 usage 를 안 준 부름(`못잰것`)은 그
+       * 몫이 **덜 세어졌고**, 캐시를 썼는데 캐시 요금을 모르는 경우
+       * (`캐시모름`)는 제값으로 세어 **더 많게** 나온다. `/cost` 는 이미
+       * 둘 다 적는다 — 그런데 늘 떠 있는 이 자리가 더 확정적으로 보이면
+       * 사람은 이쪽을 믿는다. 두 화면이 다른 말을 하면 안 된다.
+       */
+      const 흐린가 = (s.usage?.못잰것 ?? 0) > 0 || 돈.캐시모름 === true;
+      return c.gray(돈말(돈.달러) + (흐린가 ? '?' : ''));
     },
   },
 
@@ -457,7 +471,16 @@ export function statusLine(session, { segments = null, max = cols() - 2 } = {})
   // 여전히 모자라면 뒤에서부터 떨군다. 앞쪽(폴더·모델·컨텍스트)이 마지막까지 남는다.
   while (parts.length > 1 && !맞나(parts)) parts.pop();
 
-  return ` ${c.gray('▏')}${parts.join(칸막이)}`;
+  /*
+   * 덩이가 **하나만 남아도** 폭을 넘을 수 있다.
+   *
+   * 위 고리는 `parts.length > 1` 에서 멈추므로, 첫 덩이 하나가 폭보다 넓으면
+   * 그대로 나간다 — 30칸으로 좁힌 창에서 32칸이 나왔다. 넘친 줄은 터미널이
+   * 두 줄로 접는데 입력 상자는 한 줄로 세고, 그만큼 커서를 덜 올려 위쪽
+   * 대화를 한 줄씩 갉아먹는다(ui/inputbox.js 의 프레임).
+   */
+  const 줄 = ` ${c.gray('▏')}${parts.join(칸막이)}`;
+  return width(줄) > max ? clip(줄, max) : 줄;
 }
 
 // 컨텍스트가 위험하면 한마디 붙인다. 상태줄만 보고 넘기지 않도록.