deel-local-cli 1.1.1 → 1.4.0

package/src/repl.js

@@ -1,23 +1,33 @@
 // 대화 화면. 루프가 보내는 이벤트를 Claude Code 풍으로 그린다.
 import { createInterface, emitKeypressEvents } from 'node:readline';
 import { homedir } from 'node:os';
-import { resolve } from 'node:path';
+import { resolve, basename } from 'node:path';
 import { c, say as 바로쓰기, mark, clip } from './ui/ansi.js';
 import { headerLines } from './ui/status.js';
+import { 종, 창제목, 제목되돌리기, 알릴까, 제목글 } from './ui/notify.js';
+import { 보이기 as 인트로, 기본곁말 } from './ui/intro.js';
+import { 언어잡기 } from './i18n/index.js';
 import { 화면고르기 } from './ui/screen.js';
 import { STAGES } from './agent/effort.js';
 import { handle, COMMANDS, 미리보기끄기 } from './commands.js';
-import { next as nextWork, get as getWork, canWrite } from './agent/modes.js';
+import { next as nextWork, get as getWork, canWrite, 보일이름, 보일한줄 } from './agent/modes.js';
 import { route } from './agent/route.js';
 import { run } from './agent/loop.js';
-import { Session } from './agent/session.js';
+import { Session, repairToolPairs } from './agent/session.js';
 import { makeScope } from './safety/guard.js';
+import { 언어서버있나 } from './tools/index.js';
+import { 모두끄기 as 언어서버다끄기 } from './lsp/client.js';
 import { History } from './safety/undo.js';
 import { Audit } from './safety/audit.js';
-import { activeProfile, load, resolveKey, save as saveCfg } from './config.js';
+import { activeProfile, load, resolveKey, save as saveCfg, homeDir } from './config.js';
 import { discover } from './skills/discover.js';
 import { allowEndpoint, setOffline, isOffline, isLocalHost } from './safety/network.js';
 import { Store, latest, prune } from './agent/store.js';
+import { Threads } from './agent/threads.js';
+import { 못박기 } from './agent/pins.js';
+import { 카드 } from './agent/card.js';
+import { 배움 } from './agent/evolve.js';
+import { 마크다운 } from './ui/md.js';
 import { askHidden } from './ui/prompt.js';
 import { explain, shows as levelShows } from './ui/level.js';
 import { 고르기 as 승인고르기, 다음 as 승인다음 } from './ui/approve.js';
@@ -27,7 +37,7 @@ import { probeCtx, 기본값 as CTX_DEFAULT } from './backend/ctxsize.js';
 import { renderDiff, shortStat } from './ui/diff.js';
 import { expand as expandMentions } from './agent/mention.js';
 import { 다붙이기 } from './backend/mcp.js';
-import { 프롬프트토막 as 기억토막, 읽기 as 기억읽기 } from './agent/memory.js';
+import { 읽기 as 기억읽기 } from './agent/memory.js';
 import { 갈래고르기 } from './ui/working.js';
 import { 모두끝내기 as 일감모두끝내기, 일감인자 } from './tools/jobs.js';
 
