deel-local-cli 1.20.11 → 1.20.13

package/src/setup.js

@@ -12,7 +12,7 @@ import { 보관방식 } from './safety/keystore.js';
 import { 애저풀기, 애저base } from './backend/azure.js';
 import { allowEndpoint } from './safety/network.js';
 import { 인증서설정, 인증서등록 } from './backend/clientcert.js';
-import { 바깥인가 } from './safety/runmode.js';
+import { 바깥인가, 봉인됐나 } from './safety/runmode.js';
 import { 제공자들, 제공자고르기, 어디것일까, 주소후보, 막힌까닭 } from './providers/index.js';
 import { writeFileSync } from 'node:fs';
 
@@ -107,8 +107,21 @@ async function chooseModel(found) {
   return items[i].label;
 }
 
-// 진단을 돌리고 결과를 화면에 그린다.
-export async function runProbe(conn, { out = null } = {}) {
+/*
+ * 진단을 돌리고 결과를 화면에 그린다.
+ *
+ * **봉인은 진단에도 걸린다.** 여기가 빠져 있었다 — 관리자가 정책으로 밖을
+ * 막아 둔 PC 에서도 `deel diagnose` 는 그냥 나갔다. 자물쇠가 명령 하나로
+ * 열리면 자물쇠가 아니다. 사내망 주소는 봉인에서도 그대로 간다.
+ */
+export async function runProbe(conn, { out = null, 봉인 = false } = {}) {
+  if (봉인 && 바깥인가(conn.base)) {
+    say('');
+    say(`  ${mark.no} ${c.red('봉인되어 있어 이 주소는 안 두드립니다.')} ${c.gray(conn.base)}`);
+    say(`     ${c.gray('관리 정책이나 설정에 offline 이 켜져 있습니다. 사내망 주소는 그대로 됩니다.')}`);
+    say('');
+    return { facts: null, results: null, v: null, 봉인: true };
+  }
   allowEndpoint(conn.base);   // 진단도 이 주소 하나로만 나간다
   renderHeader({ shape: conn.kind, base: conn.base, auth: conn.auth, model: conn.model });
   const { facts, results } = await probe(conn, renderLine);
@@ -344,9 +357,11 @@ export async function runSetup() {
 export async function runDiagnose(flags) {
   banner();
   let conn;
+  let 쓴설정 = null;
+  let 쓴프로필 = null;
 
   if (flags.url) {
-    load();      // 설정의 api-version 을 먼저 읽는다 (runSetup 과 같은 이유)
+    쓴설정 = load();      // 설정의 api-version 을 먼저 읽는다 (runSetup 과 같은 이유)
     const key = flags.key ?? process.env.DEEL_API_KEY ?? '';
     const found = await connect(flags.url, key);
     if (!found) return 1;
@@ -356,6 +371,8 @@ export async function runDiagnose(flags) {
   } else {
     const cfg = load();
     const prof = activeProfile(cfg);
+    쓴설정 = cfg;
+    쓴프로필 = prof;
     if (!prof) {
       say(`  ${mark.warn} 저장된 연결이 없습니다. ${c.cyan('deel setup')} 을 먼저 실행하세요.`);
       say(`     ${c.gray('또는')} deel diagnose --url <주소> --key <키> --model <모델>`);
@@ -377,7 +394,11 @@ export async function runDiagnose(flags) {
     };
   }
 
-  await runProbe(conn, { out: flags.out ?? null });
+  /*
+   * 봉인은 --url 로 주소를 직접 준 갈래에도 걸린다. 오히려 그쪽이 더 위험하다
+   * — 설정에 없는 주소를 그 자리에서 두드리는 길이기 때문이다.
+   */
+  await runProbe(conn, { out: flags.out ?? null, 봉인: 봉인됐나({ 깃발: flags.offline, prof: 쓴프로필, cfg: 쓴설정 }) });
   return 0;
 }
 

package/src/skills/discover.js

@@ -11,6 +11,8 @@ import { readdirSync, readFileSync, existsSync } from 'node:fs';
 import { join, basename, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
+import { homeDir } from '../config.js';
+import { pluginsDir } from '../plugins/manage.js';
 // 저장소에 딸려 온 스킬·명령이 시스템 글에 실리지 않게 한다 (discover 안구절 머리말).
 import { 믿나 } from '../safety/trust.js';
 
@@ -163,6 +165,7 @@ function countSkillDirs(rootDir) {
  */
 export function discover(root, opts = {}) {
   const home = opts.home ?? homedir();
+  const 살림 = opts.살림 ?? (opts.home ? join(opts.home, '.deel') : homeDir());
   const caps = { skills: opts.maxSkills ?? 400, commands: opts.maxCommands ?? 400 };
   const skills = [];
   const commands = [];
@@ -177,7 +180,13 @@ export function discover(root, opts = {}) {
   // 같은 플러그인이 cache/ 와 marketplaces/ 양쪽에 있을 수 있다.
   // 이름이 같으면 알맹이가 더 많은 쪽 하나만 쓴다.
   const roots = [];
-  for (const base of [join(home, '.deel', 'plugins'), join(home, '.claude', 'plugins')]) {
+  /*
+   * 우리 플러그인은 **살림 자리** 밑이다 (`~/.deel` 또는 `DEEL_HOME`).
+   * OS 집 폴더에 `.deel` 을 직접 붙이면 `DEEL_HOME` 을 쓰는 휴대용 설치에서
+   * 깔아 놓은 플러그인의 스킬이 안 보인다 — 깔리는 자리(plugins/manage.js)와
+   * 여기가 갈리기 때문이다. 클로드 것(.claude)은 그쪽 규칙이라 집 폴더 그대로다.
+   */
+  for (const base of [pluginsDir(살림), join(home, '.claude', 'plugins')]) {
     if (existsSync(base)) roots.push(...findPluginRoots(base));
   }
   const best = new Map();

package/src/tools/fig.js

@@ -241,7 +241,7 @@ function 가지풀기(뿌리, 자식표, 줄들, 깊이, 셈) {
  * @returns {{ok:true, 갈래:'fig', 덩이들:[{이름,문단들}], 말:string[], 노드수:number}
  *          |{ok:false, error:string, 끝났다?:boolean}}
  */
-export function readFig(경로또는버퍼) {
+export function readFig(경로또는버퍼, { 최대노드 = 노드최대 } = {}) {
   let buf;
   try {
     buf = Buffer.isBuffer(경로또는버퍼) ? 경로또는버퍼 : readFileSync(경로또는버퍼);
@@ -341,7 +341,8 @@ export function readFig(경로또는버퍼) {
   const 문서 = 뿌리들.find((n) => n.type === 'DOCUMENT') ?? 뿌리들[0];
   const 쪽들 = (자식표.get(열쇠(문서?.guid)) ?? []).filter((n) => n.type === 'CANVAS');
 
-  const 셈 = { 남은: 노드최대 };
+  const 상한노드 = Math.max(1, Number(최대노드) || 노드최대);
+  const 셈 = { 남은: 상한노드 };
   const 덩이들 = [];
 
   const 개요 = [];
@@ -355,11 +356,24 @@ export function readFig(경로또는버퍼) {
 
   if (쪽들.length) {
     for (const 쪽 of 쪽들) {
+      const 아이들 = 자식표.get(열쇠(쪽.guid)) ?? [];
       const 줄들 = [];
-      for (const 아이 of 자식표.get(열쇠(쪽.guid)) ?? []) 가지풀기(아이, 자식표, 줄들, 0, 셈);
+      for (const 아이 of 아이들) 가지풀기(아이, 자식표, 줄들, 0, 셈);
+      /*
+       * 상한에 걸려 못 편 쪽을 「비어 있습니다」 라고 적으면 안 된다.
+       *
+       * 앞쪽 쪽에서 상한을 다 써 버리면 뒤쪽은 한 줄도 안 나온다. 그때 「비어
+       * 있다」 고 적으면, 시안에 멀쩡히 들어 있는 화면을 사람도 모델도 없는
+       * 것으로 읽는다 — 없는 화면을 새로 그리게 된다. 안 폈다고 말한다.
+       */
+      const 못편것 = !줄들.length && 아이들.length > 0;
       덩이들.push({
         이름: String(쪽.name ?? '').trim() || '이름 없는 쪽',
-        문단들: 줄들.length ? 줄들 : ['(이 쪽은 비어 있습니다.)'],
+        문단들: 줄들.length
+          ? 줄들
+          : [못편것
+            ? `(도형 ${상한노드.toLocaleString('en-US')}개 상한에 걸려 이 쪽은 못 폈습니다 — 비어 있는 것이 아닙니다.)`
+            : '(이 쪽은 비어 있습니다.)'],
       });
     }
   } else {
@@ -370,7 +384,7 @@ export function readFig(경로또는버퍼) {
   }
 
   if (셈.남은 <= 0) {
-    말.push(`도형이 ${노드최대.toLocaleString('en-US')}개를 넘어 거기까지만 폈습니다 — 뒷부분은 안 실렸습니다`);
+    말.push(`도형이 ${상한노드.toLocaleString('en-US')}개를 넘어 거기까지만 폈습니다 — 뒷부분은 안 실렸습니다`);
   }
 
   return { ok: true, 갈래: 'fig', 덩이들, 말, 노드수: 노드들.length };

package/src/tools/webfetch.js

@@ -65,8 +65,13 @@ const 집간격 = 400;              // 같은 집을 다시 두드리기 전에
  * 안 먹은 것과 똑같이 보인다 — 제보받은 그 증상이다.
  */
 const 잠깐 = (ms, signal = null) => new Promise((풀기) => {
-  const t = setTimeout(풀기, ms);
-  signal?.addEventListener?.('abort', () => { clearTimeout(t); 풀기(); }, { once: true });
+  // 이미 멈춘 신호를 들고 오면 abort 는 **다시 안 터진다.** 그 판에서
+  // 그냥 잠들면 ESC 를 누른 뒤에도 이 잠을 끝까지 잔다 — 고치려던 그 증상이
+  // 그대로 돌아온다.
+  if (signal?.aborted) return 풀기();
+  const 깨우기 = () => { clearTimeout(t); 풀기(); };
+  const t = setTimeout(() => { signal?.removeEventListener?.('abort', 깨우기); 풀기(); }, ms);
+  signal?.addEventListener?.('abort', 깨우기, { once: true });
 });
 
 function 한집씩(origin, 일, signal = null) {
@@ -79,8 +84,15 @@ function 한집씩(origin, 일, signal = null) {
       if (signal?.aborted) throw new Error('중단했습니다');
       return 일();
     });
-  // 다음 사람이 기다리는 것은 '내가 끝났다' 뿐이다. 내가 실패해도 줄은 넘어간다.
-  집줄.set(origin, 내차례.then(() => {}, () => {}));
+  /*
+   * 다음 사람이 기다리는 것은 '내가 끝났다' 뿐이다. 내가 실패해도 줄은 넘어간다.
+   *
+   * 끝나면 **줄에서 뺀다.** 안 빼면 한참 뒤에 혼자 부르는 요청도 앞사람이
+   * 있는 것으로 보여 400ms 를 그냥 잔다 — 줄이 비어 있는데 서 있는 셈이다.
+   */
+  const 끝나면 = 내차례.then(() => {}, () => {});
+  집줄.set(origin, 끝나면);
+  끝나면.then(() => { if (집줄.get(origin) === 끝나면) 집줄.delete(origin); });
   return 내차례;
 }
 
@@ -133,15 +145,26 @@ function 태그벗기기(html) {
     if (글 === 전) break;
   }
   return 글
-    .replace(/<\/(p|div|section|article|li|tr|h[1-6]|br)>/gi, '\n')
-    .replace(/<br\s*\/?>/gi, '\n')
+    // 닫는 태그만 줄로 바꾸면, 닫는 태그를 안 적은 페이지가 통째로 한 줄이
+    // 된다 — `<p>첫째<p>둘째` 나 `<ul><li>하나<li>둘</ul>` 이 흔하다.
+    // HTML 이 그것을 허락하므로 옛 사내 페이지에는 정말로 그렇게 적혀 있다.
+    // 여는 태그도 같이 줄로 바꾼다.
+    .replace(/<\/?(p|div|section|article|li|tr|h[1-6]|br)\b[^>]*>/gi, '\n')
     .replace(/<[^>]+>/g, ' ')
     // 한 번에 찾아서 한 번에 바꾼다 — 차례로 바꾸면(`&amp;` 를 먼저 `&` 로
     // 풀고 나서 `&lt;` 를 다시 찾는 식) `&amp;lt;` 처럼 두 겹 씌운 것이
     // 두 번 풀려서 `<` 로 튀어나온다(글자로 남아야 하는데 태그처럼 보이게 됨).
-    .replace(/&(nbsp|amp|lt|gt|quot|#39);/g, (_, 이름) => ({
-      nbsp: ' ', amp: '&', lt: '<', gt: '>', quot: '"', '#39': "'",
-    }[이름]))
+    // 숫자 꼴(`&#48712;` · `&#x27;`)과 `&apos;` 도 같은 한 판에서 푼다.
+    // 안 풀면 한글 페이지 하나가 통째로 숫자 나열로 모델에게 간다.
+    .replace(/&(nbsp|amp|lt|gt|quot|apos|#\d{1,7}|#x[0-9a-f]{1,6});/gi, (온것, 이름) => {
+      const 표 = { nbsp: ' ', amp: '&', lt: '<', gt: '>', quot: '"', apos: "'" };
+      const 키 = 이름.toLowerCase();
+      if (표[키] !== undefined) return 표[키];
+      const 번호 = 키.startsWith('#x') ? parseInt(키.slice(2), 16) : parseInt(키.slice(1), 10);
+      // 못 읽을 번호면 **손대지 않는다.** 지어낸 글자를 넣느니 원문이 낫다.
+      if (!Number.isFinite(번호) || 번호 < 32 || 번호 > 0x10ffff) return 온것;
+      try { return String.fromCodePoint(번호); } catch { return 온것; }
+    })
     .replace(/[ \t]+/g, ' ')
     .replace(/\n\s*\n\s*\n+/g, '\n\n')
     .trim();
@@ -243,6 +266,15 @@ export async function webFetch(args, { allowPrivate = false, 모델컨텍스트
   // 되돌림(redirect)으로 옮겨 간 집도 그 한 번만 연다. 한 홉마다 문지기를 지나므로
   // 여기서 열어 주지 않으면 막힌다 — 그리고 사내망으로 되돌리는 것은 열지 않는다.
   const 열어둔 = [];
+  /*
+   * 되돌림을 따라가면 **정말 답한 곳**은 처음 주소가 아니다.
+   *
+   * 여태 기록에도 오류 문구에도 처음 주소만 적혔다. 그래서 짧은주소 하나가
+   * 302 로 딴 집에 보내 놓고 429 를 뱉으면, 화면에는 짧은주소가 힘들어한다고
+   * 뜬다 — 사람도 모델도 엉뚱한 쪽을 붙잡는다. 심사서에 남는 「어디로 나갔나」
+   * 도 마찬가지로 처음 주소만 남아서, 실제로 통신한 집이 빠진다.
+   */
+  let 닿은곳 = u;
   try {
     // 같은 집이면 줄을 서고, 잠시 뒤 되는 오류면 쉬었다 다시 부른다.
     let res = null;
@@ -264,10 +296,19 @@ export async function webFetch(args, { allowPrivate = false, 모델컨텍스트
         stream: true,                             // 상한까지만 받는다 — 다 받아 놓고 버리지 않는다
         되돌림: async (다음) => {
           await 웹되돌림검사(다음, { allowPrivate });
+          닿은곳 = 다음;
+          방문기록.push({ url: 다음.href, status: 0, at: new Date().toISOString(), 되돌림: true });
           열어둔.push(allowTemporarily(다음.origin));
         },
       }), signal);
-      방문기록.push({ url: u.href, status: res.status, at: new Date().toISOString() });
+      방문기록.push({
+        url: u.href,
+        status: res.status,
+        at: new Date().toISOString(),
+        // 되돌림을 탔으면 **정말 답한 곳**도 같이 적는다. 처음 주소만 남기면
+        // 심사서의 「어디로 나갔나」 에서 실제로 통신한 집이 빠진다.
+        ...(닿은곳.href === u.href ? {} : { 닿은곳: 닿은곳.href }),
+      });
       if (res.ok || !다시할것.has(res.status) || 회차 >= 다시횟수) break;
       await res.버리기?.();
       const 초 = 얼마나쉬라나(res.headers.get('retry-after'), 회차);
@@ -282,14 +323,14 @@ export async function webFetch(args, { allowPrivate = false, 모델컨텍스트
        * 오류를 그냥 번호로만 던지면 모델은 할 수 있는 게 없다. 실제로 그랬다 —
        * `✗ HTTP 429` 만 보고 그 자료를 포기했다. 무엇을 하면 되는지 같이 준다.
        */
-      const 집 = u.hostname;
+      const 집 = 닿은곳.hostname;
       if (res.status === 429) {
         return { error: `HTTP 429 — ${집} 가 "너무 자주 부른다" 고 합니다.`
           + `\n  ${다시횟수}번 쉬었다 다시 불러 봤습니다(${쉰시간}초). 그래도 같습니다.`
           + '\n  한꺼번에 여러 개를 부르지 말고 하나씩 부르거나, 잠시 뒤에 다시 해 보세요.'
           + '\n  키가 있는 API 면 키를 붙인 주소를 쓰면 한도가 늘어납니다.' };
       }
-      if (res.status === 404) return { error: `HTTP 404 — 그런 쪽이 없습니다: ${u.href}\n  주소를 다시 확인하세요.` };
+      if (res.status === 404) return { error: `HTTP 404 — 그런 쪽이 없습니다: ${닿은곳.href}\n  주소를 다시 확인하세요.` };
       if (res.status === 401 || res.status === 403) {
         return { error: `HTTP ${res.status} — ${집} 가 접근을 막았습니다.\n  로그인이나 키가 있어야 하는 쪽입니다. 이 도구로는 못 읽습니다.` };
       }
@@ -297,11 +338,23 @@ export async function webFetch(args, { allowPrivate = false, 모델컨텍스트
         return { error: `HTTP ${res.status} — ${집} 가 지금 힘들어합니다.`
           + `\n  ${다시횟수}번 다시 불러 봤습니다(${쉰시간}초). 잠시 뒤에 다시 해 보세요.` };
       }
-      return { error: `HTTP ${res.status} — ${u.href}` };
+      return { error: `HTTP ${res.status} — ${닿은곳.href}` };
     }
 
     const type = (res.headers.get('content-type') ?? '').toLowerCase();
-    if (!/text|json|xml|javascript/.test(type)) {
+    /*
+     * 갈래는 **낱말로** 본다.
+     *
+     * 그냥 `/text|json|xml|javascript/` 로 보면 두 쪽에서 틀린다.
+     * `application/octet-stream; name="context.bin"` 은 'context' 안의 text 에
+     * 걸려 통과하고(내려받은 바이너리가 모델에게 간다), `application/yaml` 이나
+     * `application/toml` 같은 멀쩡한 글은 낱말이 없어서 거절당한다.
+     */
+    const 갈래 = type.split(';')[0].trim();
+    const 뒷말 = 갈래.split('/')[1] ?? '';
+    const 글인가 = /^text\//.test(갈래)
+      || /(^|[-+.])(json|xml|javascript|ecmascript|yaml|toml|csv|ndjson|graphql)$/.test(뒷말);
+    if (!글인가) {
       await res.버리기?.();
       return { error: `글이 아닌 내용입니다 (${type || '알 수 없음'}). 이 도구는 글만 읽습니다.` };
     }
@@ -323,12 +376,23 @@ export async function webFetch(args, { allowPrivate = false, 모델컨텍스트
     const 머리글 = /charset=["']?([\w-]+)/i.exec(type)?.[1]?.toLowerCase() ?? null;
     let text = 웹글읽기(buf, 머리글);
     if (/html/.test(type)) text = 태그벗기기(text);
-    // <meta charset> 이 머리글과 다르게 적혀 있는 페이지가 있다. 깨졌으면 그걸 믿고 다시 읽는다.
-    if (!머리글 && text.includes('�')) {
+    /*
+     * `<meta charset>` 이 머리글과 **다르게** 적혀 있는 페이지가 있다.
+     *
+     * 여기 `!머리글` 이 붙어 있어서, 정작 그 판 — 머리글이 있는데 틀린 판 —
+     * 에서는 한 번도 안 돌았다. 서버가 기본값으로 `charset=utf-8` 을 붙이고
+     * 본문은 EUC-KR 인 옛 사내 위키가 딱 그렇다. 깨진 글이 그대로 모델에게
+     * 가고, 모델은 깨진 채로 요약한다.
+     *
+     * 다시 읽어서 **덜 깨진 쪽**을 쓴다. 세어 보고 고르니 더 나빠질 일이 없다.
+     */
+    const 깨진수 = (그것) => (그것.match(/�/g) ?? []).length;
+    if (깨진수(text)) {
       const meta = /<meta[^>]+charset=["']?([\w-]+)/i.exec(buf.toString('latin1').slice(0, 2000))?.[1]?.toLowerCase();
-      if (meta) {
-        text = 웹글읽기(buf, meta);
-        if (/html/.test(type)) text = 태그벗기기(text);
+      if (meta && meta !== 머리글) {
+        let 다시 = 웹글읽기(buf, meta);
+        if (/html/.test(type)) 다시 = 태그벗기기(다시);
+        if (깨진수(다시) < 깨진수(text)) text = 다시;
       }
     }
     /*
@@ -365,7 +429,7 @@ export async function webFetch(args, { allowPrivate = false, 모델컨텍스트
         ? `\n\n(여기서 잘렸습니다 — ${남은것}자가 더 있습니다.`
           + '\n 잘린 JSON 은 그대로 읽을 수 없습니다. 다음 중 하나를 하세요:'
           + '\n  · 범위를 좁혀 다시 부른다 (per_page·ids·days 같은 조건을 붙인다)'
-          + `\n  · 같은 주소를 max_chars 를 올려 다시 부른다 (지금 ${max.toLocaleString()}, 최대 100,000))`
+          + `\n  · 같은 주소를 max_chars 를 올려 다시 부른다 (지금 ${max.toLocaleString()}, 최대 120,000)`
         : `\n\n(뒤쪽 ${남은것}자는 잘렸습니다. 더 필요하면 max_chars 를 올려 다시 부르세요.)`;
     }
 

package/src/ui/md.js

@@ -57,13 +57,22 @@ export function 인라인(글) {
   // 자리표시자로 읽혀 엉뚱한 글자로 바뀐다 — 모델이 한 말과 화면이 달라진다.
   let s = String(글 ?? '').replace(/\x00/g, '');
   const 뺀것 = [];
-  s = s.replace(/`([^`]+)`/g, (_, 안) => {
+  // 백틱은 **같은 수만큼** 짝을 짓는다. 하나만 보면 ``a`` 나 ```x``` 처럼 겹쳐
+  // 적은 코드가 안쪽만 걸려서 바깥 백틱이 화면에 그대로 남는다.
+  s = s.replace(/(`+)([\s\S]+?)\1/g, (_, __, 안) => {
     뺀것.push(코드(안));
     return `\x00${뺀것.length - 1}\x00`;
   });
 
-  s = s.replace(/\*\*([^*]+)\*\*/g, (_, 안) => 굵게(안));
-  s = s.replace(/(^|[\s(])\*([^*\s][^*]*)\*(?=$|[\s.,)])/g, (_, 앞, 안) => `${앞}${c.italic(안)}`);
+  // 별표 안쪽이 공백으로 시작하거나 끝나면 굵게가 아니다. 안 막으면 파이썬의
+  // 거듭제곱을 적은 `2 ** 3 ** 4` 가 화면에서 `2  3  4` 가 된다 — 별표가
+  // 소리 없이 사라지고 사람은 모델이 그렇게 말한 줄 안다.
+  s = s.replace(/\*\*([^*\s](?:[^*]*[^*\s])?)\*\*/g, (_, 안) => 굵게(안));
+  // 닫는 별표 뒤는 별표만 아니면 된다. `[\s.,)]` 로 좁혀 두면 조사가 붙는
+  // 한국어(`*중요*입니다`)와 `*주의*!` 에서 별표가 화면에 그대로 남는다.
+  // 굵게와 같이, 안쪽이 공백으로 끝나면 기울임이 아니다 — `5 *x * y` 의 별표를
+  // 먹으면 화면에서 별표가 사라진다.
+  s = s.replace(/(^|[\s(])\*([^*\s](?:[^*]*[^*\s])?)\*(?=$|[^*])/g, (_, 앞, 안) => `${앞}${c.italic(안)}`);
   s = s.replace(/~~([^~]+)~~/g, (_, 안) => c.gray(안));
   // 링크는 글만 보이고 주소는 흐리게. 주소를 지우면 따라갈 수가 없다.
   s = s.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, 글자, 주소) => `${c.under(글자)} ${c.gray(주소)}`);
@@ -86,13 +95,30 @@ export function 한줄(줄, 상태 = { 펜스: false }, 폭 = 80) {
   const s = String(줄 ?? '').replace(/\r+$/, '');
 
   // 코드 울타리. 여는 줄에 언어가 붙어 있으면 그걸 알려 준다.
-  const 울타리 = s.match(/^\s*```(.*)$/);
+  //
+  // 언어 자리에 백틱이 또 들어 있으면 울타리가 아니다 — 마크다운 규칙이 그렇고,
+  // 안 막으면 ```` ```js console.log(1)``` ```` 처럼 한 줄에 다 적은 코드가
+  // 울타리를 **열기만** 한다. 그 뒤로 오는 답 전체가 코드로 그려진다 — 제목도
+  // 굵기도 다 사라지고, 화면은 멀쩡해 보인다.
+  const 울타리 = s.match(/^\s*(`{3,})[ \t]*([^`]*?)[ \t]*$/);
   if (울타리) {
-    const 안쪽 = 울타리[1].trim();
+    const 길이 = 울타리[1].length;
+    const 안쪽 = 울타리[2];
+    const 줄긋기 = (앞) => c.gray(앞 + '─'.repeat(Math.max(2, Math.min(30, 폭 - 6))));
+    if (상태.펜스) {
+      /*
+       * 닫는 울타리는 언어를 못 갖고, 연 것보다 짧을 수도 없다.
+       *
+       * 마크다운 문서를 보여 주려고 백틱 넷으로 열고 그 안에 ```js 를 적는 일이
+       * 흔하다. 안 막으면 그 ```js 가 상자를 일찍 닫아 버린다 — 나머지 코드가
+       * 코드가 아닌 것으로 그려지고, 상자는 열자마자 닫힌 빈 상자가 된다.
+       */
+      if (안쪽 || 길이 < (상태.울타리길이 ?? 길이)) return { 글: `${c.gray('│')} ${c.white(s)}`, 상태 };
+      return { 글: 줄긋기('└'), 상태: { ...상태, 펜스: false, 울타리길이: 0 } };
+    }
     return {
-      글: 상태.펜스 ? c.gray('└' + '─'.repeat(Math.max(2, Math.min(30, 폭 - 6))))
-        : c.gray('┌' + '─'.repeat(Math.max(2, Math.min(30, 폭 - 6))) + (안쪽 ? ` ${안쪽}` : '')),
-      상태: { ...상태, 펜스: !상태.펜스 },
+      글: 줄긋기('┌') + (안쪽 ? c.gray(` ${안쪽}`) : ''),
+      상태: { ...상태, 펜스: true, 울타리길이: 길이 },
     };
   }
 
@@ -108,9 +134,11 @@ export function 한줄(줄, 상태 = { 펜스: false }, 폭 = 80) {
   const 제목 = s.match(/^(#{1,6})\s+(.*)$/);
   if (제목) {
     const 깊이 = 제목[1].length;
-    const 글자 = 인라인(제목[2]);
-    if (깊이 <= 2) return { 글: `${c.hcyan('▍')} ${c.bold(글자)}`, 상태 };
-    return { 글: c.bold(글자), 상태 };
+    // 이어굵게 로 감싼다. c.bold 로 감싸면 제목 안의 코드가 제 색을 끝내면서
+    // 굵기까지 꺼 버려서, 코드 뒷부분만 가늘어진다.
+    const 글자 = 이어굵게(인라인(제목[2]));
+    if (깊이 <= 2) return { 글: `${c.hcyan('▍')} ${글자}`, 상태 };
+    return { 글: 글자, 상태 };
   }
 
   // 인용
@@ -118,10 +146,14 @@ export function 한줄(줄, 상태 = { 펜스: false }, 폭 = 80) {
   if (인용) return { 글: `${c.gray('│')} ${이어흐리게(인라인(인용[1]))}`, 상태 };
 
   // 할 일 목록은 목록보다 먼저 본다 — `- [ ]` 가 그냥 목록으로 먹히면 안 된다.
-  const 할일 = s.match(/^(\s*)[-*+]\s+\[([ xX])\]\s+(.*)$/);
+  // 뒤에 글이 없는 빈 칸(`- [ ]`)도 할 일이다. 뒷글을 요구하면 그것만 글머리표로
+  // 빠져서 화면에 `• [ ]` 라고 대괄호가 그대로 뜬다. 다만 대괄호에 글이 바로 붙은
+  // `- [ ]foo` 는 할 일이 아니다 — 마크다운도 그렇게 안 읽는다.
+  const 할일 = s.match(/^(\s*)[-*+]\s+\[([ xX])\](\s+.*)?$/);
   if (할일) {
     const 표 = 할일[2] === ' ' ? c.gray('☐') : c.green('☑');
-    return { 글: `${할일[1]}${표} ${인라인(할일[3])}`, 상태 };
+    const 뒤 = 할일[3]?.trim() ? ` ${인라인(할일[3].trim())}` : '';
+    return { 글: `${할일[1]}${표}${뒤}`, 상태 };
   }
 
   // 글머리표
@@ -132,8 +164,9 @@ export function 한줄(줄, 상태 = { 펜스: false }, 폭 = 80) {
   const 번호 = s.match(/^(\s*)(\d+)([.)])\s+(.*)$/);
   if (번호) return { 글: `${번호[1]}${c.hcyan(번호[2] + 번호[3])} ${인라인(번호[4])}`, 상태 };
 
-  // 표는 세로줄만 흐리게 한다. 칸을 맞추려면 표 전체를 들고 있어야 하는데,
-  // 그러면 표가 끝날 때까지 화면에 아무것도 안 나온다.
+  // 여기는 **표가 아니었던 것**이 오는 자리다. 진짜 표는 마크다운 클래스가
+  // 모아서 표그리기() 로 칸을 맞춰 그린다. 여기서는 칸 너비를 모르므로
+  // 세로줄만 흐리게 해서 내보낸다.
   if (/^\s*\|.*\|\s*$/.test(s)) {
     // 가름줄(`|---|---|`). 그대로 두면 화면에 작대기가 그대로 뜬다.
     // 바로 앞 머리줄의 칸 너비를 기억해 뒀다가 그 자리에 맞춰 긋는다 —
@@ -182,6 +215,10 @@ const 표줄인가 = (s) => /^\s*\|.*\|\s*$/.test(String(s ?? '').replace(/\r+$/
 /** `---` `:---` `---:` `:---:` — 가름줄의 한 칸인가. */
 const 가름칸인가 = (칸) => /^:?-+:?$/.test(String(칸).trim());
 
+/** 가름줄이 몇 번째 줄인가. 머리줄이 위에 있어야 하므로 1 보다 작으면 표가 아니다. */
+const 가름찾기 = (행들) =>
+  행들.findIndex((행) => 행.length > 0 && 행.every(가름칸인가));
+
 /**
  * 한 줄을 칸으로 가른다.
  *
@@ -232,10 +269,27 @@ function 채우기(글, 폭, 쪽) {
  * 설명 칸이다. 줄인 칸은 잘라 버리지 않고 접는다(접어쓰기). 표에서 글자가
  * 사라지면 그 줄은 아예 못 읽는다.
  */
-export function 표그리기(줄들, 폭 = 80) {
+export function 표그리기(줄들, 폭 = 80, 어떻게 = {}) {
+  return 짜기(줄들, 폭, 어떻게)?.화면 ?? null;
+}
+
+/**
+ * 그 표를 그렸다면 칸 너비가 얼마였을까. 표가 아니면 null.
+ *
+ * 상한에 걸려 표를 나눠 그릴 때, 뒤 묶음에 앞 묶음의 너비를 그대로 물려 주려고
+ * 쓴다. 묶음마다 제 폭을 다시 재면 같은 표인데 위아래의 세로줄이 안 맞는다.
+ */
+export function 표칸너비(줄들, 폭 = 80) {
+  return 짜기(줄들, 폭)?.너비 ?? null;
+}
+
+function 짜기(줄들, 폭 = 80, { 너비고정 = null } = {}) {
   const 행들 = (줄들 ?? []).map(칸가르기);
   // 가름줄이 있어야 표다. 첫 줄일 수는 없다 — 머리줄이 그 위에 있어야 한다.
-  const 가름 = 행들.findIndex((행) => 행.length > 1 && 행.every(가름칸인가));
+  //
+  // 칸이 하나뿐인 표(`| 항목 |`)도 표다. 칸 둘을 요구하면 그것만 표로 안 읽혀
+  // 테두리 없이 세로줄만 그어진 채 나가고, 가름줄의 작대기도 화면에 남는다.
+  const 가름 = 가름찾기(행들);
   if (가름 < 1) return null;
 
   const 열수 = Math.max(...행들.map((행) => 행.length));
@@ -253,9 +307,14 @@ export function 표그리기(줄들, 폭 = 80) {
    */
   const 치레 = 3 * 열수 + 1;
   const 쓸수있는 = Math.max(열수, 폭 - 치레);
-  const 너비 = Array.from({ length: 열수 }, (_, i) => Math.max(1, ...몸.map((행) => width(행[i]))));
+  // 앞 묶음이 쓰던 너비가 있으면 그대로 쓴다. 다시 재면 같은 표의 위아래가
+  // 서로 다른 폭으로 그려진다 — 세로줄이 이음매에서 어긋난다.
+  const 물려받나 = Array.isArray(너비고정) && 너비고정.length === 열수;
+  const 너비 = 물려받나
+    ? 너비고정.map((w) => Math.max(1, w))
+    : Array.from({ length: 열수 }, (_, i) => Math.max(1, ...몸.map((행) => width(행[i]))));
   let 합 = 너비.reduce((a, b) => a + b, 0);
-  while (합 > 쓸수있는) {
+  while (!물려받나 && 합 > 쓸수있는) {
     let 큰 = 0;
     for (let i = 1; i < 너비.length; i += 1) if (너비[i] > 너비[큰]) 큰 = i;
     if (너비[큰] <= 1) break;
@@ -285,7 +344,7 @@ export function 표그리기(줄들, 폭 = 80) {
     화면.push(...한행(i === 0 ? 행.map(이어굵게) : 행));
     화면.push(i === 몸.length - 1 ? 가로('└', '┴', '┘') : 가로('├', '┼', '┤'));
   });
-  return 화면;
+  return { 화면, 너비 };
 }
 
 /**
@@ -308,6 +367,10 @@ export class 마크다운 {
     this.날것중 = false;
     // 그리려고 붙들고 있는 표 줄들. 표가 끝나는 순간 칸을 맞춰 한꺼번에 나간다.
     this.표줄들 = [];
+    // 상한에 걸려 끊은 표의 머리줄(가름줄까지)과 그때 쓰던 칸 너비.
+    // 다음 묶음이 같은 표로 이어 그려지도록 물려준다.
+    this.이어갈머리 = null;
+    this.표너비 = null;
   }
 
   /** 붙들고 있던 표를 내보낸다. 표가 아니었으면 옛 방식으로 한 줄씩 내보낸다. */
@@ -315,8 +378,23 @@ export class 마크다운 {
     const 줄들 = this.표줄들;
     this.표줄들 = [];
     if (!줄들.length) return [];
-    const 그린것 = 표그리기(줄들, this.폭);
-    if (그린것) return 그린것;
+    let 쓴것 = 줄들;
+    let 그린것 = 표그리기(줄들, this.폭, { 너비고정: this.표너비 });
+    /*
+     * 제 가름줄이 없으면 상한에 걸려 끊긴 표의 뒷동강이다. 그때만 앞 묶음의
+     * 머리줄을 얹어 다시 그린다. 무조건 얹으면, 상한 직후에 진짜 새 표가
+     * 시작될 때 남의 머리줄이 그 표에 섞여 들어간다.
+     */
+    if (!그린것 && this.이어갈머리) {
+      쓴것 = [...this.이어갈머리, ...줄들];
+      그린것 = 표그리기(쓴것, this.폭, { 너비고정: this.표너비 });
+    }
+    if (그린것) {
+      // 상한에 걸려 끊기는 묶음일 때만 너비를 기억해 둔다. 여느 표는 한 번에
+      // 다 나가므로 물려줄 데가 없다 — 그때까지 재면 헛일을 한 번 더 하는 것이다.
+      if (this.표너비 === null && 줄들.length >= 표붙들상한) this.표너비 = 표칸너비(쓴것, this.폭);
+      return 그린것;
+    }
     const 나갈것 = [];
     for (const 줄 of 줄들) {
       const r = 한줄(줄, this.상태, this.폭);
@@ -343,9 +421,22 @@ export class 마크다운 {
      */
     if (!this.상태.펜스 && 표줄인가(줄)) {
       this.표줄들.push(줄);
-      return this.표줄들.length >= 표붙들상한 ? this.#표비우기() : [];
+      if (this.표줄들.length < 표붙들상한) return [];
+      /*
+       * 여기서 끊는다. 다음 묶음이 표로 안 읽히지 않도록 머리줄을 기억해 둔다 —
+       * 세 번째 묶음까지 갈 수 있으므로, 이 묶음에 제 머리줄이 없으면 앞서
+       * 기억해 둔 것을 그대로 들고 간다.
+       */
+      const 가름 = 가름찾기(this.표줄들.map(칸가르기));
+      const 머리 = 가름 >= 1 ? this.표줄들.slice(0, 가름 + 1) : this.이어갈머리;
+      const 나갈것 = this.#표비우기();
+      this.이어갈머리 = 머리;
+      return 나갈것;
     }
 
+    // 표가 끝났다. 다음 표는 제 폭을 처음부터 다시 잰다.
+    this.이어갈머리 = null;
+    this.표너비 = null;
     const 앞 = this.#표비우기();
     const r = 한줄(줄, this.상태, this.폭);
     this.상태 = r.상태;
@@ -377,8 +468,11 @@ export class 마크다운 {
        * 그래도 상한은 둔다. 표가 아닌데 세로줄로 시작하는 긴 글(로그 한 덩이
        * 같은 것)이 오면 화면이 멈춘 것처럼 보이면 안 된다.
        */
+      // 지금 담긴 것이 세로줄로 시작할 때만 기다린다. 「표를 붙들고 있으면
+      // 무조건 기다린다」 로 두면, 표 뒤에 이어지는 긴 산문이 줄이 끝날 때까지
+      // 화면에 한 글자도 안 나온다 — 사람 눈에는 답이 멈춘 것으로 보인다.
       const 표기다림 = !this.상태.펜스
-        && (this.표줄들.length > 0 || /^\s*\|/.test(this.담긴것))
+        && /^\s*\|/.test(this.담긴것)
         && width(this.담긴것) <= this.폭 * 표줄최대배;
       if (표기다림) break;
 
@@ -415,9 +509,13 @@ export class 마크다운 {
 
 /** 통째로 있는 글을 한 번에 그린다 (스트리밍이 아닌 자리). */
 export function 그리기(글, 폭 = 80) {
+  const s = String(글 ?? '');
   const md = new 마크다운({ 폭 });
   const 줄들 = [];
-  for (const x of md.넣기(String(글 ?? ''))) 줄들.push(typeof x === 'string' ? x : x.이어붙임);
+  // 마지막 줄에 개행을 얹어 준다. 흘려보내는 자리가 아니므로 줄이 안 끝날 일이
+  // 없는데, 안 얹으면 마지막 줄이 폭을 넘는 순간 「아직 안 끝난 줄」 로 보여
+  // 그 줄만 날것으로 나간다 — 별표와 우물정자가 거기서만 화면에 남는다.
+  for (const x of md.넣기(s && !s.endsWith('\n') ? `${s}\n` : s)) 줄들.push(typeof x === 'string' ? x : x.이어붙임);
   for (const x of md.끝()) 줄들.push(typeof x === 'string' ? x : x.이어붙임);
   return 줄들;
 }

package/src/ui/screen.js

@@ -210,6 +210,19 @@ export class LineScreen {
    * 오히려 그때그때 상태를 알 수 있어 낫다.
    */
   입력자리(session) {
+    /*
+     * 곧 지워질 글부터 걷는다.
+     *
+     * 이 줄이 없었다. 상자화면 쪽 같은 이름 메서드는 임시지움() 을 먼저
+     * 부르는데 여기만 안 불렀다 — 그런데 아래 say('') 는 이 화면의 줄() 이
+     * 아니라 ansi.js 의 say 라, 임시글을 걷는 문이 통째로 안 열렸다.
+     *
+     * 기다림() 은 `\r` 로 커서만 앞으로 보내 놓는다. 그 상태에서 say('') 가
+     * 줄바꿈을 내면 커서만 아래로 내려가고 **「생각 중…」 은 화면에 그대로
+     * 남는다.** 그 아래 상태줄이 붙으므로, 끝난 일의 문구가 입력칸 위에
+     * 붙박인 것처럼 보인다.
+     */
+    this.임시지움();
     say('');
     say(statusLine(session));
     const w = contextWarning(session);