deel-local-cli 2.1.2 → 2.1.3

package/src/oneshot.js

@@ -11,6 +11,7 @@
 //   그래서 '묻는 자리' 를 전부 없앤 길을 따로 낸다. 에이전트 루프는 그대로 쓴다 —
 //   여기서 루프를 다시 짜면 두 벌이 되고, 언젠가 한쪽만 고쳐진다.
 import { statSync } from 'node:fs';
+import { resolve } from 'node:path';
 import { c, mark, clip, 화면글거르기 } from './ui/ansi.js';
 import { 규칙모으기, 정책읽기, 승인바닥 } from './safety/policy.js';
 import { 훅읽기 } from './safety/hooks.js';
@@ -19,7 +20,7 @@ import { 스키마읽기, 맞나, 답에서JSON뽑기, 시킬말 as 스키마시
 import { 남길것읽기 } from './safety/shellenv.js';
 import { 받기설정 } from './safety/authcmd.js';
 import { run } from './agent/loop.js';
-import { Session, 요청잘리나, 못박을길이 } from './agent/session.js';
+import { Session, 요청잘리나, 못박을길이, 생성속도, repairToolPairs } from './agent/session.js';
 import { 양수크기 } from './agent/models.js';
 import { estimateTokens } from './backend/tokens.js';
 import { makeScope } from './safety/guard.js';
@@ -31,12 +32,14 @@ import { activeProfile, load, resolveKey, 소식줄들 } from './config.js';
 import { 말 as 옮긴말 } from './i18n/index.js';
 import { 알림채움, 알림말 } from './backend/retry.js';
 import { 전선붙이기, 세션이름짓기 } from './backend/wire.js';
-import { newId } from './agent/store.js';
+import { newId, Store, latest, prune } from './agent/store.js';
+import { 못박기 } from './agent/pins.js';
+import { 바뀐파일모음, 사건적기열기 } from './runlog.js';
 import { discover, loadCommand } from './skills/discover.js';
 import { 다붙이기 } from './backend/mcp.js';
 import { 명령들 } from './cmdnames.js';
-// 슬래시 명령을 찾는 규칙은 대화 화면과 **같은 것 하나**를 쓴다 (commands.js 의 슬래시명령찾기 머리말).
-import { 슬래시명령찾기, 비슷한슬래시명령 } from './commands.js';
+// 슬래시 명령을 찾는 규칙은 대화 화면과 **같은 것 하나**를 쓴다 (slash.js 의 슬래시명령찾기 머리말).
+import { 슬래시명령찾기, 비슷한슬래시명령, MCP프롬프트펴기 } from './slash.js';
 import { allowEndpoint, setOffline } from './safety/network.js';
 import { 지금모드, 바깥인가, 나갈수있나, 봉인됐나 } from './safety/runmode.js';
 import { 주소가리기 } from './safety/secrets.js';
@@ -124,8 +127,12 @@ export async function runOnce(opts = {}) {
   let 알려진모델 = null;
   // 붙인 MCP 서버. 아래 내놓기 가 닫는다 — 그래서 여기서 선언한다 (2.0.2 · 문 맞춤).
   let mcp서버들 = [];
+  // --events 로 연 사건 파일 (runlog.js). 아래 내놓기 가 결과 줄을 적고 닫는다 (2.1.3).
+  let 사건 = null;
 
   const 내놓기 = (r) => {
+    // 사건 파일의 마지막 줄은 --json 과 같은 결과 한 덩이다. 어느 끝맺음이든 여기를 지난다.
+    if (사건) { 사건.결과(r); 사건.닫기(); }
     /*
      * 뒤에서 돌던 명령을 반드시 거둔다.
      *
@@ -234,6 +241,30 @@ export async function runOnce(opts = {}) {
   if (opts.checkTimeout !== undefined && !(Number.isFinite(Number(opts.checkTimeout)) && Number(opts.checkTimeout) > 0)) {
     return 못함('usage', `--check-timeout 은 0 보다 큰 초여야 합니다: ${opts.checkTimeout}`);
   }
+  /*
+   * 값 없는 --resume (2.1.3). 대화 화면은 목록을 띄워 고르게 하지만 여기는 고를 사람이 없다 —
+   * 아무거나 집어 이으면 스크립트는 제가 무엇을 이었는지 모른다. 치는 자리에서 고칠 것이라 64 다.
+   */
+  if (opts.resume === true) {
+    return 못함('usage', '--resume 에 이어 할 대화 이름을 주세요 (deel sessions 로 확인) — 가장 최근 것이면 --continue');
+  }
+
+  /*
+   * ── 사건 흐름 (--events <파일>) · 2.1.3 ──────────────────────────────
+   *
+   * 일을 시작하기 **전에** 연다. 다 돌고 나서 못 열었다고 하면 지켜보려던 사람은 아무것도 못 봤다.
+   * 경로는 --output-schema 처럼 부른 자리 기준이다.
+   */
+  if (opts.events != null) {
+    const 경로 = resolve(String(opts.events));
+    try {
+      사건 = 사건적기열기(경로, {
+        알림: (왜) => 삐끗(`  ${mark.warn} ${c.yellow(`사건 파일에 더 못 적습니다 (${왜}) — 일은 계속합니다`)}`),
+      });
+    } catch (err) {
+      return 못함('events', `사건 파일을 못 열었습니다 (--events): ${경로} — ${err?.code ?? err?.message ?? err}`);
+    }
+  }
 
   // ── 시킬 말 ───────────────────────────────────────────────────────────
   // 인자로 준 것이 먼저다. 없을 때만 표준입력을 읽는다 —
@@ -252,6 +283,41 @@ export async function runOnce(opts = {}) {
    * 고친다 — acp/serve.js 의 방만들기가 이미 고친 바로 그 섞임이다.
    */
   const root = opts.root ? String(opts.root) : process.cwd();
+
+  /*
+   * ── 이어 할 대화 (--continue · --resume <이름>) · 2.1.3 ────────────────
+   *
+   * 여태 `deel run` 은 오간 말을 어디에도 안 남겼다. 스크립트가 「방금 그 일에 이어서 테스트도 고쳐」 를
+   * 시킬 길이 없어 매번 처음부터 설명했고, 모델은 방금 읽은 파일을 다시 읽었다. 이제 대화 화면과 같은
+   * 자리(.deel/sessions)에 적고, 같은 두 깃발로 잇는다 — 대화 화면에서 한 대화를 배치가 이어도 된다.
+   *
+   * 설정을 읽기 **전에** 찾는다. 없는 이름이면 모델을 부르기 전에 서야 한다. 대화 화면은 못 찾으면
+   * 새로 시작하지만 여기서는 선다 — 이름을 집어 준 스크립트는 그 대화에 이어진다고 믿고 「아까 그것」 을
+   * 시킨다. 처음 보는 모델이 그 말을 받으면 짐작으로 일을 하고 0 으로 끝난다. `--continue` 는 다르다 —
+   * 「있으면 잇고 없으면 새로」 가 스크립트의 첫 판이 기대하는 뜻이다.
+   */
+  let 이어받은것 = null;
+  {
+    const 이을이름 = typeof opts.resume === 'string' ? opts.resume
+      : (opts.continue === true ? (latest(root)?.id ?? null) : null);
+    if (opts.continue === true && typeof opts.resume !== 'string' && !이을이름) {
+      곁(`  ${c.gray('· 이어 할 대화가 없어 새로 시작합니다.')}`);
+    }
+    if (이을이름) {
+      const 곳 = new Store(root, 이을이름);
+      const { messages: 적힌것, 못읽음 } = 곳.이름틀림 ? { messages: [] } : 곳.load();
+      // 도구가 도는 중에 죽은 대화는 호출만 있고 결과가 없다 — 그대로 보내면 서버가 400 을 낸다 (repl.js 와 같다).
+      const { messages, 고친것 } = repairToolPairs(적힌것);
+      if (!messages.length) {
+        return 못함('no-session', 곳.이름틀림
+          ? `대화 이름이 아닙니다 (--resume): ${이을이름}`
+          : 못읽음
+            ? `그 대화를 못 읽었습니다 (--resume): ${이을이름} — ${못읽음}`
+            : `그런 대화가 없거나 비어 있습니다 (--resume): ${이을이름} — deel sessions 로 이름을 확인하세요`);
+      }
+      이어받은것 = { 곳, messages, 고친것 };
+    }
+  }
   /*
    * 설정을 못 읽어도 **이 문의 끝맺음으로** 끝낸다.
    *
@@ -361,6 +427,20 @@ export async function runOnce(opts = {}) {
   // session 에 실어 두는 까닭은, 대화 도중 /model 로 옮겨도 같은 자리를 보게 하려는 것이다.
   session.실행모드 = 실행모드;
 
+  /*
+   * 찾아 둔 대화를 싣는다 (위 「이어 할 대화」). 못 박은 것 · 남은 할 일 · 시킨 말 원문도 같이 —
+   * 오간 말만 돌아오고 그 셋이 빠지면 대화 화면에서 막아 둔 「껐다 켜면 까먹는다」 가 여기서 되살아난다.
+   * 적는 자리(store)는 아래 턴 바로 앞에서 연다 — 그 사이에 선 실패가 빈 대화 파일을 남기지 않게.
+   */
+  if (이어받은것) {
+    session.messages = 이어받은것.messages;
+    const 박힌것 = 이어받은것.곳.못박은것읽기();
+    if (박힌것.length) session.못박은것 = new 못박기(박힌것);
+    이어받은것.곳.살림따라가기(session);
+    곁(`  ${mark.ok} ${c.gray(`${이어받은것.곳.id} — 메시지 ${이어받은것.messages.length}개를 이어 받았습니다.`)}`
+      + (이어받은것.고친것 ? ` ${c.gray(`(중단된 도구 호출 ${이어받은것.고친것}개는 걷어냈습니다)`)}` : ''));
+  }
+
   /*
    * ── 열쇠를 받아 오는 명령 (safety/authcmd.js) ───────────────────────
    *
@@ -484,7 +564,13 @@ export async function runOnce(opts = {}) {
        * 두 벌이니 한쪽만 고치면 또 갈린다. 그래서 규칙은 commands.js 한 군데에만 둔다.
        */
       const 찾은 = 붙박이 ? null : 슬래시명령찾기(found.commands, 부른이름);
-      if (붙박이) {
+      // MCP 서버가 낸 프롬프트도 대화 화면과 같이 부른다 (2.1.3 · commands.js 의 MCP프롬프트펴기).
+      const 프롬프트 = 붙박이 || 찾은 ? null : await MCP프롬프트펴기(mcp서버들, 부른이름, 인자);
+      if (프롬프트?.탈) return 못함('command-read', `/${부른이름} — ${프롬프트.탈}`);
+      if (프롬프트) {
+        곁(`  ${c.cyan('⌘')} ${부른이름} ${c.gray(`MCP 프롬프트 · ${프롬프트.서버이름}`)}`);
+        시킬말 = 프롬프트.text;
+      } else if (붙박이) {
         return 못함('repl-only', `/${부른이름} 은 대화 화면에서만 도는 명령입니다.`
           + ' 여기서 되는 것은 파일로 적어 둔 슬래시 명령뿐입니다 (.claude/commands · .deel/commands).');
       } else if (찾은) {
@@ -673,6 +759,28 @@ export async function runOnce(opts = {}) {
     }
   }
 
+  /*
+   * ── 오간 말을 남긴다 (2.1.3) ─────────────────────────────────────────
+   *
+   * 대화 화면처럼 걸음마다 적는다. 끝에 한 번에 적으면 걸음 수 상한이나 Ctrl+C 로 선 잡의 대화가
+   * 통째로 없다 — 이어서 시킬 일이 제일 많은 게 바로 그 잡이다. 여기까지 온 뒤에 연다 — 위에서 선
+   * 실패(없는 명령 · 너무 큰 말)가 머리글만 있는 빈 대화를 남기지 않게.
+   */
+  const store = 이어받은것?.곳 ?? new Store(root);
+  store.begin({ model: conn.model, base: 주소가리기(conn.base), root });
+  if (!이어받은것) store.살림따라가기(session);
+  // 지금 이어 쓰는 대화는 정리에서 뺀다 — 한 달 넘은 대화를 이으면 바로 여기서 지워졌다 (store.js 의 prune 머리말).
+  try { prune(root, { 남길것: [store.id] }); } catch { /* 못 치워도 이 잡은 돈다 — 다음 판이 다시 해 본다 */ }
+  let 적은데까지 = session.messages.length;   // 이어 받은 말은 이미 그 파일에 있다
+  const 적기 = () => {
+    // 접기 · 비우기가 이력을 통째로 바꿨는데 그 사건을 못 봤으면(모양 되물음 도중) 덧붙이지 말고 새로 적는다.
+    if (session.messages.length < 적은데까지) store.replace(session.messages, '압축');
+    else for (const m of session.messages.slice(적은데까지)) store.append(m);
+    적은데까지 = session.messages.length;
+  };
+  // 무엇이 바뀌었나 — --json 의 files (runlog.js).
+  const 바뀐 = 바뀐파일모음(root);
+
   // ── 한 턴 ─────────────────────────────────────────────────────────────
   const turn = new AbortController();
   const 끊김 = () => { if (!turn.signal.aborted) turn.abort(); };
@@ -697,10 +805,13 @@ export async function runOnce(opts = {}) {
     const 안쪽 = (ev) => (ev.depth ? '  '.repeat(ev.depth) : '');
 
     for await (const ev of run(session, ctx, 보낼글, { signal: turn.signal })) {
+      사건?.적기(ev);   // 지켜보는 쪽에 먼저 흘린다 (--events)
+      바뀐.사건(ev);
       switch (ev.type) {
         case 'stage':
           steps = ev.step;
           이번단계글 = '';
+          적기();   // 걸음마다 적어 둔다 — 도중에 죽어도 여기까지는 남는다
           break;
 
         // 중간 단계의 말은 표준출력에 안 싣는다. "이제 파일을 읽어보겠습니다" 까지
@@ -711,6 +822,7 @@ export async function runOnce(opts = {}) {
 
         case 'tool': {
           tools++;
+          적기();
           /*
            * 실패는 실패로 보여야 한다.
            *
@@ -817,6 +929,9 @@ export async function runOnce(opts = {}) {
             ? `  ${c.cyan('◱')} ${c.yellow(`요약을 못 받아 옛 대화 ${ev.folded}개를 잘라 냈습니다 (${ev.before.toLocaleString()} → ${ev.after.toLocaleString()} 토큰)`)}`
               + (ev.why ? ` ${c.gray(`— ${clip(String(ev.why), 100)}`)}` : '')
             : `  ${c.cyan('◱')} ${c.gray(`대화 ${ev.folded}개를 요약으로 접었습니다 (${ev.before.toLocaleString()} → ${ev.after.toLocaleString()} 토큰)`)}`);
+          // 접히면 이력이 통째로 바뀐다. 덧붙이면 접히기 전과 뒤가 겹쳐 남으니 새로 적는다 (repl.js 와 같다).
+          store.replace(session.messages, ev.fallback ? `압축 못 함 — 옛 대화 ${ev.folded}개를 잘라 냄` : `압축 — ${ev.folded}개를 요약으로`);
+          적은데까지 = session.messages.length;
           break;
 
         case 'compact_failed':
@@ -875,6 +990,10 @@ export async function runOnce(opts = {}) {
           } else 곁(`  ${c.yellow('⊘')} ${c.gray(옮긴말('check.skipped', { 까닭: ev.까닭 }))}`);
           break;
 
+        case 'textcalls':
+          곁(`  ${c.gray(`↳ ${옮긴말('ev.textCalls', { n: ev.count, 이름: ev.names.join(', ') })}`)}`);
+          break;
+
         case 'nudge':
           곁(`  ${c.gray(`↺ ${ev.why === '요청누락'
             ? 옮긴말('ev.nudgeMissed', { n: ev.빠진?.length ?? 0 })
@@ -915,6 +1034,8 @@ export async function runOnce(opts = {}) {
           곁(`  ${c.cyan('◱')} ${c.gray((ev.kept?.할일 ?? 0)
             ? 옮긴말('ev.reset', { 버린수: ev.dropped, 할일: ev.kept.할일 })
             : 옮긴말('ev.resetBare', { 버린수: ev.dropped }))}`);
+          store.replace(session.messages, `자리부족 — 앞선 대화 ${ev.dropped}개를 비움`);
+          적은데까지 = session.messages.length;
           /*
            * ── 비우면서 **시킨 말 뒤가 잘렸으면** 여기서 선다 (사냥5 B5-01) ────────────
            *
@@ -1050,6 +1171,7 @@ export async function runOnce(opts = {}) {
       let 다시터짐 = '';
       try {
         for await (const ev of run(session, ctx, 스키마시킬말(출력스키마, { 다시: 잰것.탈 }), { signal: turn.signal, 고쳐쓰기: true })) {
+          사건?.적기(ev);
           if (ev.type === 'content') 다시글 += ev.text;
           else if (ev.type === 'done') 다시글 = ev.text ?? 다시글;
           else if (ev.type === 'aborted') { 다시끊김 = true; break; }
@@ -1115,12 +1237,22 @@ export async function runOnce(opts = {}) {
    */
   process.removeListener('SIGINT', 끊김);
 
+  /*
+   * 남은 말을 다 적고, 못 적은 것이 있으면 **말한다.** 이어 하려던 스크립트가 다음 판에서야
+   * 「그 대화가 반쪽이다」 를 알면 늦다 — 그래서 못 적은 판은 --json 의 session 을 비운다.
+   */
+  try { 적기(); } catch { /* 셈은 store 가 한다 — 아래에서 본다 */ }
+  const 저장탈 = store.처음못쓴것();
+  if (저장탈) 삐끗(`  ${mark.warn} ${c.yellow(옮긴말('run.notSaving', { n: 저장탈.수, 까닭: 저장탈.까닭 }))}`);
+  const 대화이름 = store.이름틀림 || store.못쓴것() ? null : store.id;
+
   const code = EXIT[reason] ?? EXIT.error;
   if (why) 삐끗(`  ${reason === 'done' ? c.gray('·') : c.red('✗')} ${why}`);
   if (!json && !quiet) {
     const 조각 = [`${((Date.now() - t0) / 1000).toFixed(1)}초`];
     if (tools) 조각.push(`도구 ${tools}회`);
     조각.push(`↑${(session.usage.prompt || session.usage.in).toLocaleString()} ↓${session.usage.out.toLocaleString()}`);
+    if (생성속도(session.usage) !== null) 조각.push(`${생성속도(session.usage)} tok/s`);
     곁(`  ${c.gray('── ' + 조각.join(' · '))}`);
   }
 
@@ -1146,8 +1278,14 @@ export async function runOnce(opts = {}) {
       // 이 칸이 없으면 받는 쪽이 0 을 실측으로 읽는다 (backend/adapter.js 의 잰것).
       못잰것: session.usage.못잰것 ?? 0,
       retries: session.usage.retries ?? 0,
+      // 생성 속도 (2.1.3). 흘려받은 부름만 잰다 — 못 쟀으면 null (session.js 의 생성속도).
+      genMs: session.usage.genMs ?? 0,
+      tokPerSec: 생성속도(session.usage),
     },
     model: conn.model,
+    // 바뀐 파일 (작업 폴더 기준 · 슬래시) 과 이 대화의 이름 — `--resume <이름>` 으로 잇는다 (2.1.3).
+    files: 바뀐.목록(),
+    session: 대화이름,
     // 모양을 못 박았을 때만 실린다. --json 으로 받는 쪽은 text 를 다시 파싱할
     // 필요 없이 이 칸을 그대로 쓰면 된다.
     ...(스키마값 !== null ? { schema: 스키마값 } : {}),

package/src/repl.js

@@ -22,7 +22,7 @@ import { handle, COMMANDS, 미리보기끄기, 적용하기 as 그림적용 } fr
 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, repairToolPairs } 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';
@@ -2224,6 +2224,8 @@ export async function chatLoop(opts = {}) {
       // 캐시가 걸린 턴일수록 실제보다 비싸게 뜬다.
       cacheRead: session.usage.cacheRead ?? 0,
       cacheWrite: session.usage.cacheWrite ?? 0,
+      genMs: session.usage.genMs ?? 0,
+      genOut: session.usage.genOut ?? 0,
     };
 
     /*
@@ -3042,6 +3044,13 @@ export async function chatLoop(opts = {}) {
             }
             break;
 
+          // 글로 적은 도구 부름을 건졌다 (backend/textcalls.js) — 흘러 나온 표 글 뒤에 무엇을 했는지 한 줄.
+          case 'textcalls':
+            clearThinking();
+            if (streamed) { 답비우기(); say(''); streamed = false; }
+            say(`  ${c.gray(`↳ ${옮긴말('ev.textCalls', { n: ev.count, 이름: ev.names.join(', ') })}`)}`);
+            break;
+
           case 'nudge':
             clearThinking();
             if (streamed) { 답비우기(); say(''); streamed = false; }
@@ -3216,6 +3225,9 @@ export async function chatLoop(opts = {}) {
     const d읽음 = (session.usage.cacheRead ?? 0) - before.cacheRead;
     const d씀 = (session.usage.cacheWrite ?? 0) - before.cacheWrite;
     if (dIn || dOut) bits.push(`↑${dIn.toLocaleString()} ↓${dOut.toLocaleString()}`);
+    // 이번 턴의 생성 속도 — 흘려받은 부름만 잰다(session.js 의 생성속도). 못 쟀으면 안 적는다.
+    const 이번속도 = 생성속도({ genMs: (session.usage.genMs ?? 0) - before.genMs, genOut: (session.usage.genOut ?? 0) - before.genOut });
+    if (이번속도 !== null) bits.push(`${이번속도} tok/s`);
     /*
      * ── ↑ 안을 가른다 ────────────────────────────────────────────────────
      *

package/src/runlog.js

@@ -0,0 +1,99 @@
+// `deel run` 이 밖으로 내는 두 가지 — 바뀐 파일 목록과 사건 흐름 (2.1.3).
+//
+// oneshot.js 에서 따로 둔다. 거기는 이미 천 줄이 넘고, 이 둘은 「루프가 내는 사건을 받아 밖에 적는다」
+// 는 한 가지 일만 한다 — 루프의 속을 몰라도 되고, 그래서 따로 잴 수 있다.
+
+import { openSync, writeSync, closeSync } from 'node:fs';
+import { resolve, relative, isAbsolute, sep } from 'node:path';
+
+/*
+ * ── 바뀐 파일 ─────────────────────────────────────────────────────────
+ *
+ * 루프는 턴이 끝날 때 손댄 파일을 `done` · `stuck` · `limit` 에 실어 준다(agent/loop.js 의 마무리).
+ * 그런데 끊기거나(aborted) 터진(error) 턴은 그 목록 없이 끝난다 — 스크립트가 제일 알고 싶은 것이
+ * 「반쯤 하다 멈췄는데 무엇을 건드렸나」 인데. 그래서 도구 사건마다 루프와 같은 세 칸을 보고 모은다.
+ * 끝 사건이 준 목록도 합친다 — 하위 작업이 바꾼 것은 거기에만 온다.
+ *
+ * 작업 폴더 기준 경로로, 슬래시로 적는다. 스크립트는 `jq -r '.files[]' | xargs git add` 처럼 쓴다 —
+ * 윈도우 역슬래시나 절대 경로가 섞이면 그 한 줄이 운영체제마다 달라진다. 폴더 밖은 절대 경로 그대로 둔다.
+ */
+export function 바뀐파일모음(root) {
+  const 모음 = new Set();
+  const 담기 = (p) => {
+    if (typeof p !== 'string' || !p) return;
+    const 온경로 = resolve(root, p);
+    const 상대 = relative(root, 온경로);
+    const 밖인가 = !상대 || 상대.startsWith('..') || isAbsolute(상대);
+    모음.add((밖인가 ? 온경로 : 상대).split(sep).join('/'));
+  };
+  return {
+    사건(ev) {
+      if (!ev || typeof ev !== 'object') return;
+      if (ev.type === 'tool' && ev.result && !ev.result.error) {
+        const r = ev.result;
+        담기(r.changed);
+        for (const f of r.여럿 ?? []) if (f?.ok) 담기(f.path);
+        for (const f of r.바뀐것들 ?? []) 담기(f);
+      }
+      for (const f of Array.isArray(ev.files) ? ev.files : []) 담기(f?.path);
+    },
+    목록: () => [...모음].sort(),
+  };
+}
+
+/*
+ * ── 사건 흐름 (--events <파일>) ───────────────────────────────────────
+ *
+ * 끝날 때 한 덩이만 나오면 오래 도는 잡을 지켜볼 수가 없다. 사건을 한 줄에 하나씩 JSON 으로 흘린다 —
+ * `tail -f` 로 보고, 끝나면 `jq` 로 훑는다. 마지막 줄은 `--json` 과 같은 결과 한 덩이다(type: 'result').
+ *
+ * 글자 조각(content · thinking)은 안 싣는다. 흘려받는 서버면 한 턴에 수천 줄이 되고, 답은 마지막 줄에
+ * 이미 통째로 있다. 긴 글은 잘라 싣는다 — 큰 파일을 읽은 도구 결과 하나가 한 줄에 통째로 실리면
+ * 사건 파일이 읽은 파일들의 사본이 된다.
+ *
+ * `type` 칸은 약속이다. 나머지 칸은 판마다 늘 수 있다 — 루프가 화면에 주는 것을 그대로 옮긴다.
+ */
+export const 사건글한도 = 4000;
+const 안싣는것 = new Set(['content', 'thinking']);
+
+export function 사건줄(ev, 흐른ms, { 통째 = false } = {}) {
+  const 자르기 = (_k, v) => (typeof v === 'string' && v.length > 사건글한도
+    ? `${v.slice(0, 사건글한도)}…(+${v.length - 사건글한도})`
+    : v);
+  try {
+    return JSON.stringify({ ...ev, elapsed: 흐른ms }, 통째 ? undefined : 자르기);
+  } catch {
+    // 제자리를 도는 값 같은 것. 무엇이 있었는지는 남긴다 — 통째로 빼면 그 자리가 비어 보인다.
+    return JSON.stringify({ type: String(ev?.type ?? '?'), elapsed: 흐른ms, 못적음: true });
+  }
+}
+
+/**
+ * 사건 파일을 연다. 못 열면 던진다 — 부르는 쪽이 일을 시작하기 **전에** 선다.
+ *
+ * 다 돌고 나서 「사건 파일을 못 열었습니다」 면 지켜보려던 사람은 아무것도 못 봤다. 도중에 못 쓰게
+ * 되면(디스크 가득) 한 번 알리고 그만 적는다 — 기록을 남기려다 일을 죽이면 본말이 뒤집힌다.
+ */
+export function 사건적기열기(경로, { 시작 = Date.now(), 알림 = () => {} } = {}) {
+  const fd = openSync(경로, 'w');
+  let 막힘 = false;
+  let 닫힘 = false;
+  const 한줄 = (글) => {
+    if (막힘 || 닫힘) return;
+    try { writeSync(fd, `${글}\n`); }
+    catch (err) { 막힘 = true; 알림(err?.code ?? err?.message ?? String(err)); }
+  };
+  return {
+    적기(ev) {
+      if (!ev || 안싣는것.has(ev.type)) return;
+      한줄(사건줄(ev, Date.now() - 시작));
+    },
+    // 결과 줄은 자르지 않는다 — 답이 거기에 통째로 있다는 것이 위 약속이다(--json 과 같은 덩이).
+    결과(r) { 한줄(사건줄({ type: 'result', ...r }, Date.now() - 시작, { 통째: true })); },
+    닫기() {
+      if (닫힘) return;
+      닫힘 = true;
+      try { closeSync(fd); } catch { /* 이미 닫혔으면 그만 */ }
+    },
+  };
+}

package/src/safety/authcmd.js

@@ -69,14 +69,29 @@ let 마지막명령줄 = null;
  */
 export function 마지막명령() { return 마지막명령줄; }
 
-let 받은것 = null;      // { token, headers, 만료, 언제 } — 메모리에만. 파일로 안 나간다.
-let 물어본것 = null;    // 이번 판에 사람이 뭐라고 답했나 (true/false)
+/*
+ * ── 받아 둔 것과 승인은 **명령마다** 따로 든다 (2.1.3) ───────────────────────
+ *
+ * 둘 다 모듈에 하나뿐이었다. 한 판에 연결이 하나면 그래도 맞다 — 그런데 `/consult` 와 모델을 고른
+ * Task 는 **다른 프로필의 연결**을 연다(agent/models.js). 그 연결이 제 명령으로 열쇠를 청하면 들고
+ * 있던 앞 프로필의 토큰이 먼저 돌아와, A 게이트웨이의 토큰이 B 게이트웨이로 나갔다. B 의 명령은
+ * 묻는 자리에 닿지도 않았고, 닿았어도 A 를 허락한 답이 B 의 답으로 읽혔다.
+ *
+ * 열쇠는 명령줄로 가른다 — 같은 명령이면 같은 열쇠다(받기설정 이 정책·설정 어느 쪽이든 명령을 준다).
+ */
+const 받은것들 = new Map();    // 명령 → { token, headers, 만료, 언제 } — 메모리에만. 파일로 안 나간다.
+const 물어본것들 = new Map();  // 명령 → 이번 판에 사람이 뭐라고 답했나 (true/false)
+let 마지막받은 = null;        // 화면이 연결을 안 줄 때 보여 줄 것
 
 /** 검사와 `/model` 갈아타기가 부른다. */
-export function 잊기() { 받은것 = null; 물어본것 = null; 마지막명령줄 = null; }
+export function 잊기() { 받은것들.clear(); 물어본것들.clear(); 마지막받은 = null; 마지막명령줄 = null; }
 
-/** 지금 들고 있는 것. 없으면 null. 화면·심사서가 **토큰 없이** 상태만 볼 때. */
-export function 지금상태() {
+/**
+ * 지금 들고 있는 것. 없으면 null. 화면·심사서가 **토큰 없이** 상태만 볼 때.
+ * @param {object} [설정] 받기설정() 이 준 것 — 주면 그 명령의 것을, 안 주면 마지막에 받은 것을.
+ */
+export function 지금상태(설정 = null) {
+  const 받은것 = 설정 ? 받은것들.get(설정.명령) : 마지막받은;
   if (!받은것) return null;
   return { 있음: true, 만료: 받은것.만료, 남은초: Math.max(0, Math.round((받은것.만료 - Date.now()) / 1000)) };
 }
@@ -251,16 +266,45 @@ export async function 한번받기(설정, { 기다림 = 기본기다림, signal
         // 잘못된 것이고, 열어 두면 그 자리에서 영영 멈춘다.
         stdio: ['ignore', 'pipe', 'pipe'],
         windowsHide: true,
+        // 유닉스는 셸을 새 무리의 머리로 띄운다 — 끊을 때 무리째 거두게(거두기). 윈도우에서 detached 는 새 콘솔
+        // 창이라 안 쓴다(그쪽은 taskkill /T 가 나무를 따라간다). tools/index.js 의 Bash 와 같은 짝이다.
+        detached: process.platform !== 'win32',
       });
     } catch (err) {
       return done({ ok: false, 왜: `명령을 못 띄웠습니다 (${err.message})`, 보인것: '' });
     }
     const 마치기 = (것) => { if (!끝났나) { 끝났나 = true; clearTimeout(시계); 끊기해제(); done(것); } };
+    /*
+     * ── 끊을 때는 **나무째** 거두고 우리 파이프를 놓는다 (2.1.3) ────────────────
+     *
+     * 명령은 셸을 거쳐 뜬다(tools/shell.js 의 셸명령). kill 은 셸만 죽이고, 윈도우에서는 그 밑의 진짜
+     * 로그인 도구(손자)가 살아 stdout 을 물고 있었다. 그러면 「못 받았습니다」 뒤에도 그 파이프가 deel 을
+     * 붙들어, 할 일을 다 마친 `deel run` 이 손자가 끝날 때까지 안 끝났다. 윈도우는 셸이 살아 있을 때
+     * taskkill /T 로 나무를 따라가야 하므로 kill 은 그 뒤에 한다(backend/mcp.js 닫기 와 같은 차례).
+     * 유닉스도 같았다 — 셸만 죽고 손자가 남았다(리눅스 CI 가 잡음). 무리(-pid)째 끊는다.
+     */
+    const 거두기 = () => {
+      const 죽이기 = () => {
+        if (process.platform !== 'win32' && kid.pid) {
+          try { process.kill(-kid.pid, 'SIGKILL'); return; } catch { /* 무리가 없다 — 셸만 */ }
+        }
+        try { kid.kill('SIGKILL'); } catch { /* 이미 죽었으면 그만 */ }
+      };
+      if (process.platform === 'win32' && kid.pid && kid.exitCode === null) {
+        try {
+          const 나무 = spawn('taskkill', ['/pid', String(kid.pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore' });
+          나무.once('error', 죽이기);
+          나무.once('exit', 죽이기);
+          나무.unref();
+        } catch { 죽이기(); }
+      } else 죽이기();
+      try { kid.stdout?.destroy(); kid.stderr?.destroy(); } catch { /* 이미 닫힘 */ }
+    };
     const 시계 = setTimeout(() => {
-      try { kid.kill('SIGKILL'); } catch { /* 이미 죽었으면 그만 */ }
+      거두기();
       마치기({ ok: false, 왜: `${Math.round(기다림 / 1000)}초를 기다렸는데 안 끝났습니다`, 보인것: '' });
     }, 기다림);
-    const 끊기 = () => { try { kid.kill('SIGKILL'); } catch { /* 그만 */ } 마치기({ ok: false, 왜: '중단했습니다', 보인것: '' }); };
+    const 끊기 = () => { 거두기(); 마치기({ ok: false, 왜: '중단했습니다', 보인것: '' }); };
     const 끊기해제 = () => signal?.removeEventListener?.('abort', 끊기);
     if (signal?.aborted) return 끊기();
     signal?.addEventListener?.('abort', 끊기, { once: true });
@@ -280,8 +324,8 @@ export async function 한번받기(설정, { 기다림 = 기본기다림, signal
     kid.stdout.on('data', (b) => {
       if (끝났나) return;
       if (나온것.length + b.length > 받을상한) {
-        try { kid.kill('SIGKILL'); } catch { /* 이미 죽었으면 그만 */ }
-        try { kid.stdout.destroy(); kid.stderr.destroy(); } catch { /* 이미 닫힘 */ }
+        // 나무째 거두고 파이프를 놓는다 (위 거두기) — 셸 아래 손자가 계속 쓰고 있어도 EPIPE 를 맞고 멈춘다.
+        거두기();
         // 먼저 자르고 가린다 — 1MB 짜리 한 줄을 통째로 가리기 에 넣으면 그 무늬들이
         // 몇 분을 돈다(처음 고칠 때 검사가 여기서 멈춰 섰다).
         const 첫줄 = 가리기(나온것.slice(0, 400).trim().split('\n')[0] ?? '', {}).글.slice(0, 120);
@@ -324,7 +368,8 @@ export async function 한번받기(설정, { 기다림 = 기본기다림, signal
 export async function 열쇠(설정, { 다시 = false, 물어보기 = null, signal = null, 알림 = null, 기다림 = 기본기다림 } = {}) {
   if (!설정) return { ok: false, 왜: '열쇠받기가 설정되어 있지 않습니다' };
 
-  if (다시) 받은것 = null;
+  if (다시) 받은것들.delete(설정.명령);
+  const 받은것 = 받은것들.get(설정.명령);
   if (받은것 && 받은것.만료 - 미리 > Date.now()) {
     return { ok: true, token: 받은것.token, headers: 받은것.headers, 만료: 받은것.만료, 그대로: true };
   }
@@ -356,19 +401,22 @@ export async function 열쇠(설정, { 다시 = false, 물어보기 = null, sign
    * 거기서까지 막으면 사람이 승인을 했는데도 열쇠가 안 붙는다.
    */
   if (설정.곳 !== '정책') {
-    if (물어본것 === false) return { ok: false, 왜: '이 판에서는 안 부르기로 했습니다' };
-    if (물어본것 === null) {
+    const 답 = 물어본것들.get(설정.명령);
+    if (답 === false) return { ok: false, 왜: '이 판에서는 안 부르기로 했습니다' };
+    if (답 === undefined) {
       if (typeof 물어보기 !== 'function') {
         return { ok: false, 왜: '이 명령을 띄워도 되는지 물어볼 자리가 없습니다 — 승인 없이는 안 띄웁니다' };
       }
-      물어본것 = !!(await 물어보기(설정));
-      if (!물어본것) return { ok: false, 왜: '이 판에서는 안 부르기로 했습니다' };
+      const 허락 = !!(await 물어보기(설정));
+      물어본것들.set(설정.명령, 허락);
+      if (!허락) return { ok: false, 왜: '이 판에서는 안 부르기로 했습니다' };
     }
   }
 
   const r = await 한번받기(설정, { signal, 알림, 기다림 });
   if (!r.ok) return r;
-  받은것 = { token: r.token, headers: r.headers, 만료: r.만료, 언제: Date.now() };
+  마지막받은 = { token: r.token, headers: r.headers, 만료: r.만료, 언제: Date.now() };
+  받은것들.set(설정.명령, 마지막받은);
   return { ok: true, token: r.token, headers: r.headers, 만료: r.만료, ms: r.ms, 그대로: false };
 }
 
@@ -380,7 +428,10 @@ export async function 열쇠(설정, { 다시 = false, 물어보기 = null, sign
  */
 export function 가림(글) {
   const 것들 = [];
-  if (받은것?.token) 것들.push(받은것.token);
-  for (const v of Object.values(받은것?.headers ?? {})) if (v) 것들.push(String(v));
+  // 들고 있는 것 **전부**를 가린다 — 명령마다 따로 들게 된 뒤로(위 받은것들) 하나만 가리면 다른 연결의 토큰이 샌다.
+  for (const 받은것 of 받은것들.values()) {
+    if (받은것?.token) 것들.push(받은것.token);
+    for (const v of Object.values(받은것?.headers ?? {})) if (v) 것들.push(String(v));
+  }
   return 가리기(String(글 ?? ''), { 열쇠들: 것들 }).글;
 }