deel-local-cli 0.5.0 → 0.9.0

package/src/repl.js

@@ -1,29 +1,55 @@
 // 대화 화면. 루프가 보내는 이벤트를 Claude Code 풍으로 그린다.
-import { createInterface } from 'node:readline';
-import { c, say, mark, cursor, width } from './ui/ansi.js';
-import { handle, COMMANDS } from './commands.js';
+import { createInterface, emitKeypressEvents } from 'node:readline';
+import { c, say, mark, cursor, box, clip, cols } from './ui/ansi.js';
+import { statusLine, headerLines, contextWarning } from './ui/status.js';
+import { STAGES } from './agent/effort.js';
+import { handle } from './commands.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 { makeScope } from './safety/guard.js';
 import { History } from './safety/undo.js';
 import { Audit } from './safety/audit.js';
-import { activeProfile, load, resolveKey } from './config.js';
+import { activeProfile, load, resolveKey, save as saveCfg } 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 { askHidden } from './ui/prompt.js';
+import { spin } from './ui/spinner.js';
+import { explain } from './ui/level.js';
+import { probeCtx, 기본값 as CTX_DEFAULT } from './backend/ctxsize.js';
+
+// 도구마다 눈에 띄는 글자를 다르게 준다. 훑을 때 종류가 먼저 보인다.
+const TOOL_GLYPH = {
+  Read: c.blue('◧'),
+  Write: c.green('◆'),
+  Edit: c.yellow('◈'),
+  Glob: c.magenta('❋'),
+  Grep: c.magenta('❊'),
+  Bash: c.hcyan('▶'),
+  Skill: c.hmagenta('✦'),
+  WebFetch: c.hblue('◍'),
+  TodoWrite: c.hyellow('☰'),
+};
 
 // 도구 호출을 한 줄로 요약 — Read(src/a.js) 처럼.
 function toolLabel(name, args) {
   const a = args ?? {};
   const first =
-    a.file_path ?? a.pattern ?? a.path ??
-    (a.command ? String(a.command).slice(0, 48) : '') ?? '';
-  return `${name}(${c.gray(String(first))})`;
+    a.file_path ?? a.pattern ?? a.path ?? a.url ?? a.name ??
+    (a.command ? String(a.command).replace(/\s+/g, ' ').slice(0, 52) : null) ??
+    // 할 일 목록은 보여줄 경로가 없다. 빈 괄호를 띄우느니 개수를 적는다.
+    (Array.isArray(a.todos) ? `${a.todos.length}건` : null) ?? '';
+  const g = TOOL_GLYPH[name] ?? c.cyan('⏺');
+  const 안 = clip(String(first ?? ''), 56);
+  return `${g} ${c.bold(name)}${안 ? `${c.gray('(')}${c.gray(안)}${c.gray(')')}` : ''}`;
 }
 
 function toolResultLine(result, ms) {
-  if (result?.error) return `${c.red('└')} ${c.red(String(result.error).split('\n')[0])}`;
-  const s = result?.summary ?? '완료';
-  const t = ms > 1000 ? c.gray(` ${(ms / 1000).toFixed(1)}초`) : '';
-  return `${c.gray('└')} ${c.gray(s)}${t}`;
+  const t = ms > 700 ? c.gray(`  ${(ms / 1000).toFixed(1)}초`) : '';
+  if (result?.error) return `${c.red('└')} ${c.red(clip(String(result.error).split('\n')[0], 80))}${t}`;
+  return `${c.gray('└')} ${c.gray(clip(result?.summary ?? '완료', 80))}${t}`;
 }
 
 export async function chatLoop(opts = {}) {
@@ -40,17 +66,54 @@ export async function chatLoop(opts = {}) {
   const conn = {
     kind: prof.kind, base: prof.baseUrl, auth: prof.auth,
     key: resolveKey(prof), model: prof.model,
-    ctx: prof.ctx ?? 32768, streaming: prof.streaming ?? false,
+    // 컨텍스트 길이. 순서가 곧 우선순위다 —
+    //   deel --ctx 655360  >  프로필에 저장된 값  >  기본값
+    // 기본값으로 떨어졌다는 것은 '아직 못 쟀다' 는 뜻이다. 아래에서 그렇다고 말해 준다.
+    ctx: opts.ctx ?? prof.ctx ?? CTX_DEFAULT,
+    // 답 길이 상한. 컨텍스트와 다른 축이다 — 없으면 effort.js 의 울타리를 쓴다.
+    maxTokens: prof.maxTokens ?? null,
+    streaming: prof.streaming ?? false,
     tools: prof.tools ?? false, json: prof.json ?? false, think: prof.think ?? false,
   };
 
+  // 이 자리 하나만 연다. 다른 어디로도 나가지 못한다.
+  allowEndpoint(conn.base);
+  if (opts.offline ?? prof.offline) setOffline(true);
+
   const session = new Session(conn, {
     root,
     mode: opts.mode ?? 'auto',
+    // 처음부터 원하는 모드로 시작할 수 있다 — deel --work plan
+    work: opts.work ?? null,
+    // 수준은 설정에 남는다. 한 번 고르면 다음에 켤 때도 그대로다.
+    level: opts.level ?? cfg.level ?? null,
     think: opts.think ?? 'medium',
+    effort: opts.effort ?? 'save',
     maxSteps: opts.maxSteps ?? 24,
   });
 
+  // ── 대화 이어하기 ─────────────────────────────────────────────────────
+  // 껐다 켜도 이어지도록, 메시지가 오갈 때마다 .deel/sessions/ 에 바로 적는다.
+  let store = null;
+  if (opts.sessionId || opts.continue) {
+    const target = opts.sessionId ?? latest(root)?.id;
+    if (!target) {
+      say('');
+      say(`  ${c.gray('이어할 대화가 없습니다. 새로 시작합니다.')}`);
+    } else {
+      store = new Store(root, target);
+      const { messages } = store.load();
+      if (messages.length) {
+        session.messages = messages;
+        say('');
+        say(`  ${mark.ok} ${c.bold(target)} ${c.gray(`— 메시지 ${messages.length}개를 이어 받았습니다.`)}`);
+      }
+    }
+  }
+  if (!store) store = new Store(root);
+  store.begin({ model: conn.model, base: conn.base, root });
+  try { prune(root); } catch {}
+
   // 이 PC 에 있는 스킬·명령·플러그인을 찾아 붙인다. 품고 다니지 않는다.
   const found = discover(root);
   session.skills = found.skills;
@@ -66,7 +129,7 @@ export async function chatLoop(opts = {}) {
   const echo = !process.stdin.isTTY;   // 파이프·기록용일 때는 입력을 되비춘다
 
   rl.on('line', (l) => {
-    if (echo) say(l);
+    if (echo) say(c.gray(l));
     if (waiter) { const w = waiter; waiter = null; w(l); }
     else queue.push(l);
   });
@@ -75,6 +138,23 @@ export async function chatLoop(opts = {}) {
     if (waiter) { const w = waiter; waiter = null; w(null); }
   });
 
+  // Shift+Tab 으로 작업 모드를 차례로 돌린다.
+  //
+  // 터미널일 때만 한다. 파이프로 넣을 때 키를 가로채면 입력이 깨진다 —
+  // 검사와 데모가 그렇게 돌아간다.
+  if (process.stdin.isTTY) {
+    emitKeypressEvents(process.stdin, rl);
+    process.stdin.on('keypress', (_ch, key) => {
+      if (!key || key.name !== 'tab' || !key.shift) return;
+      session.work = nextWork(session.work);
+      const w = getWork(session.work);
+      cursor.clearLine();
+      say(`  ${c.hcyan(w.glyph)} ${c.bold(w.name)} ${c.gray('(' + w.en + ')')}  ${c.gray(w.hint)}`
+        + (canWrite(session.work) ? '' : `  ${c.green('· 파일을 못 바꿉니다')}`));
+      prompt();
+    });
+  }
+
   const nextLine = () => {
     if (queue.length) return Promise.resolve(queue.shift());
     if (closed) return Promise.resolve(null);
@@ -88,6 +168,22 @@ export async function chatLoop(opts = {}) {
     return a.trim() || o.def || '';
   };
 
+  /**
+   * 오류를 이 사람 수준에 맞게 보여준다.
+   *
+   * 쉬움 수준에서는 무엇을 하면 되는지를 앞에 놓고, 원래 문구는 회색으로 뒤에 남긴다.
+   * 원인을 지우지 않는 것이 중요하다 — 지우면 물어볼 수도 없게 된다.
+   * 개발자 수준에서는 원래 문구 그대로다.
+   */
+  const 오류보이기 = (message) => {
+    const r = explain(session.level, message);
+    if (!r.plain) { say(`  ${c.red('✗')} ${String(message)}`); return; }
+    const [머리, ...나머지] = r.text.split('\n');
+    say(`  ${c.red('✗')} ${머리}`);
+    for (const l of 나머지) say(`  ${l}`);
+    if (r.detail) say(`  ${c.gray(`(원래 문구: ${clip(String(r.detail).split('\n')[0], 90)})`)}`);
+  };
+
   const ctx = {
     scope: makeScope(root),
     history: new History(root),
@@ -96,6 +192,13 @@ export async function chatLoop(opts = {}) {
     skills: found.skills,
     loadedSkills: new Set(),
     ask,
+    // 암호는 여기서만 받는다. 받은 값은 도구가 쓰고 버린다 —
+    // 설정에도, 세션 기록에도, 감사기록에도, 명령줄에도 안 남는다.
+    askPassword: async (label) => {
+      if (closed) return null;
+      const pw = await askHidden(rl, label, nextLine);
+      return pw === null || pw === '' ? null : pw;
+    },
     confirm: async (name, args) => {
       say('');
       say(`  ${c.yellow('?')} ${toolLabel(name, args)}`);
@@ -104,30 +207,80 @@ export async function chatLoop(opts = {}) {
     },
   };
 
-  // 머리말
-  say('');
-  say(`  ${c.cyan('deel')}  ${c.gray(prof.model)}  ${c.gray('·')}  ${c.gray(ctx.scope.root)}`);
-  const warn = [];
-  if (!conn.tools) warn.push('도구 호출 미확인');
-  if (!conn.streaming) warn.push('스트리밍 없음');
-  if (warn.length) say(`  ${c.yellow('⚠')} ${c.gray(warn.join(' · '))}`);
-  if (found.skills.length || found.commands.length) {
-    say(`  ${c.gray(`스킬 ${found.skills.length}개 · 명령 ${found.commands.length}개 찾음`)}${found.plugins.length ? c.gray(` (플러그인 ${found.plugins.length}개)`) : ''}`);
+  // ── 컨텍스트 길이를 모델에서 긁어온다 ─────────────────────────────────
+  //
+  // 켤 때마다 서버에 물어본다. 저장된 값을 그대로 믿지 않는다 —
+  // 같은 이름의 모델이라도 서버에서 몇 k 로 올렸는지가 그때그때 다르고,
+  // 그 차이를 화면에 못 보면 조용히 작아진 채로 쓰게 된다.
+  //
+  // --ctx 로 직접 주신 값이 있으면 안 건드린다. 사람이 고른 것을 뒤집지 않는다.
+  const 길이알림 = [];   // 잘 된 소식
+  const 길이경고 = [];   // 손을 봐야 하는 것
+  if (opts.ctx == null) {
+    // 이 컴퓨터 안의 서버면 눈 깜짝할 새다. 사내 게이트웨이는 몇 초 걸릴 수 있어
+    // 무슨 일이 일어나는 중인지 알려 준다 — 멈춘 것처럼 보이면 안 된다.
+    const s = spin('모델에 걸린 컨텍스트 길이를 확인하는 중…');
+    let r = null;
+    try { r = await probeCtx(conn, { timeout: 6000 }); } catch { /* 못 물어보면 아래에서 처리 */ }
+    s.stop('');
+    if (r?.value) {
+      const 전 = conn.ctx;
+      conn.ctx = r.value;
+      // 알아낸 값은 프로필에 남긴다. 다음에 켤 때 화면이 곧바로 맞게 뜬다.
+      if (prof.ctx !== r.value) {
+        prof.ctx = r.value;
+        try { const cfg2 = load(); const t = cfg2.profiles.find((p) => p.id === prof.id); if (t) { t.ctx = r.value; saveCfg(cfg2); } } catch { /* 못 남겨도 이번 세션에는 먹는다 */ }
+      }
+      if (전 !== r.value) 길이알림.push(`컨텍스트를 ${전.toLocaleString()} ${c.gray('→')} ${c.white(r.value.toLocaleString())} 로 맞췄습니다 ${c.gray('(' + (r.source ?? '서버') + '에서 읽음)')}`);
+      if (r.max && r.loaded && r.max > r.loaded) {
+        길이경고.push(`이 모델은 ${c.white(r.max.toLocaleString())} 까지 됩니다 — 서버에서 더 올린 뒤 ${c.cyan('/ctx auto')}`);
+      }
+    } else if (prof.ctx == null) {
+      길이경고.push(`컨텍스트를 서버가 안 알려줍니다 — 우선 ${CTX_DEFAULT.toLocaleString()} 으로 잡았습니다. ${c.cyan('/ctx 655360')} 처럼 직접 지정하세요`);
+    }
   }
-  say(`  ${c.gray('/help 로 명령 목록.  Ctrl+C 로 끝냅니다.')}`);
+
+  // ── 머리말 ────────────────────────────────────────────────────────────
   say('');
+  for (const l of box(headerLines(session, found), { tone: c.gray })) say('  ' + l);
+  const warn = [];
+  if (!conn.tools) warn.push('도구 호출이 확인되지 않았습니다 — deel diagnose 로 점검하세요');
+  if (!conn.streaming) warn.push('스트리밍이 없어 응답이 한 번에 나옵니다');
+  warn.push(...길이경고);
+  // 잘 된 것은 경고 표시를 달지 않는다. ⚠ 가 붙으면 뭘 고쳐야 하나 싶어진다.
+  for (const l of 길이알림) say(`  ${mark.ok} ${c.gray(l)}`);
+  for (const w of warn) say(`  ${mark.warn} ${c.gray(w)}`);
+  say(`  ${c.gray('/help 명령 목록')}   ${c.gray('/think 추론 강도')}   ${c.gray('Ctrl+C 중단·끝내기')}`);
 
+  // 입력 자리. 위에 상태줄을 한 줄 깔고 그 아래에 커서를 둔다.
+  const prompt = () => {
+    say('');
+    say(statusLine(session));
+    const w = contextWarning(session);
+    if (w) say(` ${w}`);
+    process.stdout.write(` ${c.hcyan('❯')} `);
+  };
+
+  // Ctrl+C 는 상황에 따라 뜻이 다르다.
+  //   모델이 답하는 중  → 그 답을 끊는다 (프로그램은 살아 있다)
+  //   입력을 기다리는 중 → 한 번은 경고, 두 번이면 끝낸다
+  // 느린 로컬 모델이 엉뚱한 답을 길게 뽑기 시작했을 때 끝까지 기다리지 않아도 된다.
   let interrupted = false;
+  let turn = null;              // 지금 도는 턴의 AbortController
   rl.on('SIGINT', () => {
+    if (turn && !turn.signal.aborted) {
+      turn.abort();
+      return;                   // 화면 정리는 루프 쪽 'aborted' 이벤트가 한다
+    }
     if (interrupted) { rl.close(); return; }
     interrupted = true;
     say('');
     say(`  ${c.gray('한 번 더 Ctrl+C 를 누르면 끝냅니다.')}`);
-    process.stdout.write(`\n${c.cyan('›')} `);
+    prompt();
   });
 
   for (;;) {
-    process.stdout.write(`\n${c.cyan('›')} `);
+    prompt();
     const line = await nextLine();
     if (line === null) break;          // 입력이 끝났다 (파이프 종료 / Ctrl+D)
     interrupted = false;
@@ -139,84 +292,188 @@ export async function chatLoop(opts = {}) {
     if (cmd.handled) continue;
     const toSend = cmd.text ?? text;   // 슬래시 명령이면 펼쳐진 내용을 보낸다
 
+    // 종합 모드면 이 한마디가 무슨 일인지 보고 알맞은 모드로 옮긴다.
+    //
+    // 기본 모드는 안 건드린다 — 다음 한마디는 다시 처음부터 고른다.
+    // 사용자가 직접 고른 모드가 있으면 여기 안 들어온다. 사람이 고른 것을 뒤집지 않는다.
+    session.routed = null;
+    if (session.work === 'auto') {
+      const 골라진 = route(toSend);
+      if (골라진.mode) {
+        session.routed = 골라진.mode;
+        const w = getWork(골라진.mode);
+        say('');
+        say(`  ${c.hcyan(w.glyph)} ${c.bold(w.name)} ${c.gray('(' + w.en + ')')}`
+          + `  ${c.gray('말 속에 ' + 골라진.why + ' 가 있어서')}`
+          + (canWrite(골라진.mode) ? '' : `  ${c.green('· 파일은 안 바꿉니다')}`));
+        say(`  ${c.gray('다르면')} ${c.cyan('/code')} ${c.gray('처럼 직접 고르세요. 그때부터는 안 바뀝니다.')}`);
+      }
+    }
+
     say('');
     const started = Date.now();
+    const before = { in: session.usage.in, out: session.usage.out };
+
+    // 어디까지 적었는지. 도중에 죽어도 여기까지는 남아 있게 자주 흘려 보낸다.
+    let saved = session.messages.length;
+    const flush = () => {
+      for (const m of session.messages.slice(saved)) store.append(m);
+      saved = session.messages.length;
+    };
     let tools = 0;
     let thinkChars = 0;
     let streamed = false;
     let thinkingShown = false;
+    let stage = null;
+
+    const clearThinking = () => { if (thinkingShown) { cursor.clearLine(); thinkingShown = false; } };
 
+    turn = new AbortController();
     try {
-      for await (const ev of run(session, ctx, toSend)) {
+      for await (const ev of run(session, ctx, toSend, { signal: turn.signal })) {
         switch (ev.type) {
+          // 어느 단계를 어떤 강도로 도는지 — 추론 강도 조절이 실제로 먹는지 눈으로 보인다.
+          case 'stage':
+            stage = ev;
+            thinkChars = 0;
+            break;
+
+          case 'retry':
+            clearThinking();
+            say(`  ${c.yellow('↻')} ${c.gray(`${ev.why} — 상한을 ${ev.from} → ${ev.to} 로 올려 다시 부릅니다`)}`);
+            break;
+
           case 'waiting':
-            process.stdout.write(`  ${c.gray('생각 중…')}\r`);
+            process.stdout.write(`  ${c.gray(stageTag(stage) + ' 생각 중…')}\r`);
             break;
 
           case 'thinking':
             thinkChars += ev.text.length;
             if (process.stdout.isTTY) {
               cursor.clearLine();
-              process.stdout.write(`  ${c.magenta('✻')} ${c.gray(`생각 중… ${thinkChars}자`)}`);
+              process.stdout.write(`  ${mark.think} ${c.gray(stageTag(stage))} ${c.gray(`생각 중… ${thinkChars.toLocaleString()}자`)}`);
               thinkingShown = true;
             }
             break;
 
           case 'content':
-            if (thinkingShown) { cursor.clearLine(); thinkingShown = false; }
+            clearThinking();
             if (!streamed) { streamed = true; process.stdout.write('  '); }
             process.stdout.write(ev.text.replace(/\n/g, '\n  '));
             break;
 
           case 'tool_start':
-            if (thinkingShown) { cursor.clearLine(); thinkingShown = false; }
+            clearThinking();
+            if (streamed) { say(''); streamed = false; }
+            say('');
+            say(`  ${toolLabel(ev.name, ev.args)}`);
+            break;
+
+          // 여럿을 같이 돌린다 — 한 줄로 알리고, 이름은 결과와 붙여서 그린다.
+          case 'tools_start':
+            clearThinking();
             if (streamed) { say(''); streamed = false; }
             say('');
-            say(`  ${c.cyan('⏺')} ${toolLabel(ev.name, ev.args)}`);
+            say(`  ${c.gray(`${ev.count}개를 함께 돌립니다`)} ${c.gray('·')} ${c.gray(ev.names.join(' '))}`);
             break;
 
           case 'tool':
             tools++;
-            say(`    ${toolResultLine(ev.result, ev.ms ?? 0)}`);
+            // 같이 돈 것은 이름을 다시 적어 준다. 안 그러면 어느 결과인지 모른다.
+            if (ev.parallel) say(`  ${toolLabel(ev.name, ev.args)}`);
+            if (ev.name === 'TodoWrite' && ev.result?.todos) {
+              for (const t of ev.result.todos) {
+                const 표 = t.state === 'done' ? c.green('☑') : t.state === 'doing' ? c.hyellow('▶') : c.gray('☐');
+                const 글 = t.state === 'done' ? c.gray(t.text) : t.state === 'doing' ? c.white(t.text) : c.gray(t.text);
+                say(`    ${표} ${clip(글, 74)}`);
+              }
+            } else {
+              say(`    ${toolResultLine(ev.result, ev.ms ?? 0)}`);
+            }
+            flush();   // 도구가 하나 끝날 때마다 적어 둔다
             break;
 
           case 'trimmed':
             say(`  ${c.gray(`(컨텍스트가 차서 오래된 대화 ${ev.dropped}개를 줄였습니다)`)}`);
             break;
 
+          case 'compacting':
+            clearThinking();
+            process.stdout.write(`  ${c.gray('컨텍스트가 찼습니다 — 앞선 대화를 요약해 접는 중…')}\r`);
+            break;
+
+          case 'compacted': {
+            if (process.stdout.isTTY) cursor.clearLine();
+            const 줄인 = ev.before - ev.after;
+            say(`  ${c.cyan('◱')} ${c.gray(`대화 ${ev.folded}개를 요약으로 접었습니다 — `)}` +
+                `${c.gray(ev.before.toLocaleString())} ${c.gray('→')} ${c.white(ev.after.toLocaleString())} ${c.gray('토큰')} ` +
+                `${c.green(`(${Math.round((줄인 / Math.max(1, ev.before)) * 100)}% 줄어듦)`)}`);
+            if (ev.fallback) say(`     ${c.yellow('요약을 못 받아 그냥 줄였습니다.')}`);
+            // 접히면 이력이 통째로 바뀐다. 덧붙이기로는 못 맞추니 새로 적는다.
+            store.replace(session.messages, `압축 — ${ev.folded}개를 요약으로`);
+            saved = session.messages.length;
+            break;
+          }
+
+          case 'compact_failed':
+            if (process.stdout.isTTY) cursor.clearLine();
+            say(`  ${c.gray(`(접지 못했습니다: ${ev.why})`)}`);
+            break;
+
           case 'limit':
             say('');
-            say(`  ${c.yellow('⚠')} 도구 호출 ${ev.steps}회에서 멈췄습니다. ${c.gray('이어서 하려면 다시 말씀하세요.')}`);
+            say(`  ${mark.warn} 도구 호출 ${ev.steps}회에서 멈췄습니다. ${c.gray('이어서 하려면 다시 말씀하세요.')}`);
+            break;
+
+          case 'aborted':
+            clearThinking();
+            if (streamed) { say(''); streamed = false; }
+            say('');
+            say(`  ${c.yellow('⊘')} ${c.gray('중단했습니다. 여기까지는 대화에 남아 있으니 이어서 말씀하세요.')}`);
             break;
 
           case 'error':
-            if (thinkingShown) cursor.clearLine();
+            clearThinking();
             say('');
-            say(`  ${c.red('✗')} ${ev.text}`);
+            오류보이기(ev.text);
             break;
 
           case 'done':
+            clearThinking();
             if (streamed) say('');
             break;
         }
       }
     } catch (err) {
+      clearThinking();
       say('');
-      say(`  ${c.red('✗')} ${err.message}`);
+      오류보이기(err.message);
     }
+    turn = null;
+    interrupted = false;   // 중단은 '끝내기' 의사가 아니다. 종료 카운트를 되돌린다.
+    flush();               // 오류로 끝났어도 여기까지는 남긴다
 
-    // 꼬리말 — 이번 턴 요약
+    // ── 꼬리말 — 이번 턴만의 숫자 ────────────────────────────────────────
     const secs = ((Date.now() - started) / 1000).toFixed(1);
     const bits = [`${secs}초`];
     if (tools) bits.push(`도구 ${tools}회`);
-    if (session.usage.out) bits.push(`${session.usage.out.toLocaleString()}토큰`);
+    const dIn = session.usage.in - before.in;
+    const dOut = session.usage.out - before.out;
+    if (dIn || dOut) bits.push(`↑${dIn.toLocaleString()} ↓${dOut.toLocaleString()}`);
     say('');
-    say(`  ${c.gray('─ ' + bits.join(' · '))}`);
+    say(`  ${c.gray('─'.repeat(2))} ${c.gray(bits.join(c.gray(' · ')))}`);
   }
 
   rl.close();
   say('');
-  say(`  ${c.gray('끝냅니다.')} ${c.gray(`도구 시간 ${(session.usage.ms / 1000).toFixed(1)}초 · 모델 호출 ${session.usage.calls}회`)}`);
+  say(`  ${c.gray('끝냅니다.')} ${c.gray(`모델 호출 ${session.usage.calls}회 · 도구 시간 ${(session.usage.ms / 1000).toFixed(1)}초 · ↑${session.usage.in.toLocaleString()} ↓${session.usage.out.toLocaleString()}`)}`);
   say('');
   return 0;
 }
+
+// "첫 판단·high" 처럼 지금 도는 단계를 짧게.
+function stageTag(ev) {
+  if (!ev) return '';
+  const label = STAGES[ev.stage]?.label ?? ev.stage;
+  return `${label}·${ev.level}`;
+}

package/src/report.js

@@ -57,7 +57,7 @@ export function verdict(facts, results) {
   if (get('json') !== 'ok') notes.push('구조적 출력이 약합니다 — 편집 형식을 프롬프트로 강제하고 검사를 붙입니다.');
   if (get('stream') !== 'ok') notes.push('스트리밍이 없습니다 — 화면은 스피너로 대체하고 기능은 동일하게 갑니다.');
   if (get('system') === 'warn') notes.push('시스템 지시를 약하게 따릅니다 — 스킬을 적게, 짧게 올려야 합니다.');
-  if (get('think') === 'ok') notes.push('추론 강도가 모델 층에서 먹습니다 — /think 로 바로 조절됩니다.');
+  if (get('think') === 'ok') notes.push('추론 강도가 모델 층에서 적용됩니다 — /think 로 바로 조절됩니다.');
   else notes.push('추론 강도는 루프 층(계획 강제·도구 호출 상한·자기검증 횟수)으로 조절합니다.');
   if (!facts.ctx) notes.push('컨텍스트 길이를 서버가 안 알려줍니다 — 설정에서 직접 넣어야 합니다.');
 

package/src/safety/network.js

@@ -0,0 +1,95 @@
+// 어디로 말을 걸 수 있는지 한 곳에서 정한다.
+//
+// 왜 필요한가:
+//   코딩 에이전트는 소스 코드를 통째로 모델에 보낸다. 그 주소가 어디인지가 전부다.
+//   "설정한 곳으로만 갑니다" 를 말로 하면 언젠가 거짓이 된다. 코드가 막아야 한다.
+//
+// 규칙:
+//   1) 기본은 전부 거절. 허용 목록에 오른 자리만 통과.
+//   2) 모델 호출은 setup 에서 정한 그 주소 하나만.
+//   3) 플러그인 받기(github)는 사용자가 그 명령을 칠 때만 잠깐 열린다.
+//   4) offline 이면 이 컴퓨터 밖은 전부 거절 — 3번도 막힌다.
+//
+// 여기를 지나지 않는 요청은 없다. http.js 의 req() 가 매번 물어본다.
+
+export class NetBlocked extends Error {
+  constructor(url, why) {
+    super(`허용되지 않은 주소입니다: ${url}\n  ${why}`);
+    this.name = 'NetBlocked';
+    this.url = url;
+  }
+}
+
+const LOCAL = new Set(['localhost', '127.0.0.1', '::1', '0.0.0.0', '[::1]']);
+
+export const isLocalHost = (h) => LOCAL.has(String(h).toLowerCase()) ||
+  /^127\./.test(h) ||
+  /^10\./.test(h) ||
+  /^192\.168\./.test(h) ||
+  /^172\.(1[6-9]|2\d|3[01])\./.test(h);
+
+function originOf(url) {
+  const u = new URL(url);
+  return `${u.protocol}//${u.host}`;
+}
+
+// 하나뿐인 문지기. 모듈 하나에 상태를 두는 것은 일부러다 —
+// 여기저기서 각자 예외를 두면 자물쇠가 아니게 된다.
+const gate = {
+  allow: new Set(),     // 통과시킬 origin 들
+  offline: false,       // true 면 이 컴퓨터 밖은 전부 거절
+  log: [],              // 실제로 나간 곳 (사람이 확인용)
+  enforced: true,
+};
+
+/** 모델 연결 주소를 허용 목록에 올린다. 이전에 올린 것은 지운다. */
+export function allowEndpoint(baseUrl) {
+  gate.allow.clear();
+  if (baseUrl) gate.allow.add(originOf(baseUrl));
+  return [...gate.allow];
+}
+
+/** 잠깐 한 곳을 더 연다. 되돌리는 함수를 준다 — 반드시 finally 에서 부른다. */
+export function allowTemporarily(url) {
+  const o = originOf(url);
+  const had = gate.allow.has(o);
+  gate.allow.add(o);
+  return () => { if (!had) gate.allow.delete(o); };
+}
+
+export function setOffline(on) { gate.offline = !!on; return gate.offline; }
+export function isOffline() { return gate.offline; }
+export function allowed() { return [...gate.allow]; }
+export function contacted() { return gate.log.slice(); }
+export function resetNet() { gate.allow.clear(); gate.log.length = 0; gate.offline = false; }
+
+/**
+ * 이 주소로 나가도 되는가. 안 되면 던진다.
+ * 통과한 것은 기록에 남는다 — "무엇이 어디로 갔나" 를 나중에 보여 주기 위해서다.
+ */
+export function checkUrl(url) {
+  let u;
+  try { u = new URL(url); } catch { throw new NetBlocked(url, '주소 형식이 아닙니다.'); }
+
+  if (u.protocol !== 'http:' && u.protocol !== 'https:') {
+    throw new NetBlocked(url, `${u.protocol} 는 쓰지 않습니다.`);
+  }
+
+  const local = isLocalHost(u.hostname);
+  if (gate.offline && !local) {
+    throw new NetBlocked(url, '오프라인 모드입니다 — 이 컴퓨터 밖으로는 나가지 않습니다.');
+  }
+
+  const origin = `${u.protocol}//${u.host}`;
+  if (!gate.allow.has(origin)) {
+    throw new NetBlocked(url,
+      gate.allow.size
+        ? `지금 허용된 곳: ${[...gate.allow].join(', ')}`
+        : '연결이 정해지지 않았습니다. deel setup 을 먼저 하세요.');
+  }
+
+  const seen = gate.log.find((x) => x.origin === origin);
+  if (seen) seen.n++;
+  else gate.log.push({ origin, n: 1, local });
+  return true;
+}

package/src/safety/undo.js

@@ -1,7 +1,11 @@
 // 되돌리기. 승인 프롬프트를 안 쓰는 대신 이게 안전망이다.
 // 파일을 고치기 전에 항상 이전 내용을 떠 놓고, /undo 로 턴 단위로 되돌린다.
 import { join } from 'node:path';
-import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync, appendFileSync, readdirSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync, appendFileSync, readdirSync, statSync } from 'node:fs';
+
+// 되돌리기 이력은 파일 내용을 통째로 담는다. 이만큼 커지면 오래된 턴을 버린다.
+const MAX_BYTES = 32 * 1024 * 1024;
+const KEEP_TURNS = 50;
 
 export class History {
   constructor(root) {
@@ -22,9 +26,50 @@ export class History {
     const before = existsSync(absPath) ? safeRead(absPath) : null;
     const rec = { turn: this.turn, at: new Date().toISOString(), path: absPath, before, label };
     appendFileSync(this.file, JSON.stringify(rec) + '\n', 'utf8');
+    this.#maybePrune();
     return rec;
   }
 
+  /**
+   * 이력이 끝없이 자라는 것을 막는다.
+   *
+   * 스냅샷은 파일 내용을 통째로 담는다. 큰 파일을 여러 번 고치면 금방 수십 MB 가 된다.
+   * 그런데 아무 때나 자르면 안 된다 — 방금 한 일을 못 되돌리게 되면 안전망이 아니다.
+   * 그래서 최근 KEEP_TURNS 개 턴은 무조건 남기고, 그보다 오래된 것만 버린다.
+   *
+   * 매번 확인하면 파일을 계속 다시 읽게 되므로, 커졌을 때만 본다.
+   */
+  #maybePrune() {
+    this.#writes = (this.#writes ?? 0) + 1;
+    if (this.#writes % 20 !== 0) return;
+    try {
+      if (statSync(this.file).size < MAX_BYTES) return;
+    } catch { return; }
+    this.prune();
+  }
+
+  #writes = 0;
+
+  /** 최근 keep 개 턴만 남기고 자른다. 버린 줄 수를 돌려준다. */
+  prune({ keep = KEEP_TURNS } = {}) {
+    const recs = this.all();
+    const turns = this.turns();
+    if (turns.length <= keep) return 0;
+    const 남길턴 = new Set(turns.slice(-keep));
+    const 남길것 = recs.filter((r) => 남길턴.has(r.turn));
+    const 버린수 = recs.length - 남길것.length;
+    if (!버린수) return 0;
+    try {
+      writeFileSync(this.file, 남길것.map((r) => JSON.stringify(r)).join('\n') + (남길것.length ? '\n' : ''), 'utf8');
+    } catch { return 0; }
+    return 버린수;
+  }
+
+  /** 지금 이력이 얼마나 되나. /status 에서 보여 준다. */
+  size() {
+    try { return statSync(this.file).size; } catch { return 0; }
+  }
+
   all() {
     if (!existsSync(this.file)) return [];
     return readFileSync(this.file, 'utf8')