deel-local-cli 1.20.7 → 1.20.9

package/src/commands.js

@@ -29,7 +29,7 @@ import { 종, 알릴만한초 } from './ui/notify.js';
 import { 말, 말 as 옮긴말, 언어, 언어들, 언어정하기, 언어고르기, 옮긴만큼, 지시말, 지시말정하기, 지시말따로정했나 } from './i18n/index.js';
 import { 프로필찾기, 쓸수있나, 연결만들기, 알릴말, 목록보기 } from './agent/models.js';
 import { allowTemporarily } from './safety/network.js';
-import { chat, 규격이름, 더할머리 } from './backend/adapter.js';
+import { chat, 규격이름, 더할머리, 나가는눈금 } from './backend/adapter.js';
 import { 잠잠기본, 무소식기본 } from './backend/http.js';
 import { 인증서설정, 인증서말 } from './backend/clientcert.js';
 import { 알림채움, 알림말 } from './backend/retry.js';
@@ -64,7 +64,7 @@ export function 적용하기(고른것) {
   끔설정(값 === '끔');
 }
 import { PROFILES, LEVELS as THINK_LEVELS, normalizeProfile, table as effortTable, 가벼운강도, shiftLevel } from './agent/effort.js';
-import { 전선붙이기, 전선말, 눈금맞추기 } from './backend/wire.js';
+import { 전선붙이기, 전선말 } from './backend/wire.js';
 import { scanLocal, toProfiles } from './backend/scan.js';
 import { list as listSessions } from './agent/store.js';
 import { MODES as WORK_MODES, ORDER as WORK_ORDER, DEFAULT as WORK_DEFAULT, normalize as normWork, get as getWork, canWrite, 보일이름, 보일한줄 } from './agent/modes.js';
@@ -110,7 +110,15 @@ function 경로처럼보이나(line) {
   if (첫낱말.includes('/') || 첫낱말.includes('\\')) return true;
   // `/tmp` 처럼 슬래시가 하나뿐이어도, 실제로 있는 자리면 경로로 본다.
   if (첫낱말 && !COMMANDS[첫낱말.toLowerCase()]) {
-    try { if (existsSync(line.slice(1).trim())) return true; } catch { /* 못 보면 아닌 걸로 */ }
+    /*
+     * **적힌 그대로**도 보고, 앞 슬래시를 뗀 것도 본다.
+     *
+     * 앞서는 뗀 것만 봤다. 그러면 `/tmp` 가 지금 폴더의 `tmp` 를 찾다 못 찾아,
+     * 바로 위 머리글이 적어 둔 그 자리가 한 번도 안 먹었다. 둘 다 보면 여태
+     * 되던 것(지금 폴더의 이름)도 그대로 된다.
+     */
+    const 통째 = line.trim();
+    try { if (existsSync(통째) || existsSync(통째.slice(1))) return true; } catch { /* 못 보면 아닌 걸로 */ }
   }
   return false;
 }
