deel-local-cli 1.20.12 → 2.0.0

package/src/tools/xlsx.js

@@ -25,7 +25,8 @@ const 되돌림 = { lt: '<', gt: '>', amp: '&', quot: '"', apos: "'" };
 
 export function unescapeXml(s) {
   if (!s.includes('&')) return s;
-  return s.replace(/&(#x?[0-9a-fA-F]+|[a-z]+);/g, (전체, 안) => {
+  // 16진 참조의 x 는 대문자도 된다(XML 규격). 소문자만 봐서 `&#X41;` 이 글자째 남았다 (2.0.0 6회차 엑셀6).
+  return s.replace(/&(#[xX]?[0-9a-fA-F]+|[a-z]+);/g, (전체, 안) => {
     if (안[0] === '#') {
       const n = 안[1] === 'x' || 안[1] === 'X' ? parseInt(안.slice(2), 16) : parseInt(안.slice(1), 10);
       return Number.isFinite(n) && n >= 0 && n <= 0x10ffff ? String.fromCodePoint(n) : 전체;
@@ -51,7 +52,7 @@ export function* tags(xml) {
       i = 끝 < 0 ? xml.length : 끝 + 1;
       continue;
     }
-    const 닫힘 = xml.indexOf('>', 열림);
+    const 닫힘 = 태그끝(xml, 열림);
     if (닫힘 < 0) break;
     let 안 = xml.slice(열림 + 1, 닫힘);
     const closing = 안[0] === '/';
@@ -59,13 +60,42 @@ export function* tags(xml) {
     const selfClosing = 안.endsWith('/');
     if (selfClosing) 안 = 안.slice(0, -1);
     const 빈칸 = 안.search(/[\s]/);
-    const name = 빈칸 < 0 ? 안 : 안.slice(0, 빈칸);
+    const 온이름 = 빈칸 < 0 ? 안 : 안.slice(0, 빈칸);
+    /*
+     * 이름의 접두사(`x:worksheet`)는 뗀다 (2.0.0 6회차 엑셀6). 기본 이름공간을 접두사로 적는 도구가 있고,
+     * 이름을 글자 그대로 견줬더니 `sheet` 를 하나도 못 찾아 「읽을 수 있는 시트가 없습니다」 로 끝났다.
+     * 문서 읽기(docs.js)도 이 함수를 쓰는데 거기는 이미 끝이름 으로 떼고 본다. 속성 이름(`r:id`)은 그대로 —
+     * 부르는 쪽이 접두사째 찾는다.
+     */
+    const name = 온이름.slice(온이름.indexOf(':') + 1);
     const attrs = 빈칸 < 0 ? {} : 속성(안.slice(빈칸));
     yield { name, attrs, closing, selfClosing };
     i = 닫힘 + 1;
   }
 }
 
+/*
+ * 태그를 닫는 `>` 자리. 속성 값 따옴표 안의 `>` 는 건너뛴다 (2.0.0 6회차 엑셀6).
+ *
+ * XML 은 속성 값에 `>` 를 날로 적어도 되고, 엑셀 밖 도구는 `formatCode="[>100]0.0"` 처럼 적는다.
+ * 첫 `>` 에서 끊었더니 서식 문자열이 사라져 날짜 칸이 숫자로 나왔다. 따옴표가 없는 태그는 indexOf
+ * 한 번이다. 따옴표가 끝내 안 닫히는 망가진 태그는 옛날처럼 첫 `>` 에서 끊는다 — 뒤를 통째로 삼키지 않게.
+ */
+function 태그끝(xml, 열림) {
+  const 첫 = xml.indexOf('>', 열림);
+  if (첫 < 0) return -1;
+  const 앞 = xml.slice(열림, 첫);
+  if (!앞.includes('"') && !앞.includes("'")) return 첫;
+  let 따옴 = null;
+  for (let j = 열림 + 1; j < xml.length; j++) {
+    const ch = xml[j];
+    if (따옴) { if (ch === 따옴) 따옴 = null; continue; }
+    if (ch === '>') return j;
+    if (ch === '"' || ch === "'") 따옴 = ch;
+  }
+  return 첫;
+}
+
 function 속성(s) {
   const out = {};
   const re = /([\w:.-]+)\s*=\s*"([^"]*)"|([\w:.-]+)\s*=\s*'([^']*)'/g;
@@ -76,7 +106,7 @@ function 속성(s) {
 
 // ── 셀 주소 ─────────────────────────────────────────────────────────────
 
-/** 'BC12' → { col: 54, row: 12 }  (col 은 1부터) */
+/** 'BC12' → { col: 55, row: 12 }  (col 은 1부터. BC = 2×26+3 이다 — 54 는 BB) */
 export function cellRef(ref) {
   let col = 0;
   let i = 0;
@@ -117,7 +147,17 @@ function 시트목록(workbookXml, rels) {
   const out = [];
   for (const n of tags(workbookXml)) {
     if (n.name === 'sheet' && !n.closing) {
-      const rid = n.attrs['r:id'] ?? n.attrs.id;
+      /*
+       * 관계 열쇠는 **접두사를 떼고** 찾는다 (막판 훑기).
+       *
+       * 태그 이름의 접두사는 위에서 뗐는데(tags), 여기만 `r:id` 를 글자 그대로 찾았다.
+       * 접두사 이름은 규격이 정해 주는 것이 아니라 그 파일이 정하는 별명이라,
+       * `xmlns:rel="…/relationships"` 로 적는 도구가 만든 통합문서는 접두사를 뗀 고침
+       * 뒤에도 똑같이 「읽을 수 있는 시트가 없습니다」 로 죽었다. 반쪽만 고쳐져 있었다.
+       */
+      const rid = n.attrs['r:id']
+        ?? Object.entries(n.attrs).find(([k]) => k.includes(':') && k.slice(k.indexOf(':') + 1) === 'id')?.[1]
+        ?? n.attrs.id;
       out.push({
         name: n.attrs.name ?? `시트${out.length + 1}`,
         // state="hidden" 인 시트도 담는다. 숨겨진 데 진짜 값이 있는 경우가 있다.
@@ -154,8 +194,13 @@ function 날짜스타일(stylesXml) {
       const code = n.attrs.formatCode ?? '';
       // 서식 문자열에 연·월·일·시가 들어 있으면 날짜로 본다.
       // 따옴표 안의 글자는 그냥 붙는 말이라 빼고 본다.
+      //
+      // 여기 「그러면서 숫자 서식은 아닌 것」(`!/^[#0.,%\s]*$/`)이 뒤에 붙어 있었다.
+      // 앞이 참이면 y·m·d·h·s 중 한 글자가 남아 있다는 뜻이라 뒤는 **늘** 참이다 —
+      // 무작정 다 돌려 보니 앞이 참인 1,560,474건 중 걸린 것이 0건이었다. 지키는
+      // 척만 하는 조건은 다음 사람이 그것을 믿고 진짜 조건을 빼게 만든다.
       const 순수 = code.replace(/"[^"]*"/g, '').replace(/\[[^\]]*\]/g, '');
-      if (/[ymdhs]/i.test(순수) && !/^[#0.,%\s]*$/.test(순수)) 날짜Fmt.add(id);
+      if (/[ymdhs]/i.test(순수)) 날짜Fmt.add(id);
     }
   }
   // cellXfs 의 순서가 곧 셀의 s= 값이다.
@@ -182,23 +227,84 @@ function 날짜로(n) {
   return 날 + 시;
 }
 
+/*
+ * 엑셀이 담을 수 있는 가장 큰 표 — 2007 판부터 1,048,576행 × 16,384열(XFD).
+ * 이 밖을 가리키는 주소는 엑셀이 만든 파일에서 나올 수 없다. 나왔다면 누가
+ * 손으로 적은 바이트다.
+ */
+export const 엑셀최대행 = 1048576;
+export const 엑셀최대열 = 16384;
+/** 빈 줄·빈 열이 이만큼 넘게 이어지면 자리를 안 지키고 건너뛰었다고 말한다. */
+export const 빈틈상한 = 1000;
+/** 펼친 표(줄 × 폭)의 칸 수 상한. 넘는 아래쪽 줄은 빼고 뺐다고 말한다. */
+export const 칸수상한 = 1_000_000;
+
+const 천단위 = (n) => String(n).replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+
+/** 1 → 'A', 27 → 'AA', 16384 → 'XFD' */
+function 열이름(n) {
+  let s = '';
+  while (n > 0) {
+    const r = (n - 1) % 26;
+    s = String.fromCharCode(65 + r) + s;
+    n = Math.floor((n - 1) / 26);
+  }
+  return s;
+}
+
+/** 건너뛴 범위 목록을 말로. 너무 많으면 앞의 셋만 적고 나머지는 곳 수만. */
+function 범위말(목록, 꼴) {
+  const 앞 = 목록.slice(0, 3).map(꼴).join(', ');
+  return 목록.length > 3 ? `${앞} 외 ${천단위(목록.length - 3)}곳` : 앞;
+}
+
 function 시트읽기(xml, { shared, 날짜여부 }) {
-  const rows = [];
+  /*
+   * ── 값이 있는 칸만 모으고, 펼치기는 맨 끝에 한 번 ─────────────────────
+   *
+   * 전에는 읽는 대로 줄 배열을 그 번호까지 빈 줄로, 칸 배열을 그 열까지 빈 칸으로
+   * 채웠다. 그러면 메모리가 **파일 크기가 아니라 주소가 우기는 번호**를 따라간다.
+   * 1KB 도 안 되는 파일의 `<row r="80000000">` 한 줄에 빈 배열 팔천만 개,
+   * `<c r="AAAAAA1">` 한 칸에 빈 칸 천이백만 개 — 힙이 바닥나 프로세스가 죽었다
+   * (2.0.0 4회차 사냥). 엑셀 파일은 남이 보낸 바이트다.
+   *
+   * 그래서 읽는 동안은 **값이 있는 칸만** 담는다 — 메모리가 파일 크기를 따른다.
+   * 펼칠 때(표펼치기) 세 가지를 막고, 막은 것은 전부 말로 남긴다. 조용히 줄이면
+   * 표가 멀쩡해 보여서 사람은 무엇이 빠졌는지 모른다.
+   */
+  const 줄들 = [];        // { 번호, 칸: Map<열, 값>, 끝열 } — 번호 오름차순
   let 지금줄 = null;
-  let 줄번호 = 0;
+  let 앞줄번호 = 0;
   let 셀 = null;
   let 안에 = null;      // 'v' | 't' | null
   let 모은글 = '';
-  let 최대칸 = 0;
+  let 읽기표깊이 = 0;   // <rPh> 안 — 인라인 문자열의 읽기(후리가나)라 본문이 아니다
+  let 한계밖 = 0;
+
+  const 줄열기 = (r) => {
+    const n = Number(r);
+    // 엑셀은 줄을 오름차순으로 적는다. 번호가 없거나 뒷걸음치면 앞 줄 바로 다음으로
+    // 본다 — 전에도 그런 줄은 뒤에 이어 붙였다.
+    const 번호 = Number.isInteger(n) && n > 앞줄번호 ? n : 앞줄번호 + 1;
+    지금줄 = { 번호, 칸: new Map(), 끝열: 0, 앞칸열: 0, 밖: 번호 > 엑셀최대행 };
+  };
+  const 줄닫기 = () => {
+    셀마감();
+    if (지금줄 && !지금줄.밖) { 줄들.push(지금줄); 앞줄번호 = 지금줄.번호; }
+    지금줄 = null;
+  };
 
   const 셀마감 = () => {
     if (!셀) return;
     let 값 = 모은글;
     if (셀.t === 's') {
-      const i = Number(값);
+      // 값 없는 칸(`<c t="s"></c>` · `<v></v>`)은 빈 칸이다. Number('') 가 0 이라 0번 공용 글이 들어갔다 (2.0.0 6회차 엑셀6).
+      const i = 값.trim() === '' ? NaN : Number(값);
       값 = Number.isInteger(i) && i >= 0 && i < shared.length ? shared[i] : '';
     } else if (셀.t === 'b') {
-      값 = 값 === '1' ? 'TRUE' : 'FALSE';
+      // 규격은 1·0 인데 `true`·`false` 로 적는 도구가 있다. 값 없는 불리언은 FALSE 가 아니라 빈 칸 (2.0.0 6회차 엑셀6).
+      const 글 = 값.trim().toLowerCase();
+      값 = 글 === '' ? '' : (글 === '1' || 글 === 'true' ? 'TRUE' : 'FALSE');
     } else if (셀.t === 'e') {
       // #REF! 같은 오류값. 지우면 왜 비었는지 알 수 없다.
       값 = 값 || '#오류';
@@ -208,35 +314,41 @@ function 시트읽기(xml, { shared, 날짜여부 }) {
       값 = 날짜로(Number(값)) ?? 값;
     }
     if (값 !== '') {
-      while (지금줄.length < 셀.col - 1) 지금줄.push('');
-      지금줄[셀.col - 1] = 값;
-      if (셀.col > 최대칸) 최대칸 = 셀.col;
+      // <row> 밖에 떨어진 칸 — 망가진 파일이다. 죽지 않고 앞 줄 다음 줄로 본다.
+      if (!지금줄) 줄열기(null);
+      // 엑셀 한계 밖 주소는 담지 않고 센다. 센 것은 말로 남긴다(아래).
+      if (지금줄.밖 || 셀.col > 엑셀최대열) 한계밖 += 1;
+      else {
+        지금줄.칸.set(셀.col, 값);
+        if (셀.col > 지금줄.끝열) 지금줄.끝열 = 셀.col;
+      }
     }
     셀 = null;
     모은글 = '';
   };
 
   for (const n of tags(xml)) {
-    if (n.text !== undefined) { if (안에) 모은글 += unescapeXml(n.text); continue; }
+    if (n.text !== undefined) { if (안에 && !읽기표깊이) 모은글 += unescapeXml(n.text); continue; }
+    // 인라인 문자열의 <rPh> 는 공용문자열 쪽처럼 본문에 안 붙인다 — 붙였더니 `東京トウキョウ` 가 됐다 (2.0.0 6회차 엑셀6).
+    if (n.name === 'rPh') { 읽기표깊이 = Math.max(0, 읽기표깊이 + (n.closing ? -1 : (n.selfClosing ? 0 : 1))); continue; }
     if (n.name === 'row') {
-      if (n.closing) {
-        셀마감();
-        // 건너뛴 빈 줄도 자리를 지킨다. 안 그러면 행 번호가 밀린다.
-        while (rows.length < 줄번호 - 1) rows.push([]);
-        rows.push(지금줄 ?? []);
-        지금줄 = null;
-      } else if (!n.selfClosing) {
-        지금줄 = [];
-        줄번호 = Number(n.attrs.r) || rows.length + 1;
-      }
+      if (n.closing) 줄닫기();
+      else if (!n.selfClosing) { 줄닫기(); 줄열기(n.attrs.r); }
       continue;
     }
     if (n.name === 'c') {
       if (n.closing) { 셀마감(); continue; }
       셀마감();
-      const { col } = n.attrs.r ? cellRef(n.attrs.r) : { col: (지금줄?.length ?? 0) + 1 };
+      /*
+       * 주소 없는 칸은 **앞 칸 다음 열**이다 — 앞 칸에 값이 있었든 없었든.
+       * 「값이 들어간 마지막 열 + 1」 로 세면 `<c/>` · 값 없는 `<c s="2"></c>` 가 낀 자리가
+       * 안 세어져 뒤 칸이 한 칸씩 왼쪽으로 당겨졌다 (4회차 Gemini 리뷰). 끝열은 폭을 재는 데만 쓴다.
+       */
+      const { col } = n.attrs.r ? cellRef(n.attrs.r) : { col: (지금줄?.앞칸열 ?? 0) + 1 };
       셀 = { col: col || 1, t: n.attrs.t ?? null, s: Number(n.attrs.s ?? 0) };
+      if (지금줄) 지금줄.앞칸열 = 셀.col;
       모은글 = '';
+      읽기표깊이 = 0;   // 안 닫힌 <rPh> 가 다음 칸까지 삼키지 않게
       if (n.selfClosing) { 셀 = null; }   // <c r="A1"/> — 빈 칸
       continue;
     }
@@ -247,11 +359,97 @@ function 시트읽기(xml, { shared, 날짜여부 }) {
     // <f> 는 수식이다. 값은 <v> 에 따로 들어 있으므로 수식 자체는 안 읽는다.
     if (n.name === 'f' && !n.closing) 안에 = null;
   }
-  셀마감();
-  if (지금줄) rows.push(지금줄);
+  줄닫기();
 
-  // 오른쪽 끝을 고른다
-  for (const r of rows) while (r.length < 최대칸) r.push('');
+  const 말 = [];
+  if (한계밖) {
+    말.push(`엑셀 한계(${천단위(엑셀최대행)}행 × ${천단위(엑셀최대열)}열) 밖 주소를 가리키는 칸 ${천단위(한계밖)}개는 뺐습니다`
+      + ' — 엑셀이 만든 파일에서는 나올 수 없는 주소입니다');
+  }
+  return { rows: 표펼치기(줄들, 말), 말 };
+}
+
+/**
+ * 값이 있는 칸만 모은 줄들을 사람이 읽는 네모난 표(string[][])로 편다.
+ *
+ * 막는 것 셋 — 모두 **주소가 우기는 번호**만큼 메모리를 쓰게 두지 않으려는 것이고,
+ * 막은 것은 전부 `말` 에 적는다.
+ *
+ *   1. 빈 줄이 빈틈상한 넘게 이어지면 자리를 안 지키고 건너뛴다. 백만째 줄의 한 칸
+ *      때문에 빈 줄 백만 개를 내놓아 봐야 읽을 사람이 없다. 좁은 틈은 전처럼 지킨다
+ *      — 안 그러면 행 번호가 밀린다. 넓은 틈은 몇 행부터 몇 행까지 건너뛰었고
+ *      다음 값이 몇 행인지 적는다. 표에서 그 아래 줄이 당겨져 보이기 때문이다.
+ *   2. 빈 열도 같다. XFD 열의 한 칸 때문에 줄마다 빈 칸 만육천 개를 붙이지 않는다.
+ *   3. 틈이 좁아도 칸이 대각선으로 흩어지면 줄 × 폭 이 곱해서 커진다. 펼친 칸 수가
+ *      칸수상한을 넘으면 아래쪽 줄을 빼고, 몇 줄을 몇 행부터 뺐는지 적는다.
+ */
+function 표펼치기(줄들, 말) {
+  // ── 줄: 값 있는 줄 사이의 틈을 재서 좁으면 빈 줄로 채우고, 넓으면 건너뛴다 ──
+  const 마디 = [];        // { 번호, 줄 } 또는 { 번호, 빈: 개수 }
+  const 건너뛴줄 = [];    // [처음, 끝]
+  const 마지막번호 = 줄들.length ? 줄들[줄들.length - 1].번호 : 0;
+  let 앞 = 0;
+  const 틈 = (다음) => {  // 앞+1 ~ 다음-1
+    const k = 다음 - 앞 - 1;
+    if (k <= 0) return;
+    if (k > 빈틈상한) 건너뛴줄.push([앞 + 1, 다음 - 1]);
+    else 마디.push({ 번호: 앞 + 1, 빈: k });
+  };
+  const 쓰인열 = new Set();
+  for (const z of 줄들) {
+    // 값 없는 줄(서식만 있는 줄)은 틈으로 센다. 끝자리 계산에만 번호가 쓰인다.
+    if (!z.칸.size) continue;
+    틈(z.번호);
+    마디.push({ 번호: z.번호, 줄: z });
+    for (const c of z.칸.keys()) 쓰인열.add(c);
+    앞 = z.번호;
+  }
+  틈(마지막번호 + 1);
+  if (건너뛴줄.length) {
+    const 합 = 건너뛴줄.reduce((s, [a, b]) => s + (b - a + 1), 0);
+    말.push(`빈 줄 ${천단위(합)}개를 건너뛰었습니다 (${범위말(건너뛴줄, ([a, b]) => (b < 마지막번호
+      ? `${천단위(a)}~${천단위(b)}행 → ${천단위(b + 1)}행부터 이어짐`
+      : `${천단위(a)}~${천단위(b)}행 · 시트 끝`))}) — 표의 아래쪽 줄은 그만큼 당겨져 있습니다`);
+  }
+
+  // ── 열: 쓰인 열 사이의 틈도 같은 식으로. 열 번호 → 펼친 표의 칸 자리 ──
+  const 자리 = new Map();
+  const 건너뛴열 = [];
+  let 폭 = 0;
+  let 앞열 = 0;
+  for (const c of [...쓰인열].sort((a, b) => a - b)) {
+    const k = c - 앞열 - 1;
+    if (k > 빈틈상한) 건너뛴열.push([앞열 + 1, c - 1]);
+    else 폭 += k;
+    자리.set(c, 폭);
+    폭 += 1;
+    앞열 = c;
+  }
+  if (건너뛴열.length) {
+    const 합 = 건너뛴열.reduce((s, [a, b]) => s + (b - a + 1), 0);
+    말.push(`빈 열 ${천단위(합)}개를 건너뛰었습니다 (${범위말(건너뛴열, ([a, b]) => `${열이름(a)}~${열이름(b)}열 → ${열이름(b + 1)}열부터 이어짐`)})`
+      + ' — 표의 오른쪽 칸은 그만큼 당겨져 있습니다');
+  }
+
+  // ── 펼치기. 칸 수 상한에 닿으면 거기서 멈춘다 ──
+  const 줄상한 = Math.floor(칸수상한 / Math.max(폭, 1));
+  const 총줄 = 마디.reduce((s, m) => s + (m.줄 ? 1 : m.빈), 0);
+  const rows = [];
+  let 뺀첫번호 = null;
+  for (const m of 마디) {
+    const 몇 = m.줄 ? 1 : m.빈;
+    for (let i = 0; i < 몇; i++) {
+      if (rows.length >= 줄상한) { 뺀첫번호 = m.번호 + i; break; }
+      const r = new Array(폭).fill('');
+      if (m.줄) for (const [c, v] of m.줄.칸) r[자리.get(c)] = v;
+      rows.push(r);
+    }
+    if (뺀첫번호 !== null) break;
+  }
+  if (뺀첫번호 !== null) {
+    말.push(`펼친 표가 칸 수 상한(${천단위(칸수상한)}칸 — 줄 × 폭 ${천단위(폭)})을 넘어 아래쪽 ${천단위(총줄 - rows.length)}줄`
+      + `(${천단위(뺀첫번호)}행부터)은 뺐습니다`);
+  }
   return rows;
 }
 
@@ -312,7 +510,10 @@ export function readXlsx(buf) {
   for (const s of 목록) {
     const xml = s.path ? 글(s.path) : null;
     if (!xml) { notes.push(`시트 '${s.name}' 의 내용을 못 찾았습니다`); continue; }
-    sheets.push({ name: s.name, hidden: s.hidden, rows: 시트읽기(xml, { shared, 날짜여부 }) });
+    const { rows, 말 } = 시트읽기(xml, { shared, 날짜여부 });
+    // 줄이거나 뺀 것은 시트 이름을 붙여 말로 올린다 — Read 와 doc2md 가 이 notes 를 그대로 보여 준다.
+    for (const m of 말) notes.push(`시트 '${s.name}': ${m}`);
+    sheets.push({ name: s.name, hidden: s.hidden, rows });
   }
   if (!sheets.length) throw new Error('읽을 수 있는 시트가 없습니다');
   return { sheets, notes };

package/src/ui/ansi.js

@@ -90,9 +90,117 @@ export const cursor = {
 export const 판시작 = '\x1b[?2026h';
 export const 판끝 = '\x1b[?2026l';
 
+/*
+ * ── 바깥에서 온 글에 섞인 터미널 제어 순서를 뗀다 (2.0.0 3회차 사냥) ─────
+ *
+ * 모델 답은 우리가 쓴 글이 아니다. 모델이 읽은 파일 · 웹 페이지 · 도구 출력에 든 글이 그대로
+ * 되풀려 오기도 한다. 그 안에 ESC 로 시작하는 순서가 있으면 터미널은 **글자가 아니라 명령으로**
+ * 받는다. 마크다운 그리개가 이것을 그대로 흘려보내고 있었다:
+ *
+ *     ESC ]52;c;…BEL      클립보드를 몰래 바꾼다 (붙여넣은 명령이 다른 명령이 된다)
+ *     ESC ]8;;주소 ESC \  보이는 글과 다른 곳으로 가는 링크
+ *     ESC [1A ESC [2K     윗줄 「✗ 실패」 를 「✓ 통과」 로 덮어쓴다
+ *     ESC [2J · \b · \r   화면을 지우거나 이미 찍힌 글을 덮는다
+ *     ESC ]2;…            창 제목
+ *
+ * 줄바꿈과 탭만 남기고 제어 글자(C0 · DEL · C1)와 그 순서를 통째로 뗀다. 순서를 통째로 떼야
+ * `[2J` 같은 찌꺼기가 안 남는다. 토막 사이에서 순서가 끊겨 와도 ESC 와 BEL 자체는 각 토막에서
+ * 빠지므로 터미널에 명령으로 닿지 않는다 — 남는 것은 보이는 글자뿐이다.
+ */
+// 글자가 놓이는 **방향**을 뒤집는 문자(RLO · LRE · 격리 …). 화면에서 `rm txt.exe` 가 다른 이름으로
+// 보이게 만든다(Trojan Source). 이 파일에 보이지 않는 글자를 직접 적지 않으려고 코드값으로 만든다.
+const 방향틀기 = new RegExp(`[${String.fromCharCode(0x202a)}-${String.fromCharCode(0x202e)}${String.fromCharCode(0x2066)}-${String.fromCharCode(0x2069)}]`, 'g');
+
+/*
+ * 순서를 **끝난 것만** 통째로 뗀다 (Gemini 2차 검토). 마침 글자(BEL · ESC \) 가 없는 OSC 를 끝까지 삼키면
+ * 뒤따르는 답과 diff 가 통째로 사라졌다 — 글을 잃는 것이 제일 나쁘다. 끝 안 난 순서는 머리(ESC ])만
+ * 떼면 터미널이 명령으로 못 받고, 몸통은 보이는 글자로 남는다.
+ */
+export function 화면글거르기(글, { 색남김 = false } = {}) {
+  /*
+   * `색남김` — 우리가 입힌 색(SGR `ESC [ … m`)은 두고 **그 사이**만 거른다. say 처럼 우리 색과 바깥 글이
+   * 한 줄에 섞여 나가는 자리에서 쓴다(할 일 목록 · 서버가 준 모델 이름 · 승인 물음). 바깥 글에 든 색 코드도
+   * 남지만 색은 명령이 아니라 모양뿐이다.
+   */
+  if (색남김) {
+    return String(글 ?? '').split(/(\x1b\[[0-9;]*m)/).map((조각, i) => (i % 2 ? 조각 : 화면글거르기(조각))).join('');
+  }
+  return String(글 ?? '')
+    .replace(/\x1b\][^\x07\x1b\n]*(?:\x07|\x1b\\)/g, '')   // OSC — 클립보드 · 링크 · 제목 (끝난 것만)
+    .replace(/\x1b[PX^_][^\x1b\n]*\x1b\\/g, '')            // DCS · SOS · PM · APC (끝난 것만)
+    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '')               // CSI — 커서 · 지우기 · 색
+    .replace(/\x9b[0-?]*[ -/]*[@-~]/g, '')                 // 8비트 CSI
+    .replace(/\x1b[ -/]*[0-~]?/g, '')                      // ESC 두 글자 꼴(ESC 7 · ESC ( 0 · ESC c) · 끝 안 난 순서의 머리 · 홀 ESC
+    .replace(/\r\n/g, '\n')
+    .replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, '')         // 남은 제어 글자 (\t · \n 빼고)
+    .replace(방향틀기, '');
+}
+
+/*
+ * ── 칸을 안 먹는 글자 · 두 칸 먹는 그림글자 ────────────────────────────
+ *
+ * 입력 상자와 접어쓰기가 이 값으로 **화면 줄 수**를 센다. 한 칸이라도 모자라게 세면 줄이
+ * 터미널보다 넓어져 터미널은 두 줄로 접고 상자는 한 줄로 센다 — 키를 칠 때마다 위쪽 대화가
+ * 갉여 나간다(inputbox.js 머리말). 재 보니 이런 자리가 있었다:
+ *
+ *   ✅ ❌ ⚡ ⭐ ☕       한 칸으로 셌다. 터미널은 두 칸에 그린다(Emoji_Presentation).
+ *   🫠 (U+1FA70~)      그림글자 표를 1F9FF 에서 끊어 한 칸으로 셌다.
+ *   𠀀 (한자 확장 B~)   한 칸으로 셌다.
+ *   ZWSP·ZWJ·결합 부호  한 칸씩 셌다. 터미널은 칸을 안 준다.
+ *   가족 그림(ZWJ 이음) 여덟 칸으로 셌다. 터미널은 두 칸 하나로 겹쳐 그린다.
+ *   풀어 쓴 한글(NFD)   ㅎ+ㅏ+ㄴ 을 네 칸으로 셌다. 가운뎃소리·끝소리는 앞 글자에 붙는다.
+ *
+ * U+2600~27BF 는 섞여 있다. ✅ ⚡ 처럼 그림으로 그리는 것(Emoji_Presentation)만 두 칸이고,
+ * ✓ ✗ ⚠ ★ → 같은 글자 꼴은 한 칸이다. deel 이 화면에 그리는 표시가 바로 그쪽이라, 넓게 잡으면
+ * 상태줄·표가 한 칸씩 밀린다. 그래서 범위가 아니라 속성으로 가른다.
+ */
+const 칸없음 = /^[\p{Mn}\p{Me}\p{Cf}]$/u;
+const 그림으로그림 = /^\p{Emoji_Presentation}$/u;
+const 그림글자 = /^\p{Extended_Pictographic}$/u;
+
+function 넓은가(cp, ch) {
+  return (cp >= 0x1100 && cp <= 0x115f)
+    || (cp >= 0x2e80 && cp <= 0xa4cf)
+    || (cp >= 0xa960 && cp <= 0xa97f)       // 한글 첫소리 확장
+    || (cp >= 0xac00 && cp <= 0xd7a3)
+    || (cp >= 0xf900 && cp <= 0xfaff)
+    || (cp >= 0xfe30 && cp <= 0xfe6f)
+    || (cp >= 0xff00 && cp <= 0xff60)
+    || (cp >= 0xffe0 && cp <= 0xffe6)
+    || (cp >= 0x1f300 && cp <= 0x1f9ff)
+    || (cp >= 0x1fa70 && cp <= 0x1faff)     // 그림글자 확장 A
+    || (cp >= 0x20000 && cp <= 0x3fffd)     // 한자 확장 B 부터
+    || 그림으로그림.test(ch);
+}
+
+/*
+ * ── 한 칸 바탕을 두 칸 그림으로 바꾸는 꼬리 · 국기 짝 (Gemini 화면4) ─────────
+ *
+ * U+FE0F 는 「그림으로 그려라」 는 표시다. 윈도 터미널·iTerm2·kitty 는 하트·경고·체크 뒤에 이것이
+ * 붙으면 **두 칸**에 그린다. 우리는 바탕 한 칸 + 선택자 0칸 = 한 칸으로 셌다 — 모델 답에 흔한
+ * 모양이라 한 줄에 하나만 있어도 입력 상자가 줄 수를 틀려 위쪽 대화가 갉여 나갔다. 키캡(1+FE0F
+ * +20E3)과 한 칸 그림(검지 U+261D)에 붙은 살색 조절도 그랬다.
+ *
+ * 국기는 거꾸로였다. 지역 표시 글자 둘이 두 칸 하나에 겹치는데 둘 다 두 칸으로 세어 넷이 됐다.
+ * 짝을 짓는 것은 앞에서부터 둘씩이다(🇺🇸🇰🇷 는 넷 칸, 홀로 남은 반쪽은 두 칸).
+ *
+ * 선택자가 없는 ⚠ ✔ 는 여전히 한 칸이다 — deel 이 그리는 표시가 그쪽이다(위 머리말). 숫자 뒤
+ * FE0F 만으로는 키캡이 아니고(1+FE0F 는 한 칸), 20E3 이 붙어야 두 칸이다.
+ */
+const 지역표시인가 = (cp) => cp >= 0x1f1e6 && cp <= 0x1f1ff;
+const 키캡바탕인가 = (cp) => (cp >= 0x30 && cp <= 0x39) || cp === 0x23 || cp === 0x2a;
+
 // 한글·한자·가나는 터미널에서 두 칸을 차지한다. 표 정렬이 이걸 모르면 어긋난다.
 export function width(str) {
   let w = 0;
+  // 바로 앞 글자가 ZWJ 였나 · 그림글자였나. 이어붙인 그림은 앞 그림과 한 칸에 겹친다.
+  let 앞이음 = false;
+  let 앞그림 = false;
+  // 바로 앞 바탕 글자와 그 글자에 준 칸 수. 칸 안 먹는 글자(ZWJ·결합 부호)는 이 값을 안 바꾼다.
+  let 바탕 = -1;
+  let 바탕칸 = 0;
+  // 짝을 기다리는 지역 표시 글자가 바로 앞에 있나.
+  let 반쪽국기 = false;
   // 없는 값은 빈 글자로 본다.
   //
   // String(null) 은 'null' 이라 폭이 4 로 나온다. 그러면 상태줄이 네 칸씩
@@ -101,21 +209,85 @@ export function width(str) {
   if (str === null || str === undefined) return 0;
   for (const ch of String(str).replace(/\x1b\[[0-9;]*m/g, '')) {
     const cp = ch.codePointAt(0);
-    if (
-      (cp >= 0x1100 && cp <= 0x115f) ||
-      (cp >= 0x2e80 && cp <= 0xa4cf) ||
-      (cp >= 0xac00 && cp <= 0xd7a3) ||
-      (cp >= 0xf900 && cp <= 0xfaff) ||
-      (cp >= 0xfe30 && cp <= 0xfe6f) ||
-      (cp >= 0xff00 && cp <= 0xff60) ||
-      (cp >= 0xffe0 && cp <= 0xffe6) ||
-      (cp >= 0x1f300 && cp <= 0x1f9ff)
-    ) w += 2;
-    else w += 1;
+    const 이음뒤 = 앞이음;
+    const 그림뒤 = 앞그림;
+    앞이음 = cp === 0x200d;
+    // 거의 다 여기서 끝난다 — 로마자·숫자·기호. 속성 검사는 비싸고 이 함수는 자주 불린다.
+    if (cp < 0x0300) { 앞그림 = false; 반쪽국기 = false; 바탕 = cp; 바탕칸 = 1; w += 1; continue; }
+    // 그림으로 그리라는 선택자 · 키캡 꼬리 — 한 칸 바탕을 두 칸으로 넓힌다 (위 머리말).
+    if (cp === 0xfe0f || cp === 0x20e3) {
+      const 넓힌다 = 바탕칸 === 1
+        && (cp === 0xfe0f ? 그림글자.test(String.fromCodePoint(바탕)) : 키캡바탕인가(바탕));
+      if (넓힌다) { w += 1; 바탕칸 = 2; }
+      앞그림 = cp === 0xfe0f && 그림뒤;
+      continue;
+    }
+    const 그림 = 그림글자.test(ch);
+    const 살색 = cp >= 0x1f3fb && cp <= 0x1f3ff;
+    // 그림 뒤에 붙는 ZWJ · 변형 선택자 · 살색 조절은 「아직 그 그림」 이다.
+    앞그림 = 그림 || (그림뒤 && (cp === 0x200d || (cp >= 0xfe00 && cp <= 0xfe0f) || 살색));
+    if (칸없음.test(ch)) continue;
+    // 풀어 쓴 한글의 가운뎃소리·끝소리는 앞 첫소리 칸에 겹친다.
+    if ((cp >= 0x1160 && cp <= 0x11ff) || (cp >= 0xd7b0 && cp <= 0xd7ff)) continue;
+    // ZWJ 뒤의 그림은 앞 그림과 같은 칸이다.
+    if (이음뒤 && 그림) continue;
+    // 그림 뒤의 살색 조절도 같은 칸이다 — 다만 한 칸 그림이었으면 두 칸으로 넓힌다.
+    if (그림뒤 && 살색) { if (바탕칸 === 1) { w += 1; 바탕칸 = 2; } continue; }
+    // 국기 반쪽 둘은 두 칸 하나다.
+    if (지역표시인가(cp)) {
+      if (반쪽국기) { 반쪽국기 = false; continue; }
+      반쪽국기 = true;
+    } else {
+      반쪽국기 = false;
+    }
+    const 칸 = 넓은가(cp, ch) ? 2 : 1;
+    바탕 = cp;
+    바탕칸 = 칸;
+    w += 칸;
   }
   return w;
 }
 
+/*
+ * i 자리에서 **눈에 보이는 한 덩이**를 통째로 떼어 온다.
+ *
+ * 글자를 s[i] 로 한 칸씩 읽으면 UTF-16 코드 단위로 잘린다. 😀 같은 글자는
+ * 두 칸을 차지하므로 하필 그 사이에서 줄이 접히면 반쪽짜리 서로게이트가
+ * 양쪽 줄에 하나씩 남는다 — 접어쓰기("a😀", 2) 가 ["a\ud83d","\ude00"] 를
+ * 내놨다. 화면에는 물음표 두 개로 찍히고, 폭 계산도 그때부터 어긋난다.
+ *
+ * 그래서 코드 포인트로 읽고, 뒤에 붙는 것들(살색 조절·변형 선택자·결합
+ * 부호·ZWJ 로 이어붙인 다음 글자)까지 한 덩이로 본다. 완전한 문자소 분할은
+ * 아니지만 — 그건 표가 있어야 한다 — 실제로 깨지던 자리는 이걸로 다 막힌다.
+ *
+ * 접어쓰기(wrap.js)에만 있던 것을 여기로 옮겼다. clip 은 코드 포인트 하나씩 잘라서 그림과
+ * 선택자·ZWJ 사이를 끊었다 — 자른 끝에 ZWJ 가 남으면 뒤에 붙는 말줄임표와 겹쳐 그려지고,
+ * 선택자가 떨어지면 두 칸 그림이 한 칸 글 모양으로 바뀐다. 국기 짝도 한 덩이다 — 반쪽 국기
+ * 둘은 글자 두 개로 그려진다(위 width 머리말).
+ */
+export function 한덩이(s, i) {
+  const 첫 = s.codePointAt(i);
+  let 끝 = i + String.fromCodePoint(첫).length;
+  if (지역표시인가(첫) && 끝 < s.length && 지역표시인가(s.codePointAt(끝))) 끝 += 2;
+  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;
+  }
+}
+
 export function pad(str, target, align = 'left') {
   const gap = Math.max(0, target - width(str));
   if (align === 'right') return ' '.repeat(gap) + str;
@@ -140,6 +312,13 @@ export function pad(str, target, align = 'left') {
  */
 export function clip(str, max, tail = '…') {
   if (width(str) <= max) return str;
+  /*
+   * 꼬리보다 좁은 칸 (Gemini 화면5). 남은 예산이 음수여도 꼬리를 붙여서 `clip('테스트', 0)` 이 「…」
+   * 한 칸, 꼬리가 두 칸이면 `max 1` 에 두 칸을 냈다 — 좁은 창에서 줄이 넘친다. 칸이 없으면 빈 글,
+   * 꼬리가 안 들어가면 꼬리 없이 자른다.
+   */
+  if (!(max > 0)) return '';
+  if (width(tail) > max) return clip(str, max, '');
   const budget = max - width(tail);
   let out = '';
   let w = 0;
@@ -153,7 +332,10 @@ export function clip(str, max, tail = '…') {
       색켜짐 = !/^\x1b\[0?m$/.test(조각);
       continue;
     }
-    for (const ch of 조각) {
+    // 코드 포인트가 아니라 보이는 덩이로 자른다 — 그림과 선택자·ZWJ 사이를 안 끊는다 (한덩이 머리말).
+    for (let i = 0; i < 조각.length;) {
+      const ch = 한덩이(조각, i);
+      i += ch.length;
       const cw = width(ch);
       if (w + cw > budget) { 찼다 = true; break; }
       out += ch;
@@ -166,7 +348,9 @@ export function clip(str, max, tail = '…') {
 // 터미널 가로 폭. 파이프로 넘어가면 알 수 없으니 넉넉히 잡는다.
 export const cols = () => process.stdout.columns || 100;
 
-export const say = (s = '') => process.stdout.write(s + '\n');
+// 줄 하나를 낸다. 여기로 바깥 글(할 일 · 모델 이름 · 플러그인 설명 …)이 곧장 오므로 들어온 제어 순서를 뗀다 —
+// 우리 색은 남긴다(화면글거르기 머리말). 커서 옮기기 같은 우리 제어는 이 길을 안 쓴다(cursor · 판시작).
+export const say = (s = '') => process.stdout.write(화면글거르기(s, { 색남김: true }) + '\n');
 
 export function rule(label = '', total = 64) {
   if (!label) return say(c.gray('─'.repeat(total)));
@@ -176,7 +360,11 @@ export function rule(label = '', total = 64) {
 
 // 채움 막대. 반쪽 칸까지 써서 좁은 폭에서도 눈금이 보인다.
 export function bar(used, total, cells = 32) {
-  const ratio = total > 0 ? Math.min(1, used / total) : 0;
+  // 말이 안 되는 셈은 0 으로 본다 — 아래 gauge() 와 같은 까닭이다.
+  // Math.min 은 NaN 을 그대로 흘려 repeat(NaN) 이 빈 글자가 되고(막대가 통째로
+  // 사라진다), 음수는 repeat(-4) 로 **던진다** — 화면 한 칸이 프로그램을 죽인다.
+  const 몫 = Number(used) / Number(total);
+  const ratio = total > 0 && Number.isFinite(몫) ? Math.min(1, Math.max(0, 몫)) : 0;
   const exact = ratio * cells;
   const full = Math.floor(exact);
   const half = exact - full >= 0.5 && full < cells;
@@ -243,7 +431,13 @@ const BOX = { tl: '╭', tr: '╮', bl: '╰', br: '╯', h: '─', v: '│' };
 export function box(lines, { title = '', pad: gap = 1, tone = c.gray, max = cols() - 4 } = {}) {
   const body = lines.map((l) => clip(l, max - gap * 2 - 2));
   const inner = Math.max(
-    width(title) + 2,
+    // 윗줄은 `╭─ 이름 ` 까지가 다섯 칸이고 오른쪽 모서리가 한 칸이다. 안쪽이
+    // 이름+3 보다 좁으면 윗줄만 길어져 테두리가 한 칸 어긋난다(여백 0 이면 늘 그렇다).
+    //
+    // 이름이 없으면 그 바닥도 없다. 빈 이름에 +3 을 하면 안쪽 폭이 3 아래로 못 내려가
+    // 한 글자짜리 상자가 세 칸으로 그려진다 — 위 JSDoc 이 적은 「가장 긴 줄에 맞춘다」 와
+    // 어긋난다 (8회차 AN1).
+    title ? width(title) + 3 : 0,
     ...body.map((l) => width(l)),
   ) + gap * 2;
   const top = title

package/src/ui/banner.js

@@ -235,7 +235,8 @@ export function 마지막틀(opts = {}) { return 틀(틀수 - 1, opts); }
  */
 export function 쓸배율(칸) {
   const w = Number.isFinite(칸) ? 칸 : (process.stdout.columns ?? 80);
-  // 들여쓰기 두 칸 + 오른쪽 한 칸 여유.
+  // 들여쓰기 두 칸 + 오른쪽 두 칸. 한 칸만 두면 그림이 창 마지막 칸까지 닿는데,
+  // 마지막 칸에 쓰면 줄을 넘기는 터미널이 있어 그림이 한 줄 아래로 흘러내린다.
   if (w >= 이름폭(2) + 4) return 2;
   if (w >= 이름폭(1) + 4) return 1;
   return 0;