deel-local-cli 1.20.13 → 2.0.0

package/src/ui/complete.js

@@ -16,6 +16,21 @@
 // 화면에 한 번에 보여 줄 최대 개수. 더 많으면 목록이 화면을 밀어낸다.
 export const 최대추천 = 6;
 
+/*
+ * 전각 빗금(／, U+FF0F).
+ *
+ * 일본어·중국어 입력기를 켠 채로 `/` 를 치면 이 글자가 나온다. 눈으로는 빗금인데 명령 자리는
+ * `/` 만 봤다 — 추천은 아무것도 안 뜨고, Enter 를 치면 `／help` 가 말로 모델에게 갔다.
+ * 사람은 명령이 없는 줄 안다. 맨 앞 한 글자만 바꾼다(글 가운데의 전각 빗금은 사람 말이다).
+ */
+const 전각빗금 = String.fromCharCode(0xff0f);
+
+/** 맨 앞의 전각 빗금을 `/` 로. 명령을 가르는 자리(commands.js)도 같은 것을 쓴다. */
+export function 빗금펴기(글) {
+  const s = String(글 ?? '');
+  return s.startsWith(전각빗금) ? `/${s.slice(1)}` : s;
+}
+
 /**
  * 지금 치고 있는 글에 맞는 명령들.
  *
@@ -27,7 +42,7 @@ export const 최대추천 = 6;
  * @param {string[]} 보일것       이 수준에서 보여 줄 이름들 (없으면 전부)
  */
 export function 추천(글, 명령표 = {}, 보일것 = null) {
-  const s = String(글 ?? '');
+  const s = 빗금펴기(글);
   const m = /^\/([^\s]*)$/.exec(s);
   if (!m) return [];
 
@@ -37,8 +52,9 @@ export function 추천(글, 명령표 = {}, 보일것 = null) {
   /*
    * 앞에서부터 맞는 것을 먼저, 가운데 맞는 것을 뒤에.
    *
-   * `/mo` 를 치면 mode·model 이 먼저 오고 memory 는 안 온다. 그런데 `/emo` 처럼
-   * 앞을 틀리게 쳤을 때도 memory 가 나오면 고맙다 — 오타는 앞글자에서 제일 많이 난다.
+   * `/mo` 를 치면 mode·model 이 먼저 오고, 가운데가 맞는 memory 가 그 뒤에 붙는다.
+   * 떨구지 않는 것은 `/emo` 처럼 앞을 틀리게 쳤을 때 memory 가 나오면 고맙기 때문이다 —
+   * 오타는 앞글자에서 제일 많이 난다. 순서만으로 충분하고, 지울 이유는 없다.
    */
   const 앞 = [];
   const 안 = [];
@@ -63,7 +79,7 @@ export function 추천(글, 명령표 = {}, 보일것 = null) {
  * 넣어 버리면 사람이 원한 것이 아닐 때 지우는 수고가 더 든다.
  */
 export function 채울글(글, 후보들) {
-  const s = String(글 ?? '');
+  const s = 빗금펴기(글);
   const m = /^\/([^\s]*)$/.exec(s);
   if (!m || !후보들?.length) return '';
   const 친것 = m[1];
@@ -87,3 +103,29 @@ export function 채울글(글, 후보들) {
   }
   return 같은데까지.length > 친것.length ? 같은데까지.slice(친것.length) : '';
 }
+
+/**
+ * readline 에 다는 완성기 — 아무것도 채우지 않되, **붙여넣은 조각 끝의 탭은 살린다.**
+ *
+ * 빈 완성기를 달아 두는 까닭은 repl.js 에 적어 뒀다(Tab 이 줄에 박히지 않게, 채우기는 우리가
+ * rl.write 로). 그런데 readline 은 한 조각(data 한 번)의 **마지막 글자**가 탭이면 그것을 Tab 키로
+ * 보고 완성기에 넘긴다. 빈 완성기는 아무것도 안 내놓으니 그 탭이 사라진다 — 엑셀에서 복사한
+ * `이름\t부서` 가 조각 경계에 걸리면 `이름부서` 로 붙어 모델에게 간다. 조각 가운데의 탭은
+ * readline 이 글자로 넣으니 멀쩡해서, 됐다 안 됐다 한다.
+ *
+ * 사람이 Tab 을 누르면 조각이 탭 하나다. 그래서 **탭으로 끝나는데 한 글자보다 긴** 조각이면
+ * 붙여넣기로 보고 탭을 도로 넣는다. Shift+Tab(ESC [ Z)은 탭으로 안 끝나므로 걸리지 않는다.
+ *
+ * @param {import('node:stream').Readable} 입력 readline 이 읽는 입력(대개 process.stdin)
+ * @returns {(줄: string) => [string[], string]}
+ */
+export function 붙임탭완성기(입력) {
+  let 끝이탭 = false;
+  // readline 보다 **먼저** 조각을 봐야 한다 — 완성기는 readline 이 조각을 푸는 도중에 불린다.
+  입력?.prependListener?.('data', (조각) => {
+    const n = 조각?.length ?? 0;
+    const 끝 = typeof 조각 === 'string' ? 조각.charCodeAt(n - 1) : 조각?.[n - 1];
+    끝이탭 = n > 1 && 끝 === 9;
+  });
+  return (줄) => (끝이탭 ? [[`${줄}\t`], 줄] : [[], 줄]);
+}

package/src/ui/diff.js

@@ -16,7 +16,7 @@
 //      진짜 바뀐 곳을 못 찾는다. 그래서 그 경우를 따로 알아채서 말해 준다.
 //   3) 곁줄은 통째로 만들지 않는다. 20,000줄짜리에서 한 줄 고쳤다고 20,000개를
 //      늘어놓을 이유가 없다 — 필요한 자리만 그때그때 집어 온다.
-import { c, clip, cols } from './ansi.js';
+import { c, clip, cols, 화면글거르기 } from './ansi.js';
 
 // LCS 표를 여기까지만 만든다. 넘으면 대충으로 물러선다. (4M 칸 = 16MB)
 const MAX_CELLS = 4_000_000;
@@ -183,7 +183,9 @@ function LCS대본(a, b, base) {
   return out;
 }
 
-const 보기좋게 = (s) => String(s ?? '').replace(/\t/g, TAB).replace(/\r/g, '');
+// 줄은 **파일 내용**이다 — 남의 파일에 든 터미널 제어 순서를 먼저 뗀다(ansi.js 화면글거르기 머리말).
+// 탭은 그 뒤에 칸으로 편다. 거르개는 탭을 남기고 \r 은 뗀다.
+const 보기좋게 = (s) => 화면글거르기(s).replace(/\t/g, TAB);
 
 /**
  * 화면에 그릴 줄들을 만든다.

package/src/ui/export.js

@@ -27,6 +27,9 @@ import { 증거모으기 } from '../agent/evidence.js';
 import { 부른것들, 본문글 } from '../backend/adapter.js';
 import { 말, 언어 } from '../i18n/index.js';
 import { 첫이름 } from '../tools/label.js';
+import { 가리기 } from '../safety/secrets.js';
+// 「무엇이 아는 열쇠인가」 는 감사기록과 같은 자를 쓴다 — 두 벌이면 한쪽만 샌다.
+import { 열쇠묻기 } from '../safety/audit.js';
 
 /** HTML 로 안전하게. 문서 전체가 이 함수 하나를 지나야 한다. */
 function 글자(s) {
@@ -40,8 +43,13 @@ function 글자(s) {
 /** ANSI 제어문자 걷어내기. 도구 결과에는 색이 섞여 있을 수 있다. */
 const 민글 = (s) => String(s ?? '').replace(/\x1b\[[0-9;]*m/g, '');
 
-/** 도구 호출 한 줄 요약. 보고서는 기록이지 재현이 아니다 — 인자 전체를 안 싣는다. */
-function 도구줄(tc) {
+/**
+ * 도구 호출 한 줄 요약. 보고서는 기록이지 재현이 아니다 — 인자 전체를 안 싣는다.
+ *
+ * 가린 **뒤에** 자른다. 먼저 자르면 열쇠가 80자 선에 걸쳤을 때 앞 조각만 남고,
+ * 조각은 정확히 아는 열쇠라도 못 알아본다 (safety/audit.js 의 turn 과 같은 까닭).
+ */
+function 도구줄(tc, 가림 = (s) => s) {
   // 부른것들() 이 규격을 이미 펴서 { id, name, args } 로 준다.
   const 이름 = tc?.name ?? '?';
   let 핵심 = '';
@@ -51,7 +59,7 @@ function 도구줄(tc) {
     // 있어서, 웹을 읽은 줄이 보고서에서만 빈 괄호로 남았다.
     핵심 = 첫이름(a) ?? a.command ?? '';
   } catch { /* 인자가 잘렸어도 이름은 보여 준다 */ }
-  핵심 = String(핵심);
+  핵심 = 가림(String(핵심));
   if (핵심.length > 80) 핵심 = 핵심.slice(0, 80) + '…';
   return 핵심 ? `${이름}(${핵심})` : 이름;
 }
@@ -67,8 +75,22 @@ function 도구줄(tc) {
 export function 보고서짓기(session, { scope = null, audit = null } = {}) {
   const 보임 = (p) => { try { return scope?.show ? scope.show(p) : String(p); } catch { return String(p); } };
 
+  /*
+   * ── 보고서에 싣기 전에 가린다 ─────────────────────────────────────────
+   *
+   * 보고서는 남에게 가는 글이다 — 결재 첨부로 돌고 메일로 나간다. 그런데 사람 말·
+   * 모델 말·도구 줄을 **그대로** 실었다. 같은 `curl -H "Authorization: Bearer …"`
+   * 가 감사기록에는 가려서 적히는데 보고서에는 평문으로 나갔다. 가리는 자리가
+   * 한 곳이라도 빠지면, 가려진 줄 알고 넘긴 사람이 그 한 곳으로 샌다.
+   *
+   * 아는 열쇠(이 연결의 열쇠·환경변수 열쇠)는 감사기록과 같은 자로 묻는다.
+   * 자유롭게 적히는 글만 가린다 — 파일 이름·숫자는 안 건드린다.
+   */
+  const 아는열쇠 = (() => { try { return 열쇠묻기(session.conn)(); } catch { return []; } })();
+  const 가림 = (s) => 가리기(String(s ?? ''), { 열쇠들: 아는열쇠 }).글;
+
   // ── 재료 ──────────────────────────────────────────────────────────────
-  const 첫말 = 본문글((session.messages ?? []).find((m) => m.role === 'user'));
+  const 첫말 = 가림(본문글((session.messages ?? []).find((m) => m.role === 'user')));
   const 제목 = String(첫말 || 말('export.untitled')).split('\n')[0].slice(0, 80);
 
   const 흐름 = [];
@@ -84,11 +106,12 @@ export function 보고서짓기(session, { scope = null, audit = null } = {}) {
     const 글 = 본문글(m);
     if (m.role === 'user') {
       // Anthropic 꼴에서 사람 차례에 도구 결과가 섞여 온다. 그건 글이 아니다.
-      if (글.trim()) 흐름.push({ 갈래: 'user', 글 });
+      if (글.trim()) 흐름.push({ 갈래: 'user', 글: 가림(글) });
     } else if (m.role === 'assistant') {
-      const 부른것 = 부른것들(m).map(도구줄);
+      const 부른것 = 부른것들(m).map((tc) => 도구줄(tc, 가림));
       if (부른것.length) 흐름.push({ 갈래: 'tools', 글: 부른것.join(' · ') });
-      if (글.trim()) 흐름.push({ 갈래: 'assistant', 글 });
+      // 색 글자를 먼저 걷고 가린다 — 열쇠 한가운데 색이 끼면 꼴이 안 맞는다.
+      if (글.trim()) 흐름.push({ 갈래: 'assistant', 글: 가림(민글(글)) });
     }
     // 도구 결과 알맹이는 안 싣는다 — 길고, 요점은 답과 증거 절에 이미 있다.
   }
@@ -96,8 +119,18 @@ export function 보고서짓기(session, { scope = null, audit = null } = {}) {
   const 바뀐것 = [...(session.changes ?? new Map()).entries()]
     .map(([p, v]) => ({ 파일: 보임(p), 더함: v.added ?? 0, 뺌: v.removed ?? 0, 몇번: v.times ?? 1 }));
 
+  /*
+   * 못 모은 것과 모을 것이 없는 것은 **다르다** (8회차 판정).
+   *
+   * 여기가 `catch { return null; }` 이었다. 그러면 아래에서 `증거?.증명안된것 ?? []`
+   * 가 빈 배열이 되고, 바뀐 파일이 있으면 「없습니다 — 바꾼 것마다 뒤에 돌린 확인이
+   * 있습니다」 가 찍힌다. 재 보니 감사기록을 못 읽는 자리에서 그 줄이 그대로 나왔다.
+   * **증거를 한 줄도 못 봤는데 다 증명됐다고 말한 것이다.** 보고서는 남는 물건이라
+   * 그 거짓말이 그대로 남는다. 그래서 까닭을 들고 온다.
+   */
+  let 증거못모은까닭 = null;
   const 증거 = (() => {
-    try { return 증거모으기(session, { audit }); } catch { return null; }
+    try { return 증거모으기(session, { audit }); } catch (err) { 증거못모은까닭 = err?.message ?? String(err); return null; }
   })();
 
   const u = session.usage ?? {};
@@ -144,7 +177,9 @@ export function 보고서짓기(session, { scope = null, audit = null } = {}) {
   const 돌린 = 증거?.돌린것 ?? [];
   if (돌린.length) {
     조각.push('<ul class="ran">');
-    for (const x of 돌린) 조각.push(`<li class="${x.됐나 ? 'ok' : 'bad'}">${x.됐나 ? '✓' : '✗'} <code>${글자(민글(x.무엇))}</code>${x.남긴말 ? ` — ${글자(민글(x.남긴말))}` : ''}</li>`);
+    // 돌린 명령도 도구 줄이다. 감사기록에서 온 것은 이미 가려져 있지만, 대화에서 모은
+    // 것은 아니다 — 어디서 왔든 여기서 한 번 더 지난다(이미 가린 표는 그대로 남는다).
+    for (const x of 돌린) 조각.push(`<li class="${x.됐나 ? 'ok' : 'bad'}">${x.됐나 ? '✓' : '✗'} <code>${글자(가림(민글(x.무엇)))}</code>${x.남긴말 ? ` — ${글자(가림(민글(x.남긴말)))}` : ''}</li>`);
     조각.push('</ul>');
   } else {
     조각.push(`<p class="none">${글자(말('export.nothingRan'))}</p>`);
@@ -152,9 +187,13 @@ export function 보고서짓기(session, { scope = null, audit = null } = {}) {
 
   조각.push(`<h3>${글자(말('export.unproven'))}</h3>`);
   const 미증명 = 증거?.증명안된것 ?? [];
-  if (미증명.length) {
+  if (증거못모은까닭) {
+    조각.push(`<p class="none">${글자(말('export.evidenceFailed', { 왜: 증거못모은까닭 }))}</p>`);
+  } else if (미증명.length) {
     조각.push('<ul class="unproven">');
-    for (const x of 미증명) 조각.push(`<li><b>${글자(x.파일)}</b> — ${글자(x.왜 ?? '')}</li>`);
+    // 파일 이름은 바뀐것 표와 **같은 자로** 짧게 적는다 (8회차 판정) — 한 보고서
+    // 안에 짧은 경로와 날 절대경로가 섞여 있으면 같은 파일인지 사람이 못 가른다.
+    for (const x of 미증명) 조각.push(`<li><b>${글자(보임(x.파일))}</b> — ${글자(x.왜 ?? '')}</li>`);
     조각.push('</ul>');
   } else if (바뀐것.length) {
     조각.push(`<p class="none">${글자(말('export.allProven'))}</p>`);
@@ -209,7 +248,7 @@ ${조각.join('\n')}
 /**
  * 파일로 남긴다.
  *
- * .deel/보고서/ 아래에 시각으로 이름을 짓고, 같은 분(分)에 두 번 적으면
+ * .deel/export/ 아래에 시각으로 이름을 짓고, 같은 분(分)에 두 번 적으면
  * 번호를 붙인다 — **앞엣것을 절대 덮지 않는다.** 보고서는 남는 것이 일이다.
  *
  * @returns {string|null} 적은 자리. 못 적었으면 null — 못 적어도 대화는 계속된다.
@@ -222,11 +261,46 @@ export function 보고서적기(root, session, opts = {}, 탈받을것 = null) {
     const 판 = (n) => `${t.getFullYear()}${String(t.getMonth() + 1).padStart(2, '0')}${String(t.getDate()).padStart(2, '0')}`
       + `-${String(t.getHours()).padStart(2, '0')}${String(t.getMinutes()).padStart(2, '0')}`
       + (n ? `-${n}` : '') + '.html';
-    let 이름 = 판(0);
-    for (let n = 1; existsSync(join(폴더, 이름)) && n < 100; n++) 이름 = 판(n);
-    const 자리 = join(폴더, 이름);
-    writeFileSync(자리, 보고서짓기(session, opts), 'utf8');
-    return 자리;
+    /*
+     * 사람이 이름을 준 자리(`/export 보고서`). 도움말이 `[파일이름]` 이라고
+     * 적어 두고도 여기서 한 번도 안 읽어서, 무엇을 적어 주든 늘 시각 이름으로
+     * 남았다 — 적힌 대로 안 되는 자리다.
+     *
+     * 폴더는 안 받는다. 준 글에서 **이름 한 칸만** 떼어 쓴다 —
+     * `../../어디` 로 내보내는 자리를 벗어나는 길을 막는다.
+     */
+    const 준이름 = String(opts.이름 ?? '').trim().replace(/[\\/]+/g, '/').split('/').pop() ?? '';
+    const 손질 = 준이름.replace(/^\.+/, '').trim();
+    if (준이름 && !손질) throw new Error(`쓸 수 없는 이름입니다: ${준이름}`);
+
+    let 이름 = 손질 ? (/\.html?$/i.test(손질) ? 손질 : `${손질}.html`) : 판(0);
+    // 이름을 준 자리는 번호를 안 붙인다. 있으면 덮지 않고 그대로 말한다.
+    if (손질 && existsSync(join(폴더, 이름))) throw new Error(`이미 있습니다: ${이름}`);
+    if (!손질) for (let n = 1; existsSync(join(폴더, 이름)) && n < 100; n++) 이름 = 판(n);
+    /*
+     * ── 백 번째에서 덮고 있었다 ──────────────────────────────────────────
+     *
+     * 번호는 99 에서 멈추고, 멈춘 자리가 있든 없든 그대로 적었다. 같은 분에 백 번을
+     * 넘기면(스크립트로 돌리면 금방이다) `…-99.html` 을 매번 덮었다 — 위 머리말의
+     * 「절대 덮지 않는다」 가 거짓이 된다. 두 창이 같은 순간에 같은 번호를 고르는
+     * 틈도 있었다.
+     * 그래서 `wx`(없을 때만 만들기)로 적고, 이미 있으면 프로세스 번호·시각·난수를
+     * 붙인 이름으로 다시 한다. 덮는 길이 아예 없다.
+     */
+    const 글 = 보고서짓기(session, opts);
+    for (let 번 = 0; ; 번++) {
+      const 자리 = join(폴더, 이름);
+      try {
+        writeFileSync(자리, 글, { encoding: 'utf8', flag: 'wx' });
+        return 자리;
+      } catch (e) {
+        // 사람이 이름을 준 자리는 다른 이름으로 바꿔 적지 않는다 — 적어 준 이름이
+        // 아닌 데 남으면 찾으러 갈 자리가 달라진다.
+        if (손질) throw new Error(`이미 있습니다: ${이름}`);
+        if (e?.code !== 'EEXIST' || 번 >= 20) throw e;
+        이름 = 판(`${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`);
+      }
+    }
   } catch (e) {
     // 못 적은 까닭을 버리지 않는다 — 화면에 「못 남겼습니다」 만 뜨면 디스크가
     // 찼는지 폴더가 읽기 전용인지 알 길이 없다. 받을 그릇을 준 쪽에만 담는다.

package/src/ui/inputbox.js

@@ -33,7 +33,7 @@
  * 2) 그릴 것을 값으로 내놓는다(프레임). 검사는 파이프로 도니 화면을 못 본다 —
  *    값으로 내놓아야 한 칸도 안 어긋나는지 잴 수 있다.
  */
-import { c, width, cursor, clip, 판시작, 판끝 } from './ansi.js';
+import { c, width, cursor, clip, 판시작, 판끝, 화면글거르기 } from './ansi.js';
 import { isLocalHost } from '../safety/network.js';
 import { statusLine, contextWarning, quotaWarning } from './status.js';
 import { 접어쓰기 } from './wrap.js';
@@ -43,6 +43,7 @@ import {
 import { 문구고르기, 걸린시간, 느긋해질때, 문구주기 } from './working.js';
 import { 그림고르기 } from './motion.js';
 import { 최대추천 } from './complete.js';
+import { 말 } from '../i18n/index.js';
 
 /**
  * 이 연결이 이 컴퓨터 밖으로 나가나.
@@ -90,7 +91,25 @@ export const 대기최대 = 3;
  *   커서.위 = 마지막 줄에서 몇 줄 위인가, 커서.열 = 1부터 세는 칸
  */
 export function 프레임({ 글 = '', 커서: 커서자리 = null, 폭 = 80, 상태 = '', 경고 = '', 곁말 = '', 일감 = null, 추천 = [], 바깥 = false, 사무실 = null } = {}) {
-  const 칸 = Math.max(20, 폭);
+  /*
+   * 칸은 창보다 넓게 잡지 않는다.
+   *
+   * `Math.max(20, 폭)` 이었다 — 10칸 창에 20칸짜리 줄을 냈다. 터미널은 그 줄을 두 줄로 접고
+   * 상자는 한 줄로 세니, 좁은 창(분할 창 · 옆에 붙인 창)에서 키를 칠 때마다 대화가 지워졌다.
+   * 아주 좁으면 상자가 제 모양을 못 갖추지만, 모양이 깨지는 것이 대화가 지워지는 것보다 낫다.
+   * 그래서 끝에서 한 번 더 폭 안으로 자른다(폭안).
+   */
+  const 칸 = Math.max(1, 폭);
+  const 폭안 = (줄들) => 줄들.map((l) => (width(l) > 칸 ? clip(l, 칸) : l));
+  /*
+   * 사람이 친 글을 상자 안 줄로 접는다.
+   *
+   * 탭은 빈칸 넷으로 그린다. 날것으로 내보내면 터미널이 다음 탭 자리까지 밀어 그려서 몇 칸인지
+   * 아무도 모른다 — 엑셀에서 한 줄을 붙이면 탭이 아홉 개 온다. 끝의 빈칸뿐인 줄도 버리지 않는다
+   * (커서가 거기 선다 — wrap.js 의 빈칸줄남김).
+   */
+  const 탭 = String.fromCharCode(9);
+  const 접기 = (s, w) => 접어쓰기(String(s ?? '').split(탭).join('    '), w, { 빈칸줄남김: true });
   /*
    * ── 테두리가 곧 경계선이다 ───────────────────────────────────────────
    *
@@ -106,7 +125,7 @@ export function 프레임({ 글 = '', 커서: 커서자리 = null, 폭 = 80, 상
    * 화면이 그만큼은 말해 줘야 한다.
    */
   const 테 = 바깥 ? c.hyellow : c.gray;
-  const 안쪽 = Math.max(4, 칸 - 앞머리 - 2);   // 오른쪽 ' │' 두 칸
+  const 안쪽 = Math.max(2, 칸 - 앞머리 - 2);   // 오른쪽 ' │' 두 칸
   const 줄들 = [];
 
   /*
@@ -137,7 +156,7 @@ export function 프레임({ 글 = '', 커서: 커서자리 = null, 폭 = 80, 상
   if (상태) 줄들.push(clip(상태, 칸));
   if (경고) for (const 줄 of 접어쓰기(` ${경고}`, 칸)) 줄들.push(줄);
 
-  const 가로 = '─'.repeat(칸 - 3);
+  const 가로 = '─'.repeat(Math.max(0, 칸 - 3));
   줄들.push(테(` ╭${가로}╮`));
 
   /*
@@ -158,8 +177,29 @@ export function 프레임({ 글 = '', 커서: 커서자리 = null, 폭 = 80, 상
      * 어긋나 보인다.
      */
     const 일안쪽 = 안쪽 + 2;
-    const 왼쪽 = `${c.hcyan(일감.돌림 ?? '⠋')} ${c.white(일감.말 ?? '')}${c.gray('…')}`;
-    const 오른쪽 = c.gray(일감.곁 ?? '');
+    /*
+     * 여기 실리는 글은 **우리 것만이 아니다** — 들어온 제어 순서를 뗀다.
+     *
+     * 곁정보에는 모델이 적은 글이 온다(repl.js 가 `일바꿈('하위', clip(ev.목적, 24))` 로
+     * 넣는 그 값은 모델이 Task 를 부를 때 적은 목적이다). 같은 글이 say() 로 나갈 때는
+     * 걸러지는데(ansi.js 화면글거르기), 상자는 say 를 안 지나고 stdout 에 곧장 쓴다 —
+     * 한쪽만 막혀 있었다. 클립보드를 바꾸거나(OSC 52) 윗줄을 덮어써서 「✗ 실패」 를
+     * 「✓ 통과」 로 만드는 자리라, 폭이 어긋나는 것보다 무겁다.
+     *
+     * 우리 색은 남긴다 — 바로 아래 줄들이 그 색으로 그려진다(상태줄도 같은 길이다).
+     */
+    const 걸러 = (s) => 화면글거르기(s, { 색남김: true });
+    /*
+     * 줄바꿈과 탭은 거르개가 **일부러 남기는** 글자다(대화 글에는 있어야 한다). 그런데 여기는
+     * 한 줄이다. \n 하나가 들어오면 터미널은 두 줄에 그리는데 상자는 `줄들.length` 로 한 줄만
+     * 세고 그만큼만 커서를 올린다 — 그 뒤 판마다 한 줄씩 엇나간 자리에 덮어써서 위쪽 대화가
+     * 갉여 나간다. 탭은 터미널이 다음 탭 자리까지 밀어 그려 폭 셈이 통째로 틀어진다(사람이 친
+     * 글은 이미 위 접기 에서 빈칸 넷으로 편다). 한 줄 요약이니 빈칸 하나로 눕힌다 — 글자 수가
+     * 안 바뀌어서 부르는 쪽이 이미 잰 폭(clip 24)도 그대로다.
+     */
+    const 한줄로 = (s) => 걸러(s).replace(/[\n\t]/g, ' ');
+    const 왼쪽 = `${c.hcyan(일감.돌림 ?? '⠋')} ${c.white(한줄로(일감.말 ?? ''))}${c.gray('…')}`;
+    const 오른쪽 = c.gray(한줄로(일감.곁 ?? ''));
     const 남 = 일안쪽 - width(왼쪽) - width(오른쪽);
     /*
      * 자리가 모자라면 오른쪽(걸린 시간·중단 안내)을 버린다. 왼쪽이 본문이다.
@@ -191,7 +231,7 @@ export function 프레임({ 글 = '', 커서: 커서자리 = null, 폭 = 80, 상
      * 실은 다 받고 있었다. 가린 줄이 있으면 ❯ 를 … 로 바꿔 알린다
      * (아래 본 상자가 쓰는 것과 같은 표시다).
      */
-    const 대기줄들 = 일감.대기 ? 접어쓰기(일감.대기, 안쪽) : [];
+    const 대기줄들 = 일감.대기 ? 접기(일감.대기, 안쪽) : [];
     const 대기보일 = 대기줄들.slice(-대기최대);
     const 대기넘침 = 대기줄들.length > 대기최대;
     for (const [i, 한줄] of 대기보일.entries()) {
@@ -201,22 +241,22 @@ export function 프레임({ 글 = '', 커서: 커서자리 = null, 폭 = 80, 상
 
     줄들.push(테(` ╰${가로}╯`));
     // 이 아래 줄도 폭 안에 넣는다 — 안내 문구는 43칸이라 좁은 창에서 접힌다.
-    if (일감.대기) 줄들.push(clip(` ${c.gray('Enter 를 치면 지금 일이 끝난 뒤에 보냅니다')}`, 칸));
+    if (일감.대기) 줄들.push(clip(` ${c.gray(말('box.queuedHint'))}`, 칸));
     else if (곁말) 줄들.push(clip(` ${c.gray(곁말)}`, 칸));
 
     // 커서는 미리 치는 중일 때만 보여 준다. 아니면 칠 자리가 아니다.
     if (일감.대기) {
       const 마지막 = 대기보일.at(-1) ?? '';
-      return { 줄들, 커서: { 위: 2, 열: Math.min(앞머리 + 1 + width(마지막), 칸 - 1) } };
+      return { 줄들: 폭안(줄들), 커서: { 위: 2, 열: Math.max(1, Math.min(앞머리 + 1 + width(마지막), 칸 - 1)) } };
     }
-    return { 줄들, 커서: { 위: (곁말 ? 1 : 0), 열: 1 } };
+    return { 줄들: 폭안(줄들), 커서: { 위: (곁말 ? 1 : 0), 열: 1 } };
   }
 
   /*
    * 긴 입력은 접는다. 자르면 사람이 친 글이 안 보이는데, 안 보이는 채로
    * Enter 를 치게 되는 것이 제일 나쁘다 — 무엇을 보내는지 모르게 된다.
    */
-  const 안쪽줄 = 글 ? 접어쓰기(글, 안쪽) : [''];
+  const 안쪽줄 = 글 ? 접기(글, 안쪽) : [''];
   const 넘침 = 안쪽줄.length > 안쪽최대;
   /*
    * 보일 자리는 **커서를 따라간다.**
@@ -230,7 +270,7 @@ export function 프레임({ 글 = '', 커서: 커서자리 = null, 폭 = 80, 상
    * 끝에서 치는 보통 경우에는 예전과 똑같이 마지막 여덟 줄이 보인다.
    */
   const 커서앞줄수 = (커서자리 == null ? 글 : String(글).slice(0, 커서자리))
-    ? 접어쓰기(커서자리 == null ? 글 : String(글).slice(0, 커서자리), 안쪽).length
+    ? 접기(커서자리 == null ? 글 : String(글).slice(0, 커서자리), 안쪽).length
     : 1;
   const 첫줄 = 넘침
     ? Math.min(Math.max(0, 커서앞줄수 - 안쪽최대), 안쪽줄.length - 안쪽최대)
@@ -273,7 +313,7 @@ export function 프레임({ 글 = '', 커서: 커서자리 = null, 폭 = 80, 상
 
     추천줄수 = 보일것.length;
     if (추천.length > 보일것.length) {
-      줄들.push(`     ${c.gray(`그 밖에 ${추천.length - 보일것.length}개 더`)}`);
+      줄들.push(`     ${c.gray(말('box.more', { n: 추천.length - 보일것.length }))}`);
       추천줄수 += 1;
     }
   }
@@ -289,7 +329,7 @@ export function 프레임({ 글 = '', 커서: 커서자리 = null, 폭 = 80, 상
    * 엉뚱한 자리가 지워지는 것처럼 보인다.
    */
   const 앞글 = 커서자리 == null ? 글 : String(글).slice(0, 커서자리);
-  const 앞줄들 = 앞글 ? 접어쓰기(앞글, 안쪽) : [''];
+  const 앞줄들 = 앞글 ? 접기(앞글, 안쪽) : [''];
 
   // 위로 접어 둔 줄만큼 줄 번호가 밀린다 (보일 자리는 커서를 따라 옮긴다).
   const 커서줄 = Math.min(Math.max(0, 앞줄들.length - 1 - 첫줄), 보일줄.length - 1);
@@ -298,9 +338,9 @@ export function 프레임({ 글 = '', 커서: 커서자리 = null, 폭 = 80, 상
   const 아래 = 1 + 추천줄수 + (곁말 ? 1 : 0);
   const 위 = 아래 + (보일줄.length - 1 - 커서줄);
   // 1부터 세는 칸. 앞머리(5칸) 다음이 6칸째다 — 거기가 첫 글자 자리다.
-  const 열 = Math.min(앞머리 + 1 + width(앞줄들.at(-1) ?? ''), 칸 - 1);
+  const 열 = Math.max(1, Math.min(앞머리 + 1 + width(앞줄들.at(-1) ?? ''), 칸 - 1));
 
-  return { 줄들, 커서: { 위, 열 } };
+  return { 줄들: 폭안(줄들), 커서: { 위, 열 } };
 }
 
 /**
@@ -526,11 +566,11 @@ export class InputBox {
         this.일감.곁정보,
         // 예약해 둔 것이 있으면 잊지 않게 세어 준다. 몇 분짜리 일이 끝난 뒤
         // 엉뚱한 말이 저절로 나가는 것처럼 보이면 안 된다.
-        this.일감.예약수 ? `${this.일감.예약수}건 예약됨` : '',
+        this.일감.예약수 ? 말('box.queued', { n: this.일감.예약수 }) : '',
         // 도는 동안 보이는 자리라 여기서는 ESC 만 말한다. Ctrl+C 도 되지만
         // 두 번 누르면 끝나 버려서, 급히 멈추려는 사람에게 권할 것이 못 된다.
         // 이미 멈추는 중이면 안 권한다 — 또 누르라는 말로 읽힌다.
-        멈추나 ? '' : 'ESC 중단',
+        멈추나 ? '' : 말('run.hintEsc'),
       ].filter(Boolean).join(' · '),
       대기: this.일감.대기,
     });

package/src/ui/intro.js

@@ -105,11 +105,18 @@ export function 틀(n, { 바깥 = false, 곁말 = '' } = {}) {
   const 앞선글 = 색(자란글.slice(0, -1));
   const 방금글 = 자란글 ? c.bold(색(자란글.slice(-1))) : '';
   const 남은칸 = ' '.repeat(이름폭 - 앞.length - 자란글.length);
-  // 커서는 글자 자리를 안 먹는다 — 남은 칸 안에서 그린다. 그래야 글이 안 밀린다.
+  /*
+   * 커서 한 칸은 이름 자리 **밖에** 미리 잡아 둔다.
+   *
+   * 남은 칸 안에서 그리면 이름이 다 자란 틀에서는 남은 칸이 없어 커서가 한 칸
+   * 밖으로 밀리고, 첫 줄 폭이 틀마다 12·13 으로 달라진다. 다시 그리기는 커서를
+   * 올려 같은 자리에 덮어쓰는 것이라, 넓었던 한 칸이 안 지워지고 조각으로 남는다.
+   * 미리 한 칸을 잡아 두면 글자는 안 밀리고 폭은 어느 틀에서나 같다.
+   */
   const 커서글 = f.커서 ? c.gray('▏') : ' ';
   // 다 자란 뒤에는 굵기를 뺀다. 굵은 채로 굳으면 '아직 찍히는 중' 으로 보인다.
   const 이름글 = f.커서 ? `${앞선글}${방금글}` : 색(자란글);
-  const 첫줄 = `${들여}${c.bold(c.white(앞))}${이름글}${커서글}${남은칸.slice(1)}`;
+  const 첫줄 = `${들여}${c.bold(c.white(앞))}${이름글}${커서글}${남은칸}`;
 
   const 선 = f.선 ? 색('─'.repeat(f.선)) : '';
   const 곁 = f.곁 && 곁말 ? `  ${c.gray(곁말)}` : '';

package/src/ui/level.js

@@ -7,8 +7,13 @@
 // 위험을 떠넘기는 것이다. 초보일수록 되돌릴 수 있어야 한다.
 //
 // 감추는 것도 '못 쓰게' 가 아니라 '안 보이게' 다. 초보 수준에서도 /think 를
-// 치면 그대로 먹는다. 목록에 안 띄울 뿐이다 — 처음 켠 사람에게 명령 열여덟
+// 치면 그대로 먹는다. 목록에 안 띄울 뿐이다 — 처음 켠 사람에게 명령 쉰
 // 개를 들이밀면 아무것도 못 고른다.
+//
+// 「열여덟 개」 라고 적혀 있던 자리다. 그 줄을 쓸 때는 명령이 통틀어 열여덟
+// 개였는데(초보 목록은 열두 개) 그 뒤 쉰 개가 넘게 늘도록 숫자만 그대로여서,
+// 마침 열여덟 개가 된 아래 목록이 제 머리말을 어기는 꼴이 됐다. 숫자만 고치면
+// 또 낡으므로 검사가 실제 명령 수와 대 본다 (8회차 LV2).
 
 import { 말 } from '../i18n/index.js';
 
@@ -84,12 +89,32 @@ export function shows(levelId, cmd) {
  *
  * 원인을 숨기지 않는다 — 무엇을 하면 되는지를 앞에 놓고, 원래 문구는 뒤에 남긴다.
  * 원인을 지우면 물어볼 수도 없게 된다.
+ *
+ * 순서가 뜻을 정한다. 먼저 걸린 것이 나가므로 **좁은 것을 넓은 것 위에** 둔다.
  */
 const 풀이 = [
+  /*
+   * 시간 초과가 맨 앞이다. Node 가 내는 이름은 `ETIMEDOUT` 인데, 그 안에는 timeout 이라는
+   * 글자가 없다(TIMEDOUT). 그래서 `read ETIMEDOUT` 은 어느 풀이에도 안 걸려 날것으로 나갔고,
+   * `connect ETIMEDOUT` 은 아래 넓은 `connect` 에 먼저 걸려 「모델이 안 켜져 있다」 는 틀린
+   * 풀이가 나갔다 — 모델은 떠 있고 느린 것이라 그 말대로 해도 안 고쳐진다 (8회차 LV1).
+   */
   {
-    when: /ECONNREFUSED|연결할 수 없|connect|fetch failed/i,
-    say: '모델이 안 켜져 있는 것 같습니다.\n  LM Studio 나 Ollama 를 켜고 모델을 하나 올린 다음 다시 해보세요.\n  어떤 것이 떠 있는지 보려면 /scan',
+    when: /timeout|ETIMEDOUT|시간 초과/i,
+    say: '모델이 제때 답하지 않았습니다.\n  큰 모델이면 원래 느립니다. 잠시 뒤 다시 하거나 더 작은 모델을 골라 보세요.',
   },
+  /*
+   * 우리가 우리 말로 적은 풀이 셋이 `connect` **위**에 선다 (10회차 LV3).
+   *
+   * LV1 은 ETIMEDOUT 만 위로 올리고 이 셋은 그대로 뒀는데, 넓은 것은 ETIMEDOUT 만이
+   * 아니었다. `connect` 는 글자 넉 자라 **경로와 주소에 그대로 들어간다** — `connect-api/`,
+   * `connector.js`, 사내 게이트웨이 `connect.…`. 이 셋의 문구에는 그 경로·주소가 같이
+   * 실리므로, 아래에 있는 동안 「범위 밖입니다」 가 「모델이 안 켜져 있습니다 — LM Studio 를
+   * 켜세요」 로 나갔다. 모델은 켜져 있고, 시킨 대로 해도 안 고쳐진다.
+   *
+   * 반대 방향은 샐 일이 없다. 이 셋은 우리가 그 자리에서 지어 내는 문구라, 모델 서버가
+   * 보내온 연결 오류에 「작업 범위 밖」 이 섞여 올 길이 없다.
+   */
   {
     when: /허용되지 않은 주소/,
     say: '지금 연결된 곳이 아닌 데로 나가려 했습니다. 막힌 게 정상입니다.\n  다른 모델을 쓰시려면 /model 로 고르세요.',
@@ -103,12 +128,12 @@ const 풀이 = [
     say: '고치기 전에 파일을 먼저 읽게 되어 있습니다. 잠시 후 다시 시도합니다.',
   },
   {
-    when: /401|403|인증|unauthorized/i,
-    say: '열쇠(API 키)가 없거나 맞지 않습니다.\n  deel setup 으로 다시 넣어 주세요.',
+    when: /ECONNREFUSED|연결할 수 없|connect|fetch failed/i,
+    say: '모델이 안 켜져 있는 것 같습니다.\n  LM Studio 나 Ollama 를 켜고 모델을 하나 올린 다음 다시 해보세요.\n  어떤 것이 떠 있는지 보려면 /scan',
   },
   {
-    when: /timeout|시간 초과/i,
-    say: '모델이 제때 답하지 않았습니다.\n  큰 모델이면 원래 느립니다. 잠시 뒤 다시 하거나 더 작은 모델을 골라 보세요.',
+    when: /401|403|인증|unauthorized/i,
+    say: '열쇠(API 키)가 없거나 맞지 않습니다.\n  deel setup 으로 다시 넣어 주세요.',
   },
 ];