@@ -504,7 +512,8 @@ export async function handle(line, session, ctx) {
       const 끄는말 = ['off', '끔', '꺼', '끄기', 'n', 'no', 'ㄴ'];
       const 값 = String(arg ?? '').trim().toLowerCase();
       if (!값) {
-        const 켜져있나 = cfg.bell !== false;
+        // 지금 세션이 참이다. 설정 파일은 '다음에 켤 때' 값일 뿐이다.
+        const 켜져있나 = ctx?.종알림 ? ctx.종알림.켬 !== false : cfg.bell !== false;
         const 상태 = 켜져있나 ? c.hgreen(말('bell.stateOn')) : c.gray(말('bell.stateOff'));
         say('');
         say(`  ${c.gray(말('bell.now', { 상태 }))}`);
@@ -522,6 +531,9 @@ export async function handle(line, session, ctx) {
       }
       cfg.bell = 켜는말.includes(값);
       설정남기기(cfg);
+      // 이 세션에도 바로 먹여야 한다 — 아래 줄이 그렇게 적는다.
+      // repl 은 켤 때 읽어 둔 그릇으로 울릴지 말지를 정한다(repl.js 의 알림).
+      if (ctx?.종알림) ctx.종알림.켬 = cfg.bell;
       say('');
       say(`  ${mark.ok} ${말(cfg.bell ? 'bell.turnedOn' : 'bell.turnedOff')}`);
       // 켤 때는 한 번 울려 준다. "켰다는데 소리가 나나?" 를 그 자리에서 확인하게.
@@ -726,7 +738,9 @@ export async function handle(line, session, ctx) {
        */
       if (/^(auto|자동)(\s|$)/.test(말)) {
         const 값 = 말.replace(/^(auto|자동)\s*/, '').trim().toLowerCase();
-        const 켤까 = 값 === '' ? session.autoThink === false : /^(on|켜|켜기|true)$/.test(값);
+        // `켬` 도 켜는 말이다. /bell 은 받는데 여기만 빠져 있어서, `/think auto 켬`
+        // 이 **끄는** 명령이 됐다 — 켜려고 친 말로 꺼지고 화면은 「껐습니다」 였다.
+        const 켤까 = 값 === '' ? session.autoThink === false : /^(on|켬|켜|켜기|true|y|yes|ㅇ)$/.test(값);
         session.autoThink = 켤까;
         say(`  ${mark.ok} ${옮긴말(켤까 ? 'think.autoOn' : 'think.autoOff')}`);
         showThink(session);
@@ -745,6 +759,12 @@ export async function handle(line, session, ctx) {
       }
 
       if (!THINK_LEVELS.includes(말)) {
+        // 못 알아들은 값은 못 알아들었다고 먼저 말한다. 안 그러면 `/think hgih`
+        // 가 오류 없이 표만 띄워서, 강도를 올린 줄 알고 그대로 쓰게 된다.
+        if (말) {
+          say('');
+          say(`  ${mark.no} ${c.gray(옮긴말('think.unknown', { 값: 말 }))}`);
+        }
         showThink(session);
         return { handled: true };
       }
@@ -769,7 +789,16 @@ export async function handle(line, session, ctx) {
      */
     case 'mode': {
       const { 승인, 차례: 승인차례, 표시: 승인표시 } = await import('./ui/approve.js');
-      if (!MODES[arg]) {
+      /*
+       * 표에 **제 것으로 있는** 이름만 받는다.
+       *
+       * `MODES[arg]` 는 물려받은 열쇠에도 참이다. `/mode constructor` 를
+       * 치면 목록으로 안 빠지고 그대로 session.mode 에 들어가는데, 그 값은
+       * strict 도 confirm 도 아니라 **아무것도 안 물어보는** 상태가 된다
+       * (agent/loop.js 의 needsOk). 화면에는 `엄격 → undefined` 가 찍힌다.
+       * `--work` 오타가 가장 센 모드로 돌던 것과 같은 자리다.
+       */
+      if (!Object.hasOwn(MODES, arg)) {
         rule('승인 방식 — 무엇을 물어볼까', 70);
         for (const k of 승인차례) {
           const 지금 = k === session.mode;
@@ -820,7 +849,23 @@ export async function handle(line, session, ctx) {
      * 되돌린 것이 다음 순간 되살아난다.
      */
     case 'undo': {
-      const n = Math.max(1, parseInt(arg, 10) || 1);
+      /*
+       * 못 읽는 인자로 **말없이 한 턴을 되돌리지 않는다.**
+       *
+       * parseInt 는 `다섯`·`abc` 를 NaN, `-2` 를 음수로 준다. 앞서는 둘 다
+       * 1 로 깎아서, 다섯 턴을 되돌리려던 사람이 한 턴만 되돌아간 화면을
+       * 봤다. 되돌리기는 **파일을 실제로 되돌리는** 명령이라 잘못 읽은 수로
+       * 도는 값이 다른 명령보다 비싸다. /work 가 오타를 먼저 말하는 것과
+       * 같은 잣대다.
+       */
+      const 준말 = String(arg ?? '').trim();
+      if (준말 && !/^[0-9]+$/.test(준말)) {
+        say(`  ${mark.no} ${c.gray('몇 턴을 되돌릴지 숫자로 적어 주세요.')} ${c.cyan('/undo 3')}`);
+        say(`  ${c.gray('그냥')} ${c.cyan('/undo')} ${c.gray('만 치면 한 턴을 되돌립니다.')}`);
+        say('');
+        return { handled: true };
+      }
+      const n = Math.max(1, parseInt(준말, 10) || 1);
       const r = ctx.history.undo(n);
       /*
        * 세는 수는 **진짜로 되돌아간 것**이다.
@@ -832,8 +877,17 @@ export async function handle(line, session, ctx) {
        */
       const 되돌린수 = r.되돌린수 ?? r.restored.length;
       ctx.audit.undo({ turns: r.turns, files: 되돌린수 });
-      if (!r.restored.length) {
+      /*
+       * **하나도 안 되돌아갔으면** 되돌렸다고 하지 않는다.
+       *
+       * restored 에는 못 되돌린 것과 손대지 않은 것(바이너리처럼 내용을 못
+       * 떠 둔 파일)도 들어 있다. 그 길이만 보면, 되돌아간 파일이 0개인
+       * 판에도 `✓ … 파일 0개를 되돌렸습니다` 를 찍고 그 밑에 못 되돌린
+       * 파일 목록을 성공 목록처럼 늘어놓았다.
+       */
+      if (!되돌린수) {
         say(`  ${c.gray(말('undo.nothing'))}`);
+        if (r.못한것?.length) say(`  ${mark.warn} ${말('undo.failed', { n: r.못한것.length })}`);
         say('');
         return { handled: true };
       }
@@ -1238,6 +1292,33 @@ export async function handle(line, session, ctx) {
         return { handled: true };
       }
 
+      /*
+       * 지우려다 **적고 마는** 자리를 막는다.
+       *
+       * `/memory 지우기` 처럼 번호를 안 붙이면 위 무늬에 안 걸리고 아래
+       * 「이걸 기억해라」 로 떨어졌다. 그래서 `지우기` 라는 낱말이 기억 파일에
+       * **영영 적히고**, 화면에는 「기억했습니다」 라고 떴다. 그 줄은 그 뒤로
+       * 매 요청마다 모델에게 같이 나간다. 지우려던 사람이 쓰레기를 하나 더
+       * 심는 꼴이고, 그것도 성공 표시를 보면서 그렇게 된다.
+       */
+      // 낱말 끝은 `\\b` 로 못 잡는다 — 한글은 \\w 가 아니라 `지우기` 뒤에 낱말
+      // 경계가 안 생긴다. 실제로 이 무늬로 고쳤다가 한글만 그대로 새 나갔다.
+      if (/^(지우기|잊어|forget|rm)(\s|$)/i.test(말)) {
+        const 있는것 = M.읽기(session.root).줄들;
+        say(`  ${mark.no} ${c.gray('몇 번째 줄을 지울지 번호를 적어 주세요.')}`);
+        if (있는것.length) {
+          for (const [i, l] of 있는것.entries()) {
+            say(`  ${c.gray(String(i + 1).padStart(2))}  ${c.white(clip(l, 82))}`);
+          }
+          say('');
+          say(`  ${c.cyan('/memory 지우기 1')}   ${c.gray('한 줄만')}      ${c.cyan('/memory 비우기')}   ${c.gray('전부')}`);
+        } else {
+          say(`  ${c.gray('지금은 기억해 둔 것이 없습니다.')}`);
+        }
+        say('');
+        return { handled: true };
+      }
+
       // 그 밖의 말은 '이걸 기억해라' 로 본다. 모델을 안 거치고 바로 적는 길이다.
       if (말) {
         const r = M.더하기(session.root, 말);
@@ -1745,12 +1826,23 @@ function showSkills(session, arg) {
   }
   if (q.startsWith('on ')) {
     const term = q.slice(3).trim().toLowerCase();
-    let n = 0;
-    for (const s of all) {
-      s.enabled = 낮게(s.name).includes(term) || 낮게(s.description).includes(term);
-      if (s.enabled) n++;
+    const 걸린것 = all.filter((s) => 낮게(s.name).includes(term) || 낮게(s.description).includes(term));
+    /*
+     * 한 개도 안 걸리면 **아무것도 안 건드린다.**
+     *
+     * 앞서는 걸림 여부를 그대로 enabled 에 넣었다. 그래서 오타 하나면 전부
+     * false 가 되고, 화면에는 `✓ "리뷰" 에 걸리는 0개만 올립니다` 가 떴다.
+     * 올리려고 친 명령이 가지고 있던 것까지 다 내려 버리는데, 표시는 ✓ 다.
+     * 그다음 모델이 스킬을 못 쓰는 것을 보고 사람은 스킬이 깨진 줄 안다.
+     */
+    if (!걸린것.length) {
+      say(`  ${mark.no} "${term}" 에 걸리는 스킬이 없습니다 ${c.gray('— 올라간 것은 그대로 둡니다.')}`);
+      say(`  ${c.gray('무엇이 있는지 보려면')} ${c.cyan('/skills')}`);
+      say('');
+      return;
     }
-    say(`  ${mark.ok} "${term}" 에 걸리는 ${n}개만 올립니다.`);
+    for (const s of all) s.enabled = 걸린것.includes(s);
+    say(`  ${mark.ok} "${term}" 에 걸리는 ${걸린것.length}개만 올립니다.`);
     say('');
     return;
   }
@@ -1934,7 +2026,15 @@ function showThink(session, { 자세히 = false } = {}) {
   }
   if (session.conn?.전선) {
     const 카드 = session.conn.전선;
-    const 나가는것 = 눈금맞추기(카드, session.think);
+    /*
+     * **정말로 나가는 것만** 적는다.
+     *
+     * 여태 여기서 `눈금맞추기()` 를 직접 불렀다. 그 함수는 카드가 아는 눈금으로
+     * 낮추는 일만 하고 그 눈금이 실릴 칸이 있는지는 모른다 — 그래서 눈금이
+     * 아예 안 나가는 전선(budget·boolean·none)에서도 「지금 나가는 값 high」
+     * 가 떴다. 몸을 만드는 자리와 같은 함수를 쓴다(backend/adapter.js).
+     */
+    const 나가는것 = 나가는눈금(session.conn.kind, 카드, session.think);
     /*
      * ── 「끈다」 가 정말로 꺼지는 창구인가 ────────────────────────────
      *
@@ -2287,9 +2387,18 @@ async function 리뷰명령(session, ctx) {
 
 async function 커밋명령(session, ctx, arg = '') {
   const 말한것 = String(arg ?? '').trim();
-  const 전부 = /^(전부|all)$/i.test(말한것);
-  const 미리보기 = /^(미리보기|preview|dry|--dry-run)$/i.test(말한것);
-  const 준제목 = 전부 || 미리보기 ? null : (말한것 || null);
+  /*
+   * `전부` 뒤에 제목을 같이 적을 수 있다.
+   *
+   * 앞서는 `^(전부|all)$` 라 `/commit 전부 버그 수정` 이 **둘 다** 어긋났다 —
+   * 전부가 거짓이 되어 폴더째 바뀐 파일이 빠지고, `전부 버그 수정` 이 통째로
+   * 커밋 제목이 됐다. 어느 쪽도 화면에 안 적힌다.
+   */
+  const 전부친것 = /^(전부|all)(\s+|$)/i.exec(말한것);
+  const 전부 = !!전부친것;
+  const 남은말 = 전부 ? 말한것.slice(전부친것[0].length).trim() : 말한것;
+  const 미리보기 = /^(미리보기|preview|dry|--dry-run)$/i.test(남은말);
+  const 준제목 = 미리보기 ? null : (남은말 || null);
 
   say('');
   rule('커밋', 70);
@@ -2516,6 +2625,37 @@ function 배움명령(session, ctx, arg = '') {
     return;
   }
 
+  /*
+   * ── 전선만 지우는 길 ────────────────────────────────────────────────────
+   *
+   * 전선 모양은 틀리게 배울 수 있는 유일한 것이고(backend/wire.js), 틀리면
+   * 멀쩡한 기능이 꺼진 채 굳는다. 그런데 되돌릴 길이 「전부 비우기」 하나라,
+   * 몇 주 쌓은 명령 겪음까지 같이 날아갔다 — 그게 아까워서 사람은 안 비우고,
+   * 안 비우니 꺼진 기능을 그냥 안고 쓴다. 전선만 지우면 잃을 것이 없다.
+   */
+  /*
+   * 지우는 말은 **반드시 적어야** 한다.
+   *
+   * 앞서는 `\s*(…)?` 라 `/learned 전선` 만 쳐도 곧바로 지웠다. 화면이 알려
+   * 주는 명령은 `/learned 전선 지우기` 라 그 짧은 꼴은 어디에도 안 적혀
+   * 있는데, 「전선에서 뭘 배웠나 보자」 는 마음으로 치면 그것이 지우는
+   * 명령이 됐다. 지우는 명령은 지우겠다고 적었을 때만 지운다.
+   */
+  if (/^(전선|wire)$/i.test(String(arg).trim())) {
+    say(`  ${c.gray('전선에서 배운 것만 비우려면')} ${c.cyan('/learned 전선 지우기')}`);
+    say(`  ${c.gray('쌓인 것을 보려면')} ${c.cyan('/learned')}`);
+    say('');
+    return;
+  }
+  if (/^(전선|wire)\s+(지우기|clear|forget|비우기)$/i.test(String(arg).trim())) {
+    배움.지우기('전선');
+    if (session.conn) 전선붙이기(session.conn, 배움);
+    say(`  ${mark.ok} ${c.gray('전선에서 배운 것만 비웠습니다 — 다음 요청부터 짐작으로 다시 시작합니다.')}`);
+    say(`  ${c.gray('겪어 본 명령과 토큰 보정은 그대로 둡니다.')}`);
+    say('');
+    return;
+  }
+
   if (/^(지우기|clear|forget|비우기)$/i.test(String(arg).trim())) {
     배움.지우기('전부');
     session.배움요약 = null;
@@ -2580,8 +2720,29 @@ function 배움명령(session, ctx, arg = '') {
   } else {
     say(`  ${c.gray('아직 프롬프트에 실을 만큼 확실한 것은 없습니다 — 두 번 이상 겪어야 싣습니다.')}`);
   }
+  /*
+   * ── 전선에서 배운 것도 여기 보인다 ──────────────────────────────────────
+   *
+   * 쌓인 것 중 **제일 크게 작용하는 것**이 전선 모양인데(무엇을 실어 보낼지
+   * 가 여기서 갈린다) 이 화면에 아예 안 떴다. 그래서 잘못 배운 판에서 사람이
+   * 「배운 것을 보자」 고 여기를 열면, 정작 문제인 줄만 안 보였다.
+   */
+  const 전선 = session.conn?.전선;
+  if (전선) {
+    const 배운칸 = 전선.배운칸 ?? [];
+    say(`  ${c.bold('이 창구에 실어 보내는 모양')}`);
+    say(`    ${c.gray(전선말(전선))}`);
+    if (배운칸.length) {
+      say(`    ${c.gray('「배움」 은 짐작이 아니라 서버가 거절해서 고친 자리입니다 — 틀릴 수도 있습니다.')}`);
+    }
+    say('');
+  }
+
   say('');
   say(`  ${c.gray('지우려면')} ${c.cyan('/learned 지우기')}`);
+  if (전선?.배운칸?.length) {
+    say(`  ${c.gray('전선에서 배운 것만 되돌리려면')} ${c.cyan('/learned 전선 지우기')}`);
+  }
   say('');
 }
 
@@ -2792,7 +2953,7 @@ function 모델급(session, arg = '') {
     return;
   }
 
-  if (값 && 별명[값]) {
+  if (값 && Object.hasOwn(별명, 값)) {
     session.급정한것 = 별명[값];
     session.급다시재기?.();
     const v = session.급값();
@@ -2803,6 +2964,19 @@ function 모델급(session, arg = '') {
     return;
   }
 
+  /*
+   * 못 알아들은 값은 **못 알아들었다고 말한다.**
+   *
+   * 앞서는 `/grade 크게` 같은 오타가 오류 한 줄 없이 지금 상태 표로
+   * 떨어졌다. 사람은 정해진 줄로 읽고 그대로 쓴다. 바로 옆 `/work` 는
+   * 「그런 모드는 없습니다」 를 먼저 말한다 — 잣대를 같게 맞춘다.
+   */
+  if (값) {
+    say('');
+    say(`  ${mark.no} ${c.gray('그런 급은 없습니다:')} ${c.white(값)}`);
+    say(`  ${c.gray('고를 수 있는 것:')} ${c.cyan('작음')} ${c.gray('·')} ${c.cyan('보통')} ${c.gray('·')} ${c.cyan('큼')} ${c.gray('·')} ${c.cyan('auto')}`);
+  }
+
   // 인자가 없으면 지금 상태를 보여 준다.
   const g = session.급();
   const v = session.급값();
@@ -3209,8 +3383,17 @@ async function 모델만바꾸기(session, cfg, 모델, ctx = null) {
   // 서버는 그대로지만 문은 같이 지난다. 등록 안 된 서버로 옮겨 가는 길도
   // 여기라서, 여기를 열어 두면 자물쇠에 구멍이 하나 남는다.
   if (!await 나가도되나묻기(session, p)) return;
-  if (!이미) 설정남기기(upsert(cfg, p));
-  else { cfg.active = p.id; 설정남기기(cfg); }
+  /*
+   * 새로 만든 프로필도 **지금 쓰는 것**으로 못 박는다.
+   *
+   * upsert 는 active 가 비어 있을 때만 채운다. 여기서는 이미 차 있으므로,
+   * 새 프로필을 넣기만 하고 active 는 옛 모델에 그대로 남았다 — 화면에는
+   * 「모델을 X 로 바꿨습니다」 라고 적히고, 다음에 켜면 옛 모델로 돌아온다.
+   * 이미 있는 프로필로 갈아탈 때(아래 갈래)는 제대로 하고 있었다.
+   */
+  if (!이미) upsert(cfg, p);
+  cfg.active = p.id;
+  설정남기기(cfg);
   연결적용(session, p, ctx);
   say(`  ${mark.ok} 모델을 ${c.bold(모델)} 로 바꿨습니다. ${c.gray('서버는 그대로입니다.')}`);
   await 길이맞추기(session, cfg, p);

package/src/i18n/en.js

@@ -42,6 +42,7 @@ export const en = {
   // ── /think screen ──────────────────────────────────────────────────
   'run.noTools': 'Tool calling is unconfirmed — check with deel diagnose',
   'think.effort': 'Effort',
+  'think.unknown': 'No such effort level: {값}',
   'think.profile': 'Profile',
   'think.detail': 'detail',
   'think.harder': 'harder',
@@ -98,7 +99,7 @@ export const en = {
   'cmd.commit.desc': 'commit — stages only what this session changed; message from the diff and the evidence',
   'cmd.review.desc': 'review the changes in a fresh context — reports findings only, changes nothing',
   'cmd.paste.desc': 'attach the screenshot sitting in the clipboard (capture, then /paste)',
-  'cmd.commit.arg': '[all|preview|title]',
+  'cmd.commit.arg': '[all] [title|preview]',
   'cmd.sessions.desc': 'past sessions in this folder',
   'cmd.recall.desc': 'search past sessions — by what was said, not by title',
   'cmd.recall.arg': '<text>',
@@ -542,6 +543,7 @@ export const en = {
   'wire.cacheMarked': 'marked',
   'wire.cacheKey': 'key',
   'wire.cacheAuto': 'server-side',
+  'wire.learned': 'learned',
   'cost.cache': 'Cache',
   'cost.think': 'Thinking',
   'cost.thinkLine': '{토큰} tokens · {몫}% of output',

package/src/i18n/ko.js

@@ -31,6 +31,7 @@ export const ko = {
   // 단계 이름·배분 이름은 agent/effort.js 가 들고 있다 — modes.js 와 같은 방식.
   'run.noTools': '도구 호출이 확인되지 않았습니다 — deel diagnose 로 점검하세요',
   'think.effort': '추론 강도',
+  'think.unknown': '그런 강도는 없습니다: {값}',
   'think.profile': '배분',
   'think.detail': '자세히',
   'think.harder': '더 세게',
@@ -87,7 +88,7 @@ export const ko = {
   'cmd.commit.desc': '커밋 — 이번 대화가 바꾼 것만 담고, diff 와 증거로 메시지를 짓는다',
   'cmd.review.desc': '바꾼 것을 새 창에서 한 번 더 본다 — 찾은 것만 말하고 아무것도 안 고친다',
   'cmd.paste.desc': '클립보드에 든 화면 캡처를 붙인다 (캡처 → /paste)',
-  'cmd.commit.arg': '[전부|미리보기|제목]',
+  'cmd.commit.arg': '[전부] [제목|미리보기]',
   'cmd.sessions.desc': '이 폴더의 지난 대화 목록',
   'cmd.recall.desc': '지난 대화에서 찾기 — 목록 말고 내용으로',
   'cmd.recall.arg': '<찾을 말>',
@@ -589,6 +590,7 @@ export const ko = {
   'wire.cacheMarked': '표식',
   'wire.cacheKey': '열쇠',
   'wire.cacheAuto': '서버자동',
+  'wire.learned': '배움',
   'cost.cache': '캐시',
   'cost.think': '생각',
   'cost.thinkLine': '{토큰} 토큰 · 답의 {몫}%',

package/src/repl.js

@@ -1188,6 +1188,16 @@ export async function chatLoop(opts = {}) {
     loadedSkills: new Set(),
     // 고친 뒤 진단을 볼지. /lsp off 로 끈다 (lsp/diag.js).
     lsp: { 켬: true },
+    /*
+     * 종을 울릴지. `/bell on|off` 가 **이 그릇**을 고친다.
+     *
+     * 앞서는 명령이 설정 파일만 고쳤다. 울릴지 말지는 켤 때 한 번 읽어
+     * 둔 값(알림.켬)이 정하므로, `/bell off` 를 쳐도 그 세션 내내 계속
+     * 울렸다 — 화면은 「이 세션에도 바로 먹습니다」 라고 적으면서.
+     * `/bell on` 은 더 나빴다: 그 자리에서 한 번 울려 켜졌다는 증거까지
+     * 보여 준 다음, 다음 턴부터 안 울렸다.
+     */
+    종알림: 알림,
     ask,
     // 암호는 여기서만 받는다. 받은 값은 도구가 쓰고 버린다 —
     // 설정에도, 세션 기록에도, 감사기록에도, 명령줄에도 안 남는다.
@@ -2279,8 +2289,9 @@ export async function chatLoop(opts = {}) {
 
           case 'images_folded': {
             clearThinking();
-            const 장수 = (ev.뺀것들 ?? []).reduce((a2, x) => a2 + x.장수, 0);
-            say(`  ${c.cyan('◲')} ${c.gray(`오래된 그림 ${장수}장을 뺐습니다 — 사람이 쓴 말은 그대로입니다.`)}`);
+            // 장수는 접는 쪽이 세어 준다 (agent/compact.js 의 foldImages).
+            // 여기서 또 세면 한쪽만 고쳐지고, 그때부터 화면이 다른 수를 적는다.
+            say(`  ${c.cyan('◲')} ${c.gray(`오래된 그림 ${ev.뺀것}장을 뺐습니다 — 사람이 쓴 말은 그대로입니다.`)}`);
             break;
           }
 

package/src/tools/jobs.js

@@ -384,6 +384,35 @@ class 일감 {
     while (this.바이트 > 출력상한 && this.조각들.length > 1) {
       this.바이트 -= this.조각들.shift().length;
     }
+    /*
+     * 한 조각이 **혼자** 상한을 넘으면 그 조각의 뒤만 남긴다.
+     *
+     * 위 되풀이는 조각이 둘 이상일 때만 버린다. 그래서 한 조각이 혼자 넘치면
+     * **아무것도 못 버리는데 아래에서 잘렸다고 적는다.** 그 사이에 읽으면
+     * 멀쩡한 글에 "앞이 잘렸습니다" 가 붙고 읽은 자리도 0 으로 돌아간다 —
+     * 모델은 없는 앞을 찾으러 처음부터 다시 읽는다. (다음 조각이 들어오면
+     * 그때는 둘이 되어 버려지므로, 거짓말은 그 한 판만이다. 그래도 그 한
+     * 판이 되풀이를 부르는 자리다 — 읽기() 머리말 참고.)
+     *
+     * 그리고 버릴 수 있게 만들어 두는 것이 맞다. 상한 위에 남겨 두면 그
+     * 다음 조각 하나에 256KB 가 통째로 날아간다.
+     *
+     * 베껴 담는다. subarray 는 원래 덩이를 그대로 붙잡고 있어서, 큰 조각
+     * 하나가 들어온 판에서는 놓으려는 그 메모리가 안 놓인다.
+     */
+    if (this.바이트 > 출력상한 && this.조각들.length === 1) {
+      const 하나 = this.조각들[0];
+      this.조각들[0] = Buffer.from(하나.subarray(하나.length - 출력상한));
+      this.바이트 = this.조각들[0].length;
+    }
+    /*
+     * 여기 오면 **반드시 무엇인가 버렸다** — 그래서 「안 버렸으면」 갈래를
+     * 두지 않는다. 위에서 상한을 넘은 것을 확인했고, 조각이 둘 이상이면
+     * 되풀이가 버리고 하나뿐이면 그 하나를 줄였다. 늘 참인 조건을 남기면
+     * 어긋내기가 「그 줄을 지워도 아무 검사도 안 깨진다」 고 말하는데, 그건
+     * 맞는 말이라 고칠 수도 없다 — 대신 읽는 사람은 안 버리는 길이 따로
+     * 있는 줄로 읽는다.
+     */
     this.앞잘림 = true;
     this.막버렸다 = true;
     this.읽은글자 = 0;
@@ -516,10 +545,24 @@ export async function 띄우기(명령, { cwd, 설명 = null, 기다림 = 1500,
 
   kid.stdout?.on('data', (b) => j.담기(b));
   kid.stderr?.on('data', (b) => j.담기(b));
-  kid.on('error', (err) => { j.담기(Buffer.from(`\n[띄우기 실패: ${err.message}]\n`)); j.상태 = '끝남'; j.종료코드 = -1; });
+  kid.on('error', (err) => {
+    j.담기(Buffer.from(`\n[띄우기 실패: ${err.message}]\n`));
+    j.상태 = '끝남';
+    j.종료코드 = -1;
+    // 왜 표를 세우나 — 바로 아래 close 머리말.
+    j.띄우기실패 = true;
+  });
   kid.on('close', (code, sig) => {
     if (j.상태 === '죽임') return;
     j.상태 = '끝남';
+    /*
+     * 띄우기 자체가 실패한 판은 **덮지 않는다.**
+     *
+     * 명령이 없으면(ENOENT) Node 는 error 를 낸 다음 close 를 code=null 로
+     * 부른다. 그러면 위에서 세워 둔 -1 이 null 로 덮이고, null 은 이 자리에서
+     * 「시그널로 죽었다」 와 구별이 안 된다. 안 뜬 까닭이 종료코드에서 지워진다.
+     */
+    if (j.띄우기실패) { 끝난것치우기(); return; }
     j.종료코드 = sig ? null : code;
     j.시그널 = sig ?? null;
     // 끝난 것이 쌓이지 않게. 도는 것은 최대일감 이 따로 막는다.
@@ -628,7 +671,17 @@ export async function 끝내기(번호) {
      */
     await 죽는말기다리기(j.kid, 죽는말기다림);
   }
-  파이프끊기(j.kid);
+  /*
+   * ── 안 죽은 놈의 파이프는 **끊지 않는다** ──────────────────────────────
+   *
+   * 여기서 늘 끊고 있었다. 그런데 바로 아래에서 「그러고도 안 죽었으면 목록에
+   * 남긴다 — 다시 시킬 수 있어야 한다」 고 한다. 파이프를 이미 끊어 놓고
+   * 남기면, 목록에는 `도는중` 으로 뜨는데 그놈이 뱉는 말은 다시는 안 들어온다.
+   * 사람은 화면을 보며 기다리고, 자식은 다음 쓰기에서 EPIPE 를 맞는다.
+   * 남겨 두기로 한 까닭이 「다시 볼 수 있게」 인데 정작 볼 길을 끊던 셈이다.
+   */
+  const 죽었나 = !아직사나(j.kid);
+  if (죽었나) 파이프끊기(j.kid);
   const 남은 = j.읽기({});
   /*
    * ★ 그러고도 안 죽었으면 **그렇다고 말한다.**
@@ -640,7 +693,7 @@ export async function 끝내기(번호) {
    *
    * 안 죽었으면 목록에 남긴다. 그래야 사람이 한 번 더 시킬 수 있다.
    */
-  if (아직사나(j.kid)) {
+  if (!죽었나) {
     j.상태 = '도는중';   // 지우지 않는다 — 다시 시킬 수 있어야 한다
     return { 이미: false, 안죽음: true, 명령: j.명령, 초: j.산햇수(), 남은: 남은.글 };
   }
@@ -723,6 +776,8 @@ export function 일감인자(args) {
   };
   const 날번호 = 하나씩('번호');
   return {
+    // 날것을 같이 내놓는다 — 숫자가 아닐 때 **무엇을 받았는지** 적어야 한다.
+    날번호,
     번호: 날번호 == null ? null : Number(날번호),
     끝내기: !!하나씩('끝내기'),
     처음부터: !!하나씩('처음부터'),
@@ -791,11 +846,34 @@ export const JOBS_TOOL = {
           + ' 번호 없이 부르면 목록입니다.',
       };
     }
+    /*
+     * 몇 개만 못 알아들은 판도 **말해 준다.**
+     *
+     * 위 갈래는 「하나도」 못 알아들었을 때만 걸린다. 그래서
+     * `{job: 1, action: 'stop'}` 은 걸리지 않고 — `action` 을 조용히 버린 뒤
+     * 출력만 읽어 **성공으로** 돌려줬다. 끄라고 시킨 모델은 껐다고 여기고
+     * 넘어가는데 서버는 그대로 돈다. 위 머리말이 없애겠다고 적어 둔 바로 그
+     * 고장이, 인자를 하나 더 붙인 판에 그대로 남아 있었다 (34차 리뷰).
+     *
+     * 오류로 막지는 않는다 — 알아들은 것은 하라고 시킨 것이 맞다. 대신 버린
+     * 이름을 적어 보내서, 뜻이 거기 있었으면 다음 걸음에서 고쳐 부르게 한다.
+     */
+    const 버린말 = 받은것.모르는것.length
+      ? `\n(못 알아들어 버린 인자: ${받은것.모르는것.join(', ')} — Jobs 는 job · stop · from_start 만 받습니다.`
+        + ' 끝내려던 것이면 stop: true 로 다시 불러라.)'
+      : '';
     const 번호 = 받은것.번호;
     // 숫자가 아닌 것을 받으면 NaN 이 되고, 그대로 두면 `NaN번 일감이 없습니다`
     // 라는 말이 모델에게 나간다. 무엇이 잘못됐는지 안 알려 주는 오류다.
     if (번호 != null && !Number.isFinite(번호)) {
-      return { error: `번호는 숫자여야 합니다 (받은 것: ${JSON.stringify(args?.번호)}). 번호 없이 Jobs 를 불러 목록을 보세요.` };
+      /*
+       * 받은 것을 **실제로 읽은 그 칸**에서 적는다.
+       *
+       * 여기가 `args?.번호` 였다. 설명서에 실린 이름은 `job` 이라 모델은 거의
+       * 늘 `job` 으로 보내는데, 그러면 이 말은 `(받은 것: undefined)` 가 된다.
+       * 무엇을 잘못 보냈는지 알려 주려고 있는 줄이 정작 그것만 안 알려 줬다.
+       */
+      return { error: `번호는 숫자여야 합니다 (받은 것: ${JSON.stringify(받은것.날번호)}). 번호 없이 Jobs 를 불러 목록을 보세요.` };
     }
 
     if (번호 == null) {
@@ -830,7 +908,7 @@ export const JOBS_TOOL = {
        * 그러면 포트가 물려서 안 뜨고, 왜 안 되는지도 모른다.
        */
       if (치운것) 줄들.push(`  (오래된 것 ${치운것}개는 자리를 위해 지웠습니다)`);
-      return { content: 줄들.join('\n'), summary: 세말('count', ls.length), 일감수: ls.length };
+      return { content: 줄들.join('\n') + 버린말, summary: 세말('count', ls.length), 일감수: ls.length };
     }
 
     if (받은것.끝내기) {
@@ -854,7 +932,7 @@ export const JOBS_TOOL = {
       }
       return {
         content: `${번호}번을 끝냈습니다 (${r.초}초 돌았습니다): ${r.명령}`
-          + (r.남은 ? `\n\n마지막 출력:\n${뒤만(r.남은, 2000).글}` : ''),
+          + (r.남은 ? `\n\n마지막 출력:\n${뒤만(r.남은, 2000).글}` : '') + 버린말,
         summary: 이어(말('sum.jobStopped'), 말('unit.sec', { n: r.초 })),
       };
     }
@@ -870,7 +948,7 @@ export const JOBS_TOOL = {
       ? (r.앞잘림 ? '(앞부분은 너무 길어 잘렸습니다 — 뒤쪽만 남았습니다)\n' : '') + 잘라낸.글
       : '(지난번 읽은 뒤로 새 출력이 없습니다)';
     return {
-      content: `${머리}\n\n${몸}`,
+      content: `${머리}\n\n${몸}${버린말}`,
       summary: (r.상태 === '도는중' ? 이어(말('sum.jobRunning'), 말('unit.sec', { n: r.초 })) : 끝난말(r))
         + (잘라낸.줄임 ? ' · 일부만' : ''),
       // 끝난 일감이 종료코드 0 이 아니면 실패로 물들인다 — Bash 와 같은 규칙이다.