@@ -157,6 +167,27 @@ export async function chatLoop(opts = {}) {
   allowEndpoint(conn.base);
   if (opts.offline ?? prof.offline) setOffline(true);
 
+  /*
+   * ── 끝났을 때 알리기 ─────────────────────────────────────────────────
+   *
+   * 로컬 모델은 느리다. 7B 를 CPU 로 돌리면 한 턴에 2~3분이 예사고, 그동안
+   * 사람은 다른 창으로 간다. 돌아와 보면 5분 전에 끝나 있거나, 더 나쁘게는
+   * "실행할까요?" 에서 3분째 멈춰 서 있다 — 물어본 줄을 몰라서.
+   *
+   * 폴더 이름을 같이 들고 있는다. 창을 여럿 띄워 놓고 쓰는 사람이 많은데
+   * 전부 'deel' 이면 어느 탭이 끝난 건지 알 수가 없다. (ui/notify.js)
+   */
+  const 알림 = { 켬: cfg.bell !== false, 폴더: basename(root) };
+
+  /*
+   * 화면 말을 여기서 한 번 정한다.
+   *
+   * 켤 때 딱 한 번이면 된다 — 그 뒤로는 /lang 이 바꾼다. 환경변수가 설정을
+   * 이긴다. 한 번만 영어로 켜 보려는 사람이 설정을 건드리지 않고
+   * `DEEL_LANG=en deel` 로 할 수 있어야 하기 때문이다. (i18n/index.js)
+   */
+  언어잡기({ cfg });
+
   const session = new Session(conn, {
     root,
     mode: opts.mode ?? 'auto',
@@ -179,11 +210,30 @@ export async function chatLoop(opts = {}) {
       say(`  ${c.gray('이어할 대화가 없습니다. 새로 시작합니다.')}`);
     } else {
       store = new Store(root, target);
-      const { messages } = store.load();
+      const { messages: 적힌것 } = store.load();
+      /*
+       * 도구가 도는 중에 죽었으면 호출만 적히고 결과가 없다. 그대로 보내면
+       * 규격 서버가 400 을 내서 이어받자마자 첫 마디에서 죽는다. 손봐서 받는다.
+       */
+      const { messages, 고친것 } = repairToolPairs(적힌것);
       if (messages.length) {
         session.messages = messages;
         say('');
         say(`  ${mark.ok} ${c.bold(target)} ${c.gray(`— 메시지 ${messages.length}개를 이어 받았습니다.`)}`);
+        if (고친것) {
+          say(`  ${c.gray(`중단된 도구 호출 ${고친것}개를 걷어냈습니다 — 그때 하던 일은 다시 시켜 주세요.`)}`);
+        }
+      }
+      /*
+       * 못 박아 둔 것도 같이 되살린다 (agent/pins.js).
+       *
+       * 이걸 안 되살리면 '접어도 요약해도 안 지워진다' 가 **껐다 켜는 한 번에**
+       * 거짓이 된다. 사람은 이미 말했다고 믿고 있으니 다시 말하지 않는다.
+       */
+      const 박힌것 = store.못박은것읽기();
+      if (박힌것.length) {
+        session.못박은것 = new 못박기(박힌것);
+        say(`  ${c.gray(`못 박아 둔 것 ${session.못박은것.개수()}개도 그대로 이어 받았습니다 —`)} ${c.cyan('/pin')}`);
       }
     }
   }
@@ -211,6 +261,14 @@ export async function chatLoop(opts = {}) {
   // 세션도 알아야 한다 — 밖에서 붙인 도구도 스키마가 매 요청에 실린다.
   // 안 세면 컨텍스트가 그만큼 조용히 줄어든다.
   session.mcp = mcp붙임.서버들;
+  /*
+   * 이 자리에 언어 서버가 깔려 있나 (Def·Refs 를 목록에 넣을지).
+   *
+   * 여기서 한 번만 잰다. PATH 훑기와 폴더 훑기라 값이 있고, 세션 도중에
+   * 답이 바뀌지 않는다. 아무것도 안 깔아 준다 — 있으면 쓰고 없으면 없는 대로
+   * Grep·Outline 으로 간다 (lsp/servers.js 머리말).
+   */
+  session.lsp = 언어서버있나(root);
   // 지난 대화에서 정해 둔 것을 들고 시작한다.
   // 기억은 Session 이 켤 때 직접 읽는다 (session.js 생성자) — deel run 도 같은 것을 들고 시작하게.
 
@@ -346,7 +404,7 @@ export async function chatLoop(opts = {}) {
         session.work = nextWork(session.work);
         const w = getWork(session.work);
         화면.입력지움();
-        say(`  ${c.hcyan(w.glyph)} ${c.bold(w.name)} ${c.gray('(' + w.en + ')')}  ${c.gray(w.hint)}`
+        say(`  ${c.hcyan(w.glyph)} ${c.bold(보일이름(w.id))} ${c.gray('(' + w.en + ')')}  ${c.gray(보일한줄(w.id))}`
           + (canWrite(session.work) ? '' : `  ${c.green('· 파일을 못 바꿉니다')}`));
         prompt();
         return;
@@ -490,6 +548,8 @@ export async function chatLoop(opts = {}) {
     mcp: mcp붙임.서버들,
     skills: found.skills,
     loadedSkills: new Set(),
+    // 고친 뒤 진단을 볼지. /lsp off 로 끈다 (lsp/diag.js).
+    lsp: { 켬: true },
     ask,
     // 암호는 여기서만 받는다. 받은 값은 도구가 쓰고 버린다 —
     // 설정에도, 세션 기록에도, 감사기록에도, 명령줄에도 안 남는다.
@@ -501,11 +561,55 @@ export async function chatLoop(opts = {}) {
     confirm: async (name, args) => {
       say('');
       say(`  ${c.yellow('?')} ${toolLabel(name, args)}`);
+      /*
+       * 여기서 종을 울린다. 끝난 것은 늦게 알아도 되지만 **막혀 있는 것은**
+       * 기다린 만큼 그대로 손해다 — 다른 창에 가 있는 사이 3분째 이 줄에서
+       * 멈춰 서 있는 일이 실제로 잦다. 시간 문턱도 안 본다, 0초여도 알린다.
+       */
+      if (알릴까({ 물어봄: true, 켬: 알림.켬 })) 종();
+      창제목(제목글('물어봄', { 폴더: 알림.폴더 }));
       const a = (await ask('실행할까요? (y/n)', { def: 'y' })).toLowerCase();
+      창제목(제목글('도는중', { 폴더: 알림.폴더 }));
       return a === 'y' || a === 'yes' || a === 'ㅇ';
     },
   };
 
+  /*
+   * 겪어 본 것 (agent/evolve.js). 쓸수록 이 PC 에 맞춰 나아지는 자리다.
+   *
+   * 켤 때 두 가지를 받아 온다.
+   *   · 프롬프트에 실을 몇 줄 — 여기서 되는 명령, 이 모델의 버릇
+   *   · 지난번에 알아낸 토큰 배수 — 첫 턴부터 제대로 셈한다
+   *
+   * 둘 다 없으면 아무 일도 안 일어난다. 처음 켠 PC 는 지금과 똑같이 돈다.
+   */
+  ctx.배움 = new 배움(root, homeDir());
+  session.배움요약 = ctx.배움.요약(conn.model);
+  const 아는배수 = ctx.배움.아는보정(conn.model);
+  if (아는배수) { session.보정 = 아는배수; session.보정잰것 = 1; }
+
+  /*
+   * 모델 카드 (agent/card.js).
+   *
+   * 겪어 본 버릇을 **하네스 설정으로** 바꾼다. 프롬프트에 "이렇게 해라" 고 적는
+   * 것과 다르다 — 작은 모델은 그 말을 잘 안 듣는다. 여기서 바꾸는 것은 deel 의
+   * 행동이라 모델의 협조가 필요 없다.
+   *
+   * 턴마다 다시 만든다. 이번 대화에서 겪는 것이 계속 쌓이므로, 켤 때 한 번
+   * 만들어 두면 그 뒤에 알아낸 것이 이번 대화에서는 안 쓰인다.
+   */
+  ctx.카드다시 = () => {
+    ctx.카드 = 카드(conn.model, session.본것, ctx.배움?.현황(conn.model)?.모델);
+    return ctx.카드;
+  };
+  ctx.카드다시();
+
+  /*
+   * 대화 갈래. 연결·도구·되돌리기는 같이 쓰고 오간 말만 여러 벌 갖는다.
+   * 갈래마다 저장 파일을 따로 열어서, 나중에 `/sessions` 로 각각 찾아갈 수 있다.
+   */
+  ctx.갈래 = new Threads(session, ctx, () => new Store(root).begin({ model: conn.model, base: conn.base, root }), store);
+
   // ── 컨텍스트 길이를 모델에서 긁어온다 ─────────────────────────────────
   //
   // 켤 때마다 서버에 물어본다. 저장된 값을 그대로 믿지 않는다 —
@@ -554,6 +658,26 @@ export async function chatLoop(opts = {}) {
     }
   }
 
+  /*
+   * ── 켤 때 도는 글자 모션 ──────────────────────────────────────────────
+   *
+   * 사람은 `deel` 이라고 치고 들어온다. 그 글자가 그 자리에서 deel-local 로
+   * 자라고, 아래로 선이 그어지며 닫힌다. 꾸미기만은 아니다 — 이 프로그램이
+   * 하는 말이 딱 하나인데(소스가 이 컴퓨터 밖으로 안 나간다) 그 말을 켜는
+   * 첫 1초에 그림으로 한 번 하는 것이다. 바깥 게이트웨이면 같은 선이 노랗게
+   * 그어진다. 그러면 사람이 그 자리에서 안다.
+   *
+   * 여기서 도는 이유는 **연결이 정해진 다음**이라야 색을 제대로 칠하기
+   * 때문이다. 더 일찍 돌면 초록으로 그려 놓고 나중에 바깥이었다고 정정하는
+   * 꼴이 되는데, 그건 안 보여 주느니만 못하다.
+   */
+  {
+    let 바깥 = false;
+    try { 바깥 = !isLocalHost(new URL(conn.base).hostname); } catch { 바깥 = false; }
+    say('');
+    await 인트로({ 바깥, 곁말: 기본곁말(바깥), 쓰기: (t) => process.stdout.write(t) });
+  }
+
   // ── 머리말 ────────────────────────────────────────────────────────────
   화면.머리말(headerLines(session, found));
   const warn = [];
@@ -729,7 +853,7 @@ export async function chatLoop(opts = {}) {
         계획승인받나 = 골라진.겹침 === true;
         const w = getWork(골라진.mode);
         say('');
-        say(`  ${c.hcyan(w.glyph)} ${c.bold(w.name)} ${c.gray('(' + w.en + ')')}`
+        say(`  ${c.hcyan(w.glyph)} ${c.bold(보일이름(w.id))} ${c.gray('(' + w.en + ')')}`
           + `  ${c.gray('말 속에 ' + 골라진.why + ' 가 있어서')}`
           + (canWrite(골라진.mode) ? '' : `  ${c.green('· 파일은 안 바꿉니다')}`));
         // 겹친 요청은 '파일을 안 바꾼다' 로 끝나면 안 된다. 시킨 일의 절반만 한 것이다.
@@ -747,10 +871,24 @@ export async function chatLoop(opts = {}) {
     const started = Date.now();
     const before = { in: session.usage.in, out: session.usage.out };
 
+    /*
+     * 창 제목에 흐른 시간을 띄운다. 탭 이름만 봐도 도는 중인지 알게 하려는 것이다.
+     *
+     * 화면에 보이는 글자를 건드리지 않는다 — OSC 는 커서를 안 옮기고 아무것도
+     * 안 찍으므로, 한창 그리는 중에 끼어들어도 화면이 깨지지 않는다.
+     * unref 를 거는 이유는, 이 시계 하나 때문에 프로그램이 안 꺼지면 안 되기 때문이다.
+     */
+    창제목(제목글('도는중', { 폴더: 알림.폴더, 초: 0 }));
+    const 제목시계 = setInterval(
+      () => 창제목(제목글('도는중', { 폴더: 알림.폴더, 초: (Date.now() - started) / 1000 })),
+      1000,
+    );
+    제목시계.unref?.();
+
     // 어디까지 적었는지. 도중에 죽어도 여기까지는 남아 있게 자주 흘려 보낸다.
     let saved = session.messages.length;
     const flush = () => {
-      for (const m of session.messages.slice(saved)) store.append(m);
+      for (const m of session.messages.slice(saved)) ctx.갈래.현재store().append(m);
       saved = session.messages.length;
     };
     let tools = 0;
@@ -759,6 +897,18 @@ export async function chatLoop(opts = {}) {
     let 턴탈났나 = false;
     let thinkChars = 0;
     let streamed = false;
+    /*
+     * 답을 그리는 자리. 턴마다 새로 만든다 — 앞 턴의 코드 울타리 상태가
+     * 다음 턴으로 새면 멀쩡한 답이 통째로 코드 블록으로 그려진다.
+     */
+    const 답그림 = new 마크다운({ 폭: (process.stdout.columns || 80) - 6 });
+    // 답 흐름이 끊기는 자리마다 남은 반 줄을 비운다. 안 비우면 마지막 줄이 사라진다.
+    const 답비우기 = () => {
+      for (const 조각 of 답그림.끝()) {
+        if (typeof 조각 === 'string') 화면.붙임(`  ${답표시} ${조각}\n`);
+        else 화면.붙임(조각.이어붙임 + (조각.끝났나 ? '\n' : ''));
+      }
+    };
     let thinkingShown = false;
     let stage = null;
     // 접는 중 표시. 끝나거나 다른 글을 찍기 전에 반드시 멈춰야 한다.
@@ -779,6 +929,9 @@ export async function chatLoop(opts = {}) {
      * 그렇게 날아간다. 테두리를 그대로 두고 안엣것만 바꾸는 이유다.
      */
     화면.일시작(session, '생각');
+    // 이번 턴에 쓸 카드를 지금 만든다. 앞 턴에서 겪은 것까지 반영돼야
+    // '겪을수록 나아진다' 가 이번 대화 안에서도 참이 된다.
+    ctx.카드다시?.();
     try {
       for await (const ev of run(session, ctx, 보낼글, { signal: turn.signal })) {
         /*
@@ -830,15 +983,28 @@ export async function chatLoop(opts = {}) {
            * 세로줄 하나면 된다. 칸을 나눠 그리는 화면으로 갈 이유가 없다 —
            * 파이프로 넘기거나 기록으로 남길 때도 그대로 읽힌다.
            */
+          /*
+           * 답을 마크다운으로 그린다 (ui/md.js).
+           *
+           * 줄이 끝나야 그릴 수 있다 — `**굵` 까지 왔을 때는 그게 굵은 글씨가
+           * 될지 알 수 없고, 한 번 찍은 글자는 되돌릴 수 없다. 그래서 md 가
+           * 줄 단위로 모았다가 내놓는다. 줄이 화면 폭보다 길어지면 거기까지를
+           * 날것으로 흘려보낸다(md 가 알아서 한다) — 긴 문단에서 몇 초씩
+           * 아무것도 안 나오면 멈춘 것처럼 보이기 때문이다.
+           */
           case 'content':
             clearThinking();
-            if (!streamed) { streamed = true; 화면.일바꿈('답'); 화면.붙임(`  ${답표시} `); }
-            화면.붙임(ev.text.replace(/\n/g, `\n  ${답표시} `));
+            if (!streamed) { streamed = true; 화면.일바꿈('답'); }
+            for (const 조각 of 답그림.넣기(ev.text)) {
+              if (typeof 조각 === 'string') { 화면.붙임(`  ${답표시} ${조각}\n`); continue; }
+              // 아직 안 끝난 긴 줄. 그 줄이 처음 나가는 것이면 세로줄을 앞에 세운다.
+              화면.붙임((조각.첫조각 ? `  ${답표시} ` : '') + 조각.이어붙임 + (조각.끝났나 ? '\n' : ''));
+            }
             break;
 
           case 'tool_start':
             clearThinking();
-            if (streamed) { say(''); streamed = false; }
+            if (streamed) { 답비우기(); say(''); streamed = false; }
             // 문구를 지금 하는 일에 맞춘다. 아무 말이나 돌려 대면 두 번째부터
             // 아무도 안 읽고, 그때부터는 화면이 조용한 것과 같아진다.
             화면.일바꿈(갈래고르기(ev.name));
@@ -849,7 +1015,7 @@ export async function chatLoop(opts = {}) {
           // 여럿을 같이 돌린다 — 한 줄로 알리고, 이름은 결과와 붙여서 그린다.
           case 'tools_start':
             clearThinking();
-            if (streamed) { say(''); streamed = false; }
+            if (streamed) { 답비우기(); say(''); streamed = false; }
             화면.일바꿈(갈래고르기(ev.names?.[0]));
             say('');
             say(`  ${c.gray(`${ev.count}개를 함께 돌립니다`)} ${c.gray('·')} ${c.gray(ev.names.join(' '))}`);
@@ -861,7 +1027,7 @@ export async function chatLoop(opts = {}) {
             // '시작' 을 안 거쳤다. 그래서 '생각 중…' 줄이 안 지워진 채로 결과가
             // 그 줄 뒤에 가서 붙고, 이름도 없이 "└ 인자가 잘렸습니다" 만 남는다.
             // 무슨 도구가 왜 그랬는지 알 수 없는 화면이 된다.
-            if (ev.showLabel) { clearThinking(); if (streamed) { say(''); streamed = false; } say(''); }
+            if (ev.showLabel) { clearThinking(); if (streamed) { 답비우기(); say(''); streamed = false; } say(''); }
             // 같이 돈 것은 이름을 다시 적어 준다. 안 그러면 어느 결과인지 모른다.
             if (ev.parallel || ev.showLabel) say(`  ${toolLabel(ev.name, ev.args)}`);
             if (ev.name === 'TodoWrite' && ev.result?.todos) {
@@ -872,6 +1038,19 @@ export async function chatLoop(opts = {}) {
               }
             } else {
               say(`    ${toolResultLine(ev.result, ev.ms ?? 0)}`);
+              /*
+               * 비밀이 지나갔으면 반드시 말한다.
+               *
+               * 가렸으면 가렸다고, 못 가렸으면 못 가렸다고 적는다. 파일에서
+               * 읽어 온 글은 일부러 안 가린다 — 가리면 모델이 그 가린 글을
+               * 되돌려 써서 진짜 열쇠가 지워진다. 대신 사람에게 알린다.
+               * 조용히 넘어가면 사람은 제 열쇠가 대화에 들어간 줄을 모른다.
+               */
+              if (ev.비밀) {
+                say(ev.비밀.가렸나
+                  ? `      ${c.gray(`⊘ ${ev.비밀.말} — 모델에 가려서 보냈습니다`)}`
+                  : `      ${c.yellow('!')} ${c.yellow(ev.비밀.말)} ${c.gray('— 파일 내용은 가리지 않습니다 (가리면 되돌려 쓸 때 지워집니다)')}`);
+              }
               /*
                * 파일을 바꾸는 명령이었으면, 무엇을 떠 뒀는지 적는다.
                *
@@ -879,6 +1058,18 @@ export async function chatLoop(opts = {}) {
                * 수 있는지 없는지 알 길이 없어서, 사람은 되돌릴 수 있는 줄 알고
                * 넘어가거나 반대로 못 되돌리는 줄 알고 겁을 낸다. 사실을 적는다.
                */
+              /*
+               * 확인한 것을 센다. 상태줄이 이 숫자를 본다.
+               *
+               * 모델이 "다 됐습니다" 로 답을 맺는 것과 **실제로 돌려 본 것**은
+               * 다른 일이다. 화면에 초록 ✓ 가 없으면 아직 아무도 안 돌려 본
+               * 것이고, 그 구분이 상태줄에 있어야 사람이 속지 않는다.
+               */
+              if (ev.name === 'Verify' && ev.result) {
+                session.검증.돈횟수 += 1;
+                session.검증.확인 += ev.result.확인됨 ?? 0;
+                session.검증.탈 += ev.result.탈 ?? 0;
+              }
               if (ev.result?.되돌릴것?.length) {
                 const 것들 = ev.result.되돌릴것;
                 say(`      ${c.gray(`↩ ${것들.slice(0, 3).join(' · ')}${것들.length > 3 ? ` 외 ${것들.length - 3}개` : ''} 는 떠 뒀습니다 — /undo 로 되돌아갑니다`)}`);
@@ -936,17 +1127,29 @@ export async function chatLoop(opts = {}) {
            */
           case 'task_start':
             clearThinking();
-            if (streamed) { say(''); streamed = false; }
+            if (streamed) { 답비우기(); say(''); streamed = false; }
             화면.일바꿈('하위', clip(ev.목적, 24));
             say('');
             say(`  ${c.hmagenta('⌥')} ${c.bold('하위 작업')} ${c.white(clip(ev.목적, 60))}`
-              + ` ${c.gray(`· ${getWork(ev.모드).name} · 최대 ${ev.steps}걸음`)}`);
+              + ` ${c.gray(`· ${보일이름(ev.모드)} · 최대 ${ev.steps}걸음`)}`);
             say(`  ${c.gray('여기서부터는 따로 떨어진 대화입니다 — 결과 요약만 위로 올라옵니다.')}`);
+            /*
+             * 다른 모델에게 떼어 줬으면 여기서 말한다.
+             *
+             * 상태줄의 ⌂ 는 이 세션의 연결을 보고 있어서 하위가 딴 데로
+             * 나가는 것을 모른다. 이 줄이 그 사실을 남기는 유일한 자리다.
+             * 바깥으로 나가면 노랗게 — 그냥 지나칠 수 없게.
+             */
+            if (ev.모델) {
+              say(ev.밖으로
+                ? `  ${c.hyellow('↗')} ${c.hyellow(ev.모델)} ${c.gray('— 이 덩이는 바깥으로 나갑니다')}`
+                : `  ${c.hgreen('⌂')} ${c.gray(`${ev.모델} — 이 컴퓨터 안입니다`)}`);
+            }
             break;
 
           case 'task_done': {
             clearThinking();
-            if (streamed) { say(''); streamed = false; }
+            if (streamed) { 답비우기(); say(''); streamed = false; }
             const 끝 = ev.끝 ?? {};
             const 잘됨 = 끝.type === 'done';
             const 왜 = { done: '끝냈습니다', limit: '걸음 수를 다 써서 멈췄습니다 — 다 못 했습니다',
@@ -954,7 +1157,7 @@ export async function chatLoop(opts = {}) {
               aborted: '중단했습니다' }[끝.type] ?? '끝난 이유를 알 수 없습니다';
             say('');
             say(`  ${잘됨 ? c.green('✓') : c.yellow('⚠')} ${c.gray('하위 작업')} ${c.white(clip(ev.목적, 50))}`
-              + ` ${c.gray(`— ${왜}`)} ${c.gray(`(${끝.steps ?? 0}걸음)`)}`);
+              + ` ${c.gray(`— ${왜}`)} ${c.gray(`(${끝.steps ?? 0}걸음${ev.모델 ? ` · ${ev.모델}` : ''})`)}`);
             // 무엇이 실제로 생겼는지는 하위가 한 말이 아니라 디스크가 말한다.
             만든파일보이기(끝.files);
             if (끝.why) say(`  ${c.gray(`막힌 데: ${clip(끝.why, 80)}`)}`);
@@ -981,6 +1184,30 @@ export async function chatLoop(opts = {}) {
             접는중 = true;
             break;
 
+          /*
+           * 요약 압축보다 먼저 오는 것. 대화는 안 건드리고 옛 도구 결과만 접었다.
+           * 조용히 하면 사람은 어느 파일 내용이 왜 사라졌는지 모른다 — 한 줄로 알린다.
+           */
+          case 'folded': {
+            clearThinking();
+            say(`  ${c.cyan('◲')} ${c.gray(`오래된 도구 결과 ${ev.접은것}개를 접었습니다 — `)}`
+              + `${c.white(ev.아낀토큰.toLocaleString())} ${c.gray('토큰을 비웠습니다. 대화는 그대로입니다.')}`);
+            /*
+             * 무엇을 접었는지 이름으로 보여 준다.
+             *
+             * 조용히 버리면 "아까 그 파일 내용 어디 갔지" 를 사람이 스스로 답할 수
+             * 없다. 개발자 수준에서만 편다 — 쉬움 수준에서는 숫자 한 줄이면 된다.
+             */
+            const 접은것들 = ev.접은것들 ?? [];
+            if (접은것들.length && session.level !== '쉬움') {
+              const 보일것 = 접은것들.slice(0, 4)
+                .map((x) => `${x.도구}${x.곳 ? `(${x.곳})` : ''}`).join(' · ');
+              const 남은수 = 접은것들.length - Math.min(4, 접은것들.length);
+              say(`    ${c.gray(`${보일것}${남은수 > 0 ? ` 외 ${남은수}개` : ''}`)}`);
+            }
+            break;
+          }
+
           case 'compacted': {
             접기멈춤();
             const 줄인 = ev.before - ev.after;
@@ -989,7 +1216,7 @@ export async function chatLoop(opts = {}) {
                 `${c.green(`(${Math.round((줄인 / Math.max(1, ev.before)) * 100)}% 줄어듦)`)}`);
             if (ev.fallback) say(`     ${c.yellow('요약을 못 받아 그냥 줄였습니다.')}`);
             // 접히면 이력이 통째로 바뀐다. 덧붙이기로는 못 맞추니 새로 적는다.
-            store.replace(session.messages, `압축 — ${ev.folded}개를 요약으로`);
+            ctx.갈래.현재store().replace(session.messages, `압축 — ${ev.folded}개를 요약으로`);
             saved = session.messages.length;
             break;
           }
@@ -1033,7 +1260,7 @@ export async function chatLoop(opts = {}) {
           case 'stuck':
             턴탈났나 = true;
             clearThinking();
-            if (streamed) { say(''); streamed = false; }
+            if (streamed) { 답비우기(); say(''); streamed = false; }
             say('');
             say(`  ${c.yellow('⊘')} ${c.bold('같은 자리에서 헛돌고 있어 멈췄습니다.')}`);
             say(`  ${c.gray(ev.why)}`);
@@ -1055,7 +1282,7 @@ export async function chatLoop(opts = {}) {
           case 'aborted':
             턴탈났나 = true;
             clearThinking();
-            if (streamed) { say(''); streamed = false; }
+            if (streamed) { 답비우기(); say(''); streamed = false; }
             say('');
             // 남았는지 아닌지를 **사실대로** 말한다. 전에는 무조건 '남아 있다' 고 했는데
             // 실제로는 아무것도 안 남는 경우가 있었다. 그러면 "이어서 해줘" 라고 했을 때
@@ -1074,7 +1301,7 @@ export async function chatLoop(opts = {}) {
 
           case 'done':
             clearThinking();
-            if (streamed) say('');
+            if (streamed) { 답비우기(); say(''); }
             만든파일보이기(ev.files);
             break;
         }
@@ -1090,6 +1317,22 @@ export async function chatLoop(opts = {}) {
     // 어떻게 끝났든 일하는 표시는 반드시 걷는다. 오류로 빠져나온 길에서
     // 안 걷으면 돌아가는 표시가 화면에 붙박이로 남고, 시계도 계속 돈다.
     화면.일끝();
+    clearInterval(제목시계);
+    /*
+     * 오래 걸린 턴만 알린다. "안녕" 에 1초 만에 답할 때마다 딩 소리가 나면
+     * 사람은 이틀 만에 알림을 꺼 버리고, 그러면 정작 3분짜리 턴도 못 듣는다.
+     * 알림은 아껴 써야 알림이다. (문턱은 ui/notify.js 의 알릴만한초)
+     */
+    /*
+     * 되돌릴 수 있는 턴 수를 여기서 한 번 센다.
+     *
+     * 상태줄이 직접 세게 하면 안 된다 — 상태줄은 사람이 글자 하나 칠 때마다
+     * 다시 그려지고, 거기서 이력 파일을 열면 타이핑이 끊긴다. 턴 경계에서
+     * 한 번 세어 두면 화면은 그 숫자만 읽으면 된다.
+     */
+    try { session.되돌릴턴 = ctx.history.turns().length; } catch { /* 못 세면 그냥 둔다 */ }
+    if (알릴까({ 걸린밀리초: Date.now() - started, 켬: 알림.켬 })) 종();
+    창제목(제목글(턴탈났나 ? '탈남' : '끝남', { 폴더: 알림.폴더 }));
     turn = null;
     interrupted = false;   // 중단은 '끝내기' 의사가 아니다. 종료 카운트를 되돌린다.
     flush();               // 오류로 끝났어도 여기까지는 남긴다
@@ -1119,6 +1362,9 @@ export async function chatLoop(opts = {}) {
       say('');
       계획상자(할일);
       say('');
+      // 계획을 다 내놓고 사람 답을 기다리는 자리다. 위 confirm 과 같은 이유로 알린다.
+      if (알릴까({ 물어봄: true, 켬: 알림.켬 })) 종();
+      창제목(제목글('물어봄', { 폴더: 알림.폴더 }));
       const 답 = String(await ask(
         `이대로 진행할까요? ${c.gray('⏎ 진행 · n 취소 · 그 밖엔 고칠 점')}`,
         { def: 'y' },
@@ -1145,9 +1391,14 @@ export async function chatLoop(opts = {}) {
   }
 
   rl.close();
+  // 남의 터미널을 우리 이름으로 두고 나가지 않는다. 켤 때 있던 제목으로 돌려놓는다.
+  제목되돌리기();
   // 띄운 남의 프로세스는 반드시 거둔다. 안 거두면 deel 을 껐는데도
   // 그 서버가 계속 돌고 있게 된다 — 사람 눈에는 안 보이는 채로.
   for (const s of mcp붙임.서버들) s.닫기();
+  // 언어 서버도 같이 거둔다. 이건 사람 눈에 안 보이는 채로 메모리를 몇백 MB
+  // 물고 있는 종류라, 남겨 두면 나중에 작업 관리자를 열기 전에는 모른다.
+  언어서버다끄기().catch(() => {});
   // 뒤에서 돌던 명령도 같이 거둔다. 이걸 조용히 하면 안 된다 —
   // 사람은 dev 서버가 아직 떠 있다고 여기고 브라우저를 새로 고치다가
   // "왜 안 되지" 로 시간을 쓴다. 몇 개를 껐는지 말해 준다.

package/src/safety/guard.js

@@ -72,12 +72,47 @@ const BLOCKED = [
   { re: /\brm\s+(-[a-z]*[rR][a-z]*f|-[a-z]*f[a-z]*[rR])\b[^|;&]*\s(\/|~|\$HOME)\s*$/i, why: '뿌리 폴더를 통째로 지우려 합니다' },
   { re: /\b(mkfs|fdisk|diskpart)\b/i, why: '디스크를 초기화하는 명령입니다' },
   { re: /\bformat\s+[a-z]:/i, why: '드라이브를 포맷하는 명령입니다' },
-  { re: /\b(rd|rmdir)\s+\/s\b/i, why: '폴더를 통째로 지웁니다 — 정션이 있으면 원본까지 딸려 갑니다' },
-  { re: /\bdel\s+\/[sq]\b.*\\\*/i, why: '하위 폴더까지 전부 지웁니다' },
+  // 윈도우 짝을 빠뜨리면 안 된다 — deel 은 윈도우에서 주로 돈다.
+  //
+  // 옛 규칙은 스위치가 **차례대로** 오고 끝에 `\*` 가 붙은 모양만 봤다.
+  // 그래서 `del /f /s /q C:\` 와 `rd /q /s C:\` 가 그대로 새어 나갔다.
+  // 스위치는 아무 차례로나 오므로 차례를 안 따진다.
+  { re: /\b(rd|rmdir)\b[^|;&]*\s\/s\b/i, why: '폴더를 통째로 지웁니다 — 정션이 있으면 원본까지 딸려 갑니다' },
+  { re: /\bdel\b[^|;&]*\s\/[sq]\b[^|;&]*(\\\*|\s[a-z]:\\?\s*$)/i, why: '하위 폴더까지 전부 지웁니다' },
+  // 파워셸도 같은 일을 한다. 드라이브 뿌리나 집 폴더를 통째로 미는 것만 본다 —
+  // 폴더 하나 지우는 평범한 Remove-Item 까지 막으면 도구를 못 쓴다.
+  {
+    re: /Remove-Item\b[^|;&]*\s-(Recurse|r)\b[^|;&]*\s(-?[a-z]*\s*)*([a-z]:\\?|~|\$HOME|\$env:USERPROFILE)\s*$/i,
+    why: '드라이브나 집 폴더를 통째로 지웁니다',
+  },
   { re: /git\s+push\b[^|;&]*--force(?!-with-lease)/i, why: '원격 이력을 덮어씁니다 (--force-with-lease 를 쓰세요)' },
   // 낱말만 보면 안 된다. `node scripts/shutdown.js` 나 `npm run reboot` 이
   // '시스템을 끕니다' 로 막히고 감사기록에까지 남았다. 명령의 **첫 낱말**일 때만 본다.
   { re: /(^|[|;&]\s*)(sudo\s+)?(shutdown|reboot|halt|poweroff)\b/i, why: '시스템을 끕니다' },
+  // 포크 폭탄.
+  //
+  // 껐다 켜면 기계는 돌아오니 '되돌릴 수 없는 것' 은 아니다. 그런데 되돌아오지
+  // 않는 것이 하나 있다 — **아직 안 적은 것들.** 기계가 굳으면 열어 둔 것을
+  // 저장할 수도, 하던 대화를 끝낼 수도 없다. 그래서 목록에 넣는다.
+  //
+  // 이름은 아무거나 될 수 있으니(`:` 든 `bomb` 든) 이름 자체를 보지 않고 **모양**을
+  // 본다: 함수를 만들고, 그 안에서 **저를 불러 곧바로 파이프나 뒤로 보내기에**
+  // 물리고, 밖에서 그 이름을 부른다. 뒷갈이(\2)로 같은 이름인지까지 본다.
+  //
+  // '저를 부른 **바로 뒤**가 | 나 &' 인 것이 열쇠다. 그냥 '이름이 몸 안에 있고
+  // & 도 있다' 로 보면 `up(){ docker compose up -d & }; up` 같은 평범한 함수가
+  // 걸린다 — 거기서는 up 뒤에 `-d` 가 온다.
+  //
+  // 이름 앞뒤로 낱말 경계도 본다. 그래야 `tee -a out.log` 의 log 나
+  // `deploy_app` 의 deploy 를 저를 부르는 것으로 잘못 읽지 않는다.
+  // 앞자리에 따옴표와 여는 괄호도 넣는다. 안 넣으면 `bash -c ":(){ :|:& };:"` 처럼
+  // 한 겹 싸는 것만으로 그대로 새어 나간다.
+  {
+    re: /(^|[|;&\s"'(])([\w.:]{1,16})\s*\(\s*\)\s*\{[^}]*(?<![\w.])\2(?![\w.])\s*[|&][^}]*\}\s*;?\s*(?<![\w.])\2(?![\w.])/,
+    why: '스스로를 끝없이 불려 기계를 멈춰 세웁니다 (포크 폭탄)',
+  },
+  // 같은 것을 한 줄로 적는 오래된 방법. 이 모양으로 쓸 다른 일이 없다.
+  { re: /\bfork\s+while\s+fork\b/i, why: '스스로를 끝없이 불려 기계를 멈춰 세웁니다 (포크 폭탄)' },
   { re: /curl[^|]*\|\s*(ba)?sh/i, why: '받은 스크립트를 그대로 실행합니다' },
   { re: /\biwr\b[^|]*\|\s*iex\b/i, why: '받은 스크립트를 그대로 실행합니다' },
 ];