deel-local-cli 1.20.12 → 2.0.0

package/src/ui/md.js

@@ -27,7 +27,7 @@
 //
 // 실제로는 제목·목록·코드펜스가 다 짧은 줄이라 거의 다 그려진다. 안 그려지는
 // 것은 긴 산문뿐인데, 산문은 원래 꾸밀 것이 없다.
-import { c, width } from './ansi.js';
+import { c, width, 화면글거르기 } from './ansi.js';
 import { 접어쓰기 } from './wrap.js';
 
 const 굵게 = (s) => c.bold(s);
@@ -171,7 +171,11 @@ export function 한줄(줄, 상태 = { 펜스: false }, 폭 = 80) {
     // 가름줄(`|---|---|`). 그대로 두면 화면에 작대기가 그대로 뜬다.
     // 바로 앞 머리줄의 칸 너비를 기억해 뒀다가 그 자리에 맞춰 긋는다 —
     // 그래야 세로줄과 가로줄이 만나서 표처럼 보인다.
-    if (/^\s*\|[\s:|-]+\|\s*$/.test(s)) {
+    //
+    // 하이픈을 하나는 **꼭** 요구한다. 안 그러면 빈칸과 세로줄뿐인 줄(`|   |   |`)까지
+    // 걸려서, 내용이 빈 데이터 행이 가로선으로 그려진다 — 그 행의 글이 아니라 행 자체가
+    // 사라진 것으로 보인다 (2.0.0 8회차).
+    if (/^\s*\|[\s:|-]*-[\s:|-]*\|\s*$/.test(s)) {
       const 너비 = 상태.표너비 ?? s.split('|').map(() => 3);
       return { 글: c.gray(너비.map((w) => '─'.repeat(w)).join('┼')), 상태 };
     }
@@ -227,15 +231,36 @@ const 가름찾기 = (행들) =>
  * 세로줄이다. 둘 다 칸을 가르면 안 되는 자리다.
  */
 function 칸가르기(줄) {
-  const s = String(줄 ?? '').replace(/\r+$/, '').trim().replace(/^\|/, '').replace(/\|$/, '');
+  // 끝의 바깥 세로줄만 뗀다 — `\|` 로 끝나면 칸 안의 세로줄이다 (2.0.0 6회차 마크6: `2 \` 만 남았다).
+  //
+  // 「앞이 백슬래시면 무조건 안 뗀다」 로 두면 반대로 샌다. 백슬래시가 **짝수** 개면
+  // 그것들은 서로를 벗긴 것이라 마지막 세로줄은 여전히 바깥 것이다 — `C:\\|` 의 닫는
+  // 세로줄을 못 떼서 칸에 `C:\|` 가 남았다 (2.0.0 8회차). 짝을 먼저 먹고 판단한다.
+  const s = String(줄 ?? '').replace(/\r+$/, '').trim().replace(/^\|/, '').replace(/(^|[^\\])((?:\\\\)*)\|$/, '$1$2');
   const 칸들 = [];
   let 지금 = '';
-  let 코드안 = false;
+  /*
+   * 인라인 코드는 **같은 길이의 백틱 줄**로 닫힌다(``` ``a | b`` ```). 백틱 하나마다 「코드 안」 을
+   * 뒤집었더니 겹백틱 코드 안의 `|` 에서 칸이 갈려 2칸 표가 3칸이 됐다 (2.0.0 6회차 마크6).
+   * 0 이면 코드 밖, 아니면 연 백틱 줄의 길이.
+   */
+  let 코드길이 = 0;
   for (let i = 0; i < s.length; i += 1) {
     const ch = s[i];
+    // `\\` 는 백슬래시 한 자다. 안 벗기면 위에서 짝수로 세어 세로줄을 뗀 칸이
+    // 화면에는 `C:\\` 로 뜬다 — 뗀 만큼 글이 딴 것이 된다 (2.0.0 8회차).
+    if (ch === '\\' && s[i + 1] === '\\') { 지금 += '\\'; i += 1; continue; }
     if (ch === '\\' && s[i + 1] === '|') { 지금 += '|'; i += 1; continue; }
-    if (ch === '`') { 코드안 = !코드안; 지금 += ch; continue; }
-    if (ch === '|' && !코드안) { 칸들.push(지금); 지금 = ''; continue; }
+    if (ch === '`') {
+      let n = 1;
+      while (s[i + n] === '`') n += 1;
+      if (코드길이 === 0) 코드길이 = n;
+      else if (n === 코드길이) 코드길이 = 0;
+      지금 += s.slice(i, i + n);
+      i += n - 1;
+      continue;
+    }
+    if (ch === '|' && 코드길이 === 0) { 칸들.push(지금); 지금 = ''; continue; }
     지금 += ch;
   }
   칸들.push(지금);
@@ -362,6 +387,9 @@ export class 마크다운 {
     // 바닥을 둬서, 좁은 창에서도 짧은 줄은 제 모양으로 나가게 한다.
     this.폭 = Math.max(20, Number(폭) || 0);
     this.담긴것 = '';
+    // 토막 끝에서 끊긴 제어 순서의 앞머리(`ESC [1`). 다음 토막과 붙여서 통째로 뗀다 — 토막마다 따로
+    // 떼면 ESC 만 빠지고 `[1A[2K` 가 글자로 화면에 남는다.
+    this.날토막 = '';
     this.상태 = { 펜스: false };
     // 이 줄은 이미 날것으로 흘려보내기 시작했다 — 뒤늦게 꾸미면 앞뒤가 안 맞는다.
     this.날것중 = false;
@@ -434,17 +462,38 @@ export class 마크다운 {
       return 나갈것;
     }
 
-    // 표가 끝났다. 다음 표는 제 폭을 처음부터 다시 잰다.
+    // 표가 끝났다. 비운 **뒤에** 지운다 — 끝() 이 적어 둔 것과 같은 까닭이다.
+    // 먼저 지우면 상한에 끊긴 표의 뒷동강이 머리줄과 칸 너비를 잃어, 산문이 한 줄
+    // 오는 것만으로 표 아래쪽이 테두리도 정렬도 없는 딴 모양으로 나간다.
+    const 앞 = this.#표비우기();
+    // 다음 표는 제 폭을 처음부터 다시 잰다.
     this.이어갈머리 = null;
     this.표너비 = null;
-    const 앞 = this.#표비우기();
     const r = 한줄(줄, this.상태, this.폭);
     this.상태 = r.상태;
     return [...앞, r.글];
   }
 
   넣기(토막) {
-    this.담긴것 += String(토막 ?? '');
+    // 모델 답은 바깥 글이다 — 섞여 온 터미널 제어 순서는 여기서 뗀다(ansi.js 화면글거르기 머리말).
+    // 그리기() 도 이 길을 지나므로 한 자리에서 막힌다.
+    let 날것 = this.날토막 + String(토막 ?? '');
+    this.날토막 = '';
+    let 끝ESC = Math.max(날것.lastIndexOf('\x1b'), 날것.lastIndexOf('\x9b'));
+    // `ESC ] … ESC` 로 끝나면 마침 글자(ESC \) 가 반만 왔다. 그 ESC 만 붙들면 앞 몸통(링크 주소)이
+    // 끝 안 난 순서로 걸러져 글자로 샌다 — 순서 머리부터 붙든다.
+    if (끝ESC > 0 && 날것.slice(끝ESC) === '\x1b') {
+      const 앞ESC = 날것.lastIndexOf('\x1b', 끝ESC - 1);
+      if (앞ESC >= 0 && /^\x1b(?:\][^\x07\x1b\n]*|[PX^_][^\x1b\n]*)$/.test(날것.slice(앞ESC, 끝ESC))) 끝ESC = 앞ESC;
+    }
+    // 끝난 순서가 아니면(마침 글자 없음) 붙들어 둔다. 너무 길면 순서가 아니라 보고 그냥 뗀다.
+    // 8비트 CSI(0x9b) 와 ESC 두 글자 꼴의 가운데 글자(`ESC (`)도 같다 — 안 붙들면 `2J` · `0` 이 글자로 남는다.
+    if (끝ESC >= 0 && 날것.length - 끝ESC < 256
+      && /^(?:\x1b(?:\[[0-?]*[ -/]*|\][^\x07\x1b\n]*\x1b?|[PX^_][^\x1b\n]*\x1b?|[ -/]*)?|\x9b[0-?]*[ -/]*)$/.test(날것.slice(끝ESC))) {
+      this.날토막 = 날것.slice(끝ESC);
+      날것 = 날것.slice(0, 끝ESC);
+    }
+    this.담긴것 += 화면글거르기(날것);
     const 나갈것 = [];
 
     for (;;) {
@@ -491,19 +540,56 @@ export class 마크다운 {
     return 나갈것;
   }
 
+  /*
+   * ── 여기서 **코드 울타리 안인지**까지 지운다 ────────────────────────────
+   *
+   * 이 파일 위쪽이 한 번 적어 뒀다 — 「울타리를 열기만 하면 그 뒤로 오는 답
+   * 전체가 코드로 그려진다. 제목도 굵기도 다 사라지고, 화면은 멀쩡해 보인다」.
+   * 그 일이 실제로 나던 자리가 여기다.
+   *
+   * 끝() 은 담긴 반 줄과 붙들고 있던 표는 비우면서 `상태.펜스` 만 켜 둔 채로
+   * 돌아갔다. 부르는 쪽(repl.js)은 마크다운 하나를 한 턴 내내 쓰고, 도구를
+   * 부를 때마다 여기를 거친다. 그래서 도구 부르기 직전에 ```js 한 줄이
+   * 나갔으면 **그 턴의 남은 답이 통째로** 회색 세로줄 붙은 날글로 그려졌다.
+   * 잘려서 다시 받는 자리(retry)는 더 나쁘다 — 새로 받은 답 전체가 그 꼴이 된다.
+   *
+   * 화면에 글자는 다 있다. 그래서 아무도 고장으로 안 읽고, 「모델이 오늘
+   * 이상하게 답한다」 로 읽힌다. 흘려보내던 상태는 흘려보내기가 끝나는
+   * **이 자리에서 다 지운다.**
+   */
+  /** 그리던 것을 다 잊는다. 다음 글은 처음부터 읽는다. */
+  처음으로() {
+    this.담긴것 = '';
+    this.날토막 = '';
+    this.상태 = { 펜스: false };
+    this.날것중 = false;
+    this.표줄들 = [];
+    this.이어갈머리 = null;
+    this.표너비 = null;
+  }
+
   /** 답이 끝났다. 남은 것을 내놓는다. */
   끝() {
+    const 나갈것 = [];
+    // 끝내 마침 글자가 안 온 순서 앞머리는 글자가 아니다 — 떼고 버린다. 거르개에 넣었더니
+    // ESC·`[` 만 떼이고 `ESC [1` 의 `1` 이 글자로 남았다 (2.0.0 6회차 마크6).
+    this.날토막 = '';   // 붙들던 앞머리는 버린다
     // 담긴 것은 없는데 날것으로 나가던 중이면 줄만 끝내 준다.
     if (!this.담긴것) {
-      const 닫을것 = this.날것중 ? [{ 이어붙임: '', 끝났나: true }] : [];
+      if (this.날것중) 나갈것.push({ 이어붙임: '', 끝났나: true });
       this.날것중 = false;
       // 표로 끝나는 답이 흔하다(마지막이 정리 표). 여기서 안 비우면 통째로 사라진다.
-      return [...(닫을것.length ? 닫을것 : []), ...this.#표비우기()];
+      나갈것.push(...this.#표비우기());
+    } else {
+      const 남은것 = this.#그리기(this.담긴것);
+      this.담긴것 = '';
+      this.날것중 = false;
+      나갈것.push(...남은것, ...this.#표비우기());
     }
-    const 남은것 = this.#그리기(this.담긴것);
-    this.담긴것 = '';
-    this.날것중 = false;
-    return [...남은것, ...this.#표비우기()];
+    // 비운 **뒤에** 지운다. 먼저 지우면 위 두 줄이 붙들고 있던 표를 옛 방식으로
+    // 내보낼 때 쓸 상태를 잃는다 — 글이 사라지는 것이 제일 나쁘다.
+    this.처음으로();
+    return 나갈것;
   }
 }
 

package/src/ui/motion.js

@@ -402,7 +402,7 @@ const 동물그림들 = {
     ['.#..#.......', '.####.......', '######......', '............'],
   ],
 
-  // 웹 — 새 한 마리가 날아간다. 날개가 오르내린다.
+  // 웹 — 새 두 마리. 앞엣것은 제자리에서 날갯짓하고, 뒤엣것이 오른쪽으로 날아간다.
   웹: [
     ['..#.........', '.###..#.....', '..#..###....', '......#.....'],
     ['.###........', '..#...###...', '......#.....', '............'],
@@ -496,7 +496,10 @@ export const 테마들 = {
  *
  * DEEL_MOTION=기사 · knight · 동물 · animal 로 고른다. 영어 이름도 받는 것은
  * 한글을 못 치는 자리(CI 설정 파일·도커 환경변수)가 있기 때문이다.
- * 모르는 이름이면 조용히 기본으로 간다 — 오타 하나로 프로그램이 안 뜨면 안 된다.
+ * 모르는 이름이면 조용히 **없는 셈 친다** — 오타 하나로 프로그램이 안 뜨면 안 된다.
+ * 없는 셈 치니 그 아래가 이어서 이긴다: 설정 파일에 고른 것이 있으면 그것, 그것도
+ * 없을 때라야 기본이다. `DEEL_MOTION=cat` 은 기본이 아니라 설정대로 돈다는 뜻이라,
+ * `/motion` 은 「환경변수가 이깁니다」 를 말하기 전에 `환경그림()` 으로 되물어야 한다.
  */
 const 이름표 = {
   기사: '기사', knight: '기사', 동물: '동물', animal: '동물', animals: '동물',

package/src/ui/notify.js

@@ -64,7 +64,13 @@ export function 창제목(글) {
   return 쓰기(`\x1b]2;${s}\x1b\\\x1b]1;${s}\x1b\\`);
 }
 
-/** 켤 때 있던 제목으로 돌려놓는다. 남의 터미널을 우리 이름으로 두고 나가지 않는다. */
+/*
+ * 제목을 터미널에 도로 맡긴다 — 남의 터미널을 우리 이름으로 두고 나가지 않는다.
+ *
+ * 켤 때 있던 제목을 그대로 되살리지는 못한다. 그것을 알려면 터미널에 물어야 하는데
+ * (OSC 21), 답하는 터미널이 얼마 없고 안 답하면 그 답을 기다리다 멈춘다. 빈 제목을
+ * 보내면 터미널·셸이 제 규칙대로(대개 셸 프롬프트가 다시 정한다) 채운다.
+ */
 export function 제목되돌리기() {
   return 쓰기('\x1b]2;\x1b\\\x1b]1;\x1b\\');
 }

package/src/ui/office.js

@@ -56,9 +56,21 @@ function 색충분한가() {
 
   // 윈도우는 Node 20 이 Win10 이상을 요구하고, 거기 콘솔은 256색을 한다.
   if (process.platform === 'win32') return true;
-  if (process.env.WT_SESSION) return true;            // 윈도우 터미널
+  /*
+   * 아래 둘은 윈도우 콘솔이 심는 값인데, 정작 **윈도우에서는 한 번도 안 돈다** —
+   * 바로 위 한 줄이 이미 참으로 답하고 나가기 때문이다. 그러니 이 두 줄이 사는
+   * 자리는 윈도우가 아니라 **윈도우가 아닌 판**, 곧 WSL 이다. 윈도우 터미널이
+   * WSLENV 로 WT_SESSION 을 리눅스 쪽에 건너보내므로(WSLENV=WT_SESSION:…),
+   * 거기서는 platform 이 linux 인 채로 이 값만 서 있다.
+   *
+   * 죽은 줄로 보고 지우면 그 자리에서 사무실이 안 켜진다. 자리를 위로 옮겨도
+   * 답은 한 글자도 안 바뀐다(어차피 둘 다 참이다). 그래서 코드는 그대로 두고
+   * 주석만 사실에 맞춘다 — 「윈도우 터미널」 이라고만 적혀 있어서 윈도우에서
+   * 도는 줄로 읽혔다.
+   */
+  if (process.env.WT_SESSION) return true;            // 윈도우 터미널 — WSL 쪽에서 돈다
   if (process.env.TERM_PROGRAM) return true;          // iTerm · VS Code · Apple Terminal
-  if (process.env.ConEmuANSI === 'ON') return true;
+  if (process.env.ConEmuANSI === 'ON') return true;   // ConEmu — 마찬가지로 윈도우 밖에서만
 
   return false;
 }
@@ -375,13 +387,20 @@ export function 사무실줄들(상태, 폭) {
       // 한 바퀴에 1분. 7.5초마다 한 칸씩 — 도는 것이 보이면서도 매 판 다시
       // 그릴 만큼 부산하지는 않다.
       const 칸 = Math.floor((걸린초 % 60) / 7.5) % 8;
-      const [dx, dy] = [[0, -2], [1, -1], [2, 0], [1, 1], [0, 2], [-1, 1], [-2, 0], [-1, -1]][칸];
+      /*
+       * 세로로는 **한 칸만** 뻗는다. 시계판 속은 가로 다섯 · 세로 셋뿐이라,
+       * 세로로 둘을 가면 바늘 끝이 판을 넘어 테두리 줄에 얹힌다. 그 테두리도
+       * 바늘도 C.검정 이라 12시·6시 두 자리는 **안 찍은 것과 똑같은 그림**이
+       * 됐다 — 여덟 자리 중 둘이 서로 구별이 안 됐고, 0초 판과 30초 판이 한
+       * 글자도 안 달랐다. 바늘은 판 안에서만 돈다.
+       */
+      const [dx, dy] = [[0, -1], [1, -1], [2, 0], [1, 1], [0, 1], [-1, 1], [-2, 0], [-1, -1]][칸];
       p.찍기(cx + 3, 2, C.검정);
       p.찍기(cx + 3 + dx, 2 + dy, C.검정);
     }
   }
 
-  // 서류함 12×12 — 읽은 파일. 서랍 하나가 일곱쯤.
+  // 서류함 12×10 — 읽은 파일. 서랍 하나가 일곱쯤 (테두리 한 줄 + 서랍 셋 × 세 줄).
   {
     const 찬칸 = Math.min(3, Math.ceil(읽은파일 / 7));
     const 그림 = ['CCCCCCCCCCCC'];
@@ -680,7 +699,20 @@ export function 상태만들기(session, 일감, 틱 = 0, 할일들 = [], 도는
    * 꺼 둔다 — 다섯이 동시에 돌고 있다고 말하면 그건 거짓말이라서다.
    * 켜진 화면이 지금 도는 것, 꺼진 화면이 아직 차례가 안 온 것이다.
    */
-  for (let i = 0; i < Math.max(0, 할일들.filter((t) => t.state !== 'done').length); i++) {
+  /*
+   * 도는 중(doing)인 일은 빼야 한다. 그 일은 바로 위에서 **켜진 화면**으로 이미 앉혔다.
+   * 또 앉히면 한 사람이 둘이 되고, 바로 이 문단이 못 박은 「꺼진 화면은 아직 차례가 안 온 것」
+   * 이 거짓이 된다 (2.0.0 6회차 사무실6ck-f OF4). 화이트보드 쪽지 셈(아래 할일)은 그대로 —
+   * 거기서는 도는 일도 아직 남은 일이다.
+   *
+   * 다만 그건 **앉힌 사람이 있을 때** 하는 말이다. 일감이 없으면 위 고리가 통째로
+   * 안 돌아 켜진 화면이 하나도 안 생기는데, 여기서만 doing 을 빼고 있었다. 그러면
+   * 하던 일이 방에서 **증발한다** — 화이트보드에는 쪽지가 붙어 있는데 방은 텅 비어,
+   * 같은 화면이 두 말을 한다. 뺄 사람이 없으면 빼지 않는다.
+   */
+  const 아직안잡은일 = 할일들
+    .filter((t) => t.state !== 'done' && !(일감 && t.state === 'doing')).length;
+  for (let i = 0; i < Math.max(0, 아직안잡은일); i++) {
     일꾼들.push({ 갈래: '기다림' });
   }
 

package/src/ui/pastechip.js

@@ -37,8 +37,9 @@ export function 크기말(바이트) {
 /**
  * 이 덩이가 상자에 안 들어가나.
  *
- * 들어가면 접지 않는다 — 세 줄짜리는 그냥 보이는 편이 낫다. 접을지는
- * 줄 수만 세면 안 된다. 한 줄이어도 폭보다 길면 상자 안에서 여러 줄로
+ * 개행이 하나라도 있으면 줄 수를 안 따지고 접는다 (아래 까닭). 개행이 없는
+ * 한 덩이는 들어가면 접지 않는다 — 상자에 보이는 편이 낫다. 그 들어가는지를
+ * 줄 수만 세서 보면 안 된다. 한 줄이어도 폭보다 길면 상자 안에서 여러 줄로
  * 접히기 때문이다. 그래서 상자가 쓰는 접어쓰기 로 똑같이 세어 본다.
  */
 export function 접을까(글, { 폭 = 80, 최대 = 안쪽최대 } = {}) {

package/src/ui/pick.js

@@ -18,6 +18,7 @@
 //     2 - 파일은 나눠서 해줘
 //     1,3                        (둘 다)
 //     1 3 둘 다 하되 순서는 반대로
+//     2번 파일은 나눠서           (한국 사람은 번호를 「2번」 이라고 친다)
 //
 // ── 어디서 멈추나 ───────────────────────────────────────────────────────
 //
@@ -26,15 +27,34 @@
 // 사람이 고른 적 없는 것을 골랐다고 하는 셈이라, 안 받느니만 못하다.
 // 그래서 수 바로 뒤에 글자가 붙어 있으면(3개) 수로 안 읽는다.
 //
+// 「번」 하나만 그 선 안으로 들인다. 「2번」 을 못 읽으면 가장 흔한 답이 고른 것 없는 글이
+// 된다. 「번」 뒤에도 끝이나 구분표가 와야 한다 — 「2번째로」 · 「2번으로 해줘」 는 여태처럼
+// 사람 말로 둔다(골랐다고 우기는 쪽이 더 나쁘다).
+//
 // 목록에 없는 수도 안 읽는다. 선택지가 둘인데 「5분만 기다려」 라고 치면
 // 그건 고른 것이 아니라 하는 말이다.
 
-/** 수 뒤에 올 수 있는 것 — 끝, 빈칸, 그리고 흔한 구분표. `1.5` 는 수가 아니다. */
-const 수뒤 = /^(\d{1,3})(?:\s*[.):：\]](?!\d)|\s*[,，、·]|\s|$)/;
+/*
+ * 수 뒤에 올 수 있는 것 — 끝, 빈칸, 그리고 흔한 구분표. `1.5` 는 수가 아니다.
+ *
+ * 「번」 앞의 빈칸도 받는다. 「1 번」 이라고 치면 「번」 이 하고 싶은 말로 남아 모델에게
+ * 「가 — 번」 이 갔다 (2.0.0 6회차 고르기6cg PK1).
+ *
+ * 붙임표도 구분표다. 머리말이 적어 둔 「2 - 나눠서」 는 읽으면서 빈칸 없는 「2- 나눠서」 는
+ * 아무것도 못 골랐다. 다만 뒤가 숫자면 안 읽는다 — 「2-3」 은 범위로 친 말이지 둘을 고른 것이
+ * 아니다 (PK2).
+ *
+ * 「번」 뒤도 마찬가지다. 전방탐색에 붙임표가 빠져 있어서 「2번- 나눠서」 만 아무것도 못 골랐다 —
+ * 「2- 나눠서」 는 읽는데 「번」 을 하나 더 친 사람만 고른 것이 사라진다 (8회차 PK4).
+ */
+const 수뒤 = /^(\d{1,3})(?:\s*번(?=[\s,，、·.):：\]\-–—]|$))?(?:\s*[.):：\]](?!\d)|\s*[,，、·]|\s*[-–—](?!\d)|\s|$)/;
 
 /** 수와 말 사이에 사람이 흔히 넣는 것들. 말 앞머리에서 떼어 낸다. */
 const 사이표 = /^[\s,，、·:：\-–—>]+/;
 
+/** 전각 숫자(０–９)를 보통 숫자로. 일본어·중국어 입력기는 번호를 이렇게 낸다. */
+const 숫자펴기 = (s) => String(s ?? '').replace(/[０-９]/g, (d) => String.fromCharCode(d.charCodeAt(0) - 0xfee0));
+
 /**
  * 답 한 줄을 「고른 번호들」과 「덧붙인 말」로 가른다.
  *
@@ -49,7 +69,7 @@ export function 고른것풀기(답, 고를것 = []) {
   if (!원) return { 번호들: [], 덧말: '', 글: '' };
 
   const 번호들 = [];
-  let 남은 = 원;
+  let 남은 = 숫자펴기(원);
   for (;;) {
     const m = 수뒤.exec(남은);
     if (!m) break;
@@ -70,15 +90,63 @@ export function 고른것풀기(답, 고를것 = []) {
   return { 번호들, 덧말, 글 };
 }
 
+/*
+ * 계획 상자 첫 낱말을 표와 견주기 전에 다듬는다.
+ *
+ * 글자 그대로 견줬더니 「ok.」 「네.」 「yes!」 가 표에 없는 글이 되어 「그 말대로 다시 짜라」 로
+ * 갔다. 자음을 두 번 친 「ㅇㅇ」 「ㄴㄴ」 도 그랬다 — 그러라고 했는데 계획이 또 나오고, 그만하라고
+ * 했는데 또 나온다.
+ *
+ * 떼는 것은 끝의 마침표·느낌표·물결뿐이다. **물음표는 안 뗀다** — 「네?」 「ok?」 는 되묻는
+ * 말이지 그러라는 말이 아니다. 애매하면 여태처럼 「다시」 로 두는 편이 낫다(계획을 한 번 더
+ * 보는 것이, 안 시킨 일을 하는 것보다 싸다).
+ */
+function 낱말다듬기(낱말) {
+  return String(낱말 ?? '').toLowerCase()
+    .replace(/[.!~。！]+$/u, '')
+    .replace(/^(ㅇ|ㄴ|ㄱ)\1+$/u, '$1');
+}
+
+/*
+ * ── 멈추라는 말 · 진행을 뒤집는 말 (Gemini 화면4) ──────────────────────────
+ *
+ * 첫 낱말만 표와 견줬다. 그래서 두 자리가 틀렸다.
+ *   · 「그만」 「멈춰」 「stop」 「cancel」 이 멈춤 표에 없어서 「그 말대로 다시 짜라」 로 갔다 —
+ *     그만하라는데 계획이 또 나온다.
+ *   · 첫 낱말이 진행 쪽이면 뒤는 「진행하되 한마디」 로 얹었다. 「ok 말고」 「진행 하지 마」
+ *     「응 취소」 「y 아니 멈춰」 가 전부 **계획 실행**으로 갔다 — 안 시킨 일을 한다.
+ *
+ * 뒤에 부정·멈춤 말이 붙은 진행은 뜻이 둘로 읽힌다. 멈춤으로 못 박지도 않는다(「y 테스트는 하지
+ * 말고」 는 진행하되 빼라는 말일 수 있다). 여태 원칙대로 「다시」 — 계획을 한 번 더 보는 것이
+ * 안 시킨 일을 하는 것보다 싸다. 영어 낱말은 낱말 경계로만 본다 — 「note」 의 not 에 안 걸리게.
+ */
+const 멈춤낱말 = ['n', 'no', 'nope', 'ㄴ', '아니', '아니요', '아뇨', '취소', '그만', '그만해', '멈춰', '중단', '종료', '중지', '포기', 'stop', 'cancel', 'abort', 'quit'];
+const 뒤집는말 = /말고|하지\s*마|하지\s*말|안\s*돼|안\s*되|멈춰|멈추|그만|취소|중단|종료|포기|중지|아니|아뇨|잠깐|(?:^|[^a-z])(?:no|not|nope|don['’]?t|abort|quit|halt|stop|cancel|wait)(?![a-z])/i;
+/*
+ * 멈추라는 말을 **뒤집는** 말. 「취소 말고」 「그만 말고」 는 멈추라는 말이 아니다.
+ *
+ * 위 뒤집는말 을 그대로 쓰면 안 된다 — 거기에는 멈춤 말이 다 들어 있어서 「no 그만해」 처럼
+ * 두 번 멈추라는 답까지 「다시」 로 가고, 그만하라는데 계획이 또 나온다. 그래서 여기서는
+ * 부정하는 말만 본다. 진행 쪽에 이미 있는 원칙(애매하면 다시)을 멈춤 쪽에도 맞춘 것이다
+ * (2.0.0 6회차 고르기6cg PK3).
+ */
+const 부정말 = /말고|하지\s*마|하지\s*말|안\s*돼|안\s*되/;
+/*
+ * 그러라는 말. 「진행해」 「좋아」 「ㄱㄱ」 「okay」 가 표에 없어서 「그 말대로 다시 짜라」 로 갔다 —
+ * 그러라고 했는데 계획이 또 나온다(Gemini 화면5). 멈추라는 말만큼 비싸지는 않지만 한 번 더 도는 값을 치른다.
+ */
+const 진행낱말 = ['y', 'yes', 'ㅇ', '응', '네', '예', '진행', '진행해', '진행해줘', '좋아', '좋아요', '좋습니다', '그래', '그래요',
+  'ok', 'okay', 'sure', 'go', 'ㄱ', '고', '고고'];
+
 /**
  * 계획 상자의 답을 읽는다.
  *
  * 갈래는 셋(진행·그만·다시)이고, 들어오는 모양은 다섯이다.
- *   · 그냥 진행      — ⏎ · y · yes · ㅇ · 진행
+ *   · 그냥 진행      — ⏎ · y · yes · ㅇ · ㅇㅇ · 응 · 진행 (끝의 . ! 는 떼고 본다)
  *   · 진행하되 한마디 — `y 검사도 같이 넣어줘`
- *   · 그만            — n · no · ㄴ
- *   · 그 밖의 글      — 그 말대로 다시 짜라 (여태 그대로)
- *   · `3 이건 빼자`   — 3단계에 대한 말로 붙여서 다시 짜라
+ *   · 그만            — n · no · ㄴ · ㄴㄴ · 그만 · 멈춰 · 취소 · stop · cancel
+ *   · 그 밖의 글      — 그 말대로 다시 짜라 (여태 그대로). 진행 낱말 뒤에 뒤집는 말이 붙어도(「ok 말고」) 여기다
+ *   · `3 이건 빼자`   — 3단계에 대한 말로 붙여서 다시 짜라 (`3번 이건 빼자` 도)
  *
  * ⏎ 하나로 진행하는 것은 안 건드린다. 계획을 읽고 「그래」 하는 데
  * 두 글자를 더 치게 하면, 그 두 글자 때문에 안 읽고 넘기게 된다.
@@ -91,22 +159,27 @@ export function 계획답풀기(답, 단계수 = 0) {
   const 원 = String(답 ?? '').trim();
   if (!원) return { 갈래: '진행', 덧말: '', 단계: null };
 
-  const 첫낱말 = 원.split(/\s+/)[0].toLowerCase();
+  const 첫낱말 = 낱말다듬기(원.split(/\s+/)[0]);
   const 나머지 = 원.slice(원.split(/\s+/)[0].length).replace(사이표, '').trim();
 
-  if (['n', 'no', 'ㄴ', '아니', '아니요', '취소'].includes(첫낱말)) {
+  if (멈춤낱말.includes(첫낱말)) {
+    // 「취소 말고」 「그만 말고」 — 첫 낱말은 멈춤인데 뒤가 뒤집는다. 진행 쪽과 같이 「다시」 로 둔다.
+    if (부정말.test(나머지)) return { 갈래: '다시', 덧말: 원, 단계: null };
     return { 갈래: '그만', 덧말: '', 단계: null };
   }
-  if (['y', 'yes', 'ㅇ', '네', '예', '진행', 'ok', 'go'].includes(첫낱말)) {
+  if (진행낱말.includes(첫낱말)) {
+    // 「ok 말고」 「응 취소」 — 첫 낱말은 진행인데 뒤가 뒤집는다. 애매하면 다시 (위 뒤집는말 머리말).
+    if (뒤집는말.test(나머지)) return { 갈래: '다시', 덧말: 원, 단계: null };
     return { 갈래: '진행', 덧말: 나머지, 단계: null };
   }
 
   // 「3 이건 빼자」 — 그 단계에 대고 하는 말이다.
-  const m = 수뒤.exec(원);
+  const 펴진 = 숫자펴기(원);
+  const m = 수뒤.exec(펴진);
   if (m) {
     const n = Number(m[1]);
     if (Number.isInteger(n) && n >= 1 && n <= 단계수) {
-      const 말 = 원.slice(m[0].length).replace(사이표, '').trim();
+      const 말 = 펴진.slice(m[0].length).replace(사이표, '').trim();
       if (말) return { 갈래: '다시', 덧말: 말, 단계: n };
     }
   }