deel-local-cli 1.8.0 → 1.12.0

package/src/oneshot.js

@@ -1,471 +1,620 @@
-// 한 번만 돌고 끝내는 비대화 모드.  deel run "..."  ·  echo "..." | deel run
-//
-// 왜 따로 냈는가:
-//   사내에 넣고 나면 곧바로 "배치에서 부르고 싶다" 는 말이 나온다. 야간 작업에
-//   끼워 검사를 돌리거나, 파일 목록을 훑어 한 건씩 시키는 식이다.
-//   그런데 대화 화면(repl.js)은 사람이 앞에 앉아 있다는 것을 전제로 만들었다 —
-//   줄을 기다리고, 승인을 물어보고, 엑셀 암호를 물어본다. 그 자리에 사람이
-//   없으면 프로그램은 터지지도 않고 그냥 서 있는다. 배치 잡의 시간 제한까지
-//   서 있다가 죽고, 로그에는 아무 단서도 안 남는다.
-//
-//   그래서 '묻는 자리' 를 전부 없앤 길을 따로 낸다. 에이전트 루프는 그대로 쓴다 —
-//   여기서 루프를 다시 짜면 두 벌이 되고, 언젠가 한쪽만 고쳐진다.
-import { c, mark, clip } from './ui/ansi.js';
-import { 규칙모으기, 정책읽기 } from './safety/policy.js';
-import { 받기설정 } from './safety/authcmd.js';
-import { run } from './agent/loop.js';
-import { Session } from './agent/session.js';
-import { makeScope } from './safety/guard.js';
-import { 모두끄기 as 언어서버다끄기 } from './lsp/client.js';
-import { History } from './safety/undo.js';
-import { Audit } from './safety/audit.js';
-import { activeProfile, load, resolveKey, 잠금소식 } from './config.js';
-import { 말 as 옮긴말 } from './i18n/index.js';
-import { 알림채움 } from './backend/retry.js';
-import { discover } from './skills/discover.js';
-import { allowEndpoint, setOffline } from './safety/network.js';
-import { 지금모드, 바깥인가, 나갈수있나 } from './safety/runmode.js';
-import { 주소가리기 } from './safety/secrets.js';
-import { probeCtx, 기본값 as CTX_DEFAULT } from './backend/ctxsize.js';
-import { route } from './agent/route.js';
-import { get as getWork } from './agent/modes.js';
-import { 모두끝내기 as 일감모두끝내기, 일감인자 } from './tools/jobs.js';
-
-/**
- * 종료코드.
- *
- * 스크립트는 화면 글이 아니라 이 숫자만 본다. 그래서 '끝났다' 와 '끝난 척했다'
- * 를 반드시 갈라 놔야 한다 — 걸음 수 상한에 걸려 멈춘 것을 0 으로 돌려주면
- * 야간 배치가 아무 일도 안 하고 초록불을 켠다. 그게 제일 나쁜 결말이다.
- */
-export const EXIT = {
-  done: 0,      // 끝까지 답했다
-  error: 1,     // 오류로 끝났다 (연결 없음 · 시킬 말 없음 · 모델 오류)
-  limit: 2,     // 도구 호출 걸음 수 상한에 닿았다
-  stuck: 3,     // 같은 자리에서 헛돌아 스스로 멈췄다
-  aborted: 4,   // 도중에 끊겼다 (Ctrl+C)
-};
-
-/**
- * 표준입력에 실려 온 말을 통째로 읽는다.
- *
- * 터미널이면 안 읽는다. 사람이 앉아 있는 자리에서 읽으려 들면 아무도 안 치는
- * 입력을 영영 기다린다 — 그게 바로 이 모드가 없애려는 상황이다.
- */
-async function 표준입력읽기() {
-  if (process.stdin.isTTY) return '';
-  const 조각 = [];
-  try {
-    for await (const b of process.stdin) 조각.push(b);
-  } catch { /* 파이프가 먼저 닫히면 읽은 데까지만 쓴다 */ }
-  return Buffer.concat(조각).toString('utf8');
-}
-
-// 도구 한 줄 요약. 화면 그림이 아니라 로그에 남을 글이라 색을 아낀다.
-function 도구줄(name, args) {
-  const a = args ?? {};
-  const 첫 = a.file_path ?? a.pattern ?? a.path ?? a.url ?? a.name ?? a.purpose ?? a.목적 ??
-    (a.command ? String(a.command).replace(/\s+/g, ' ') : null) ??
-    // 뒤에서 도는 명령. 번호가 곧 그 일감의 이름이라, 이게 없으면 기록에
-    // `Jobs()` 만 여러 줄 남아 나중에 무엇을 본 것인지 알 수 없다.
-    // 이름 고르기는 jobs.js 한 군데에만 둔다 (영문 이름도 받는다).
-    (() => { const g = 일감인자(a); return g.번호 != null ? `${g.번호}번${g.끝내기 ? ' · 끝내기' : ''}` : null; })() ??
-    // 한 번에 여러 파일을 쓴 경우. 기록에 빈 괄호만 남으면 나중에 이 줄로는
-    // 무엇을 만들었는지 알 수 없다 — `deel run` 의 출력은 곧 근거로 쓰인다.
-    (Array.isArray(a.files) && a.files.length
-      ? `${a.files[0]?.file_path ?? '?'}${a.files.length > 1 ? ` 외 ${a.files.length - 1}개` : ''}`
-      : null) ??
-    (Array.isArray(a.edits) && a.edits.length
-      ? `${a.edits[0]?.file_path ?? '?'}${a.edits.length > 1 ? ` 외 ${a.edits.length - 1}군데` : ''}`
-      : null) ??
-    (Array.isArray(a.paths) && a.paths.length ? `${a.paths.length}개` : null) ??
-    (Array.isArray(a.todos) ? `${a.todos.length}건` : '');
-  const 안 = clip(String(첫 ?? ''), 48);
-  return `${name}${안 ? `(${안})` : ''}`;
-}
-
-/**
- * 한 턴만 돌린다.
- *
- * @param {object} opts
- *   prompt   시킬 말. 없으면 표준입력에서 읽는다
- *   root/mode/work/think/effort/ctx/offline  대화 시작 옵션과 같은 뜻
- *   yes      승인이 필요한 것도 그냥 실행 (기본은 거부)
- *   json     결과를 JSON 한 덩이로
- *   quiet    도구가 무엇을 했는지를 안 적는다 (오류는 그래도 적는다)
- * @returns {Promise<number>} 종료코드
- */
-export async function runOnce(opts = {}) {
-  const json = opts.json === true;
-  const quiet = opts.quiet === true;
-
-  // 두 갈래로 나눠 쓴다.
-  //   표준출력 — 모델의 마지막 답만. 그래야 > 파일 이나 | grep 이 그대로 먹는다.
-  //   표준오류 — 도구가 무엇을 했는지. 사람이 볼 것이지 넘겨줄 것이 아니다.
-  // 이걸 섞으면 파이프 뒤에 붙은 명령이 도구 기록까지 받아 먹는다.
-  const 삐끗 = (s = '') => process.stderr.write(s + '\n');
-  const 곁 = (s = '') => { if (!quiet) 삐끗(s); };
-
-  const 내놓기 = (r) => {
-    /*
-     * 뒤에서 돌던 명령을 반드시 거둔다.
-     *
-     * 여기가 이 모드의 모든 끝맺음이 지나는 자리다. 배치는 이걸 빠뜨리면
-     * 제일 크게 다친다 — 잡이 끝났다고 표시된 뒤에도 dev 서버가 계속 돌고,
-     * 다음 잡이 같은 포트를 잡으려다 실패한다. 그 원인은 로그 어디에도 없다.
-     */
-    const 껐다 = 일감모두끝내기();
-    if (껐다) 곁(`  ${mark.ok} ${c.gray(`뒤에서 돌던 명령 ${껐다}개를 껐습니다.`)}`);
-    // 고친 뒤 진단 때문에 뒤에서 데워진 언어 서버도 같이 거둔다.
-    // 이건 아무 말 없이 한다 — 사용자가 띄우라고 한 적이 없는 것이라,
-    // 껐다는 말부터 하면 "그건 또 뭐냐" 가 된다.
-    언어서버다끄기().catch(() => {});
-    if (json) process.stdout.write(JSON.stringify(r) + '\n');
-    else if (r.text) process.stdout.write(r.text.endsWith('\n') ? r.text : r.text + '\n');
-    return r.code;
-  };
-  // 시작도 못 한 실패. --quiet 여도 이유는 반드시 적는다 — 스크립트를 고칠 사람이 볼 유일한 글이다.
-  const 못함 = (reason, message) => {
-    삐끗(`  ${c.red('✗')} ${message}`);
-    return 내놓기({
-      ok: false, reason, code: EXIT.error, text: '', why: message,
-      tools: 0, steps: 0, usage: { in: 0, out: 0, calls: 0, ms: 0, retries: 0 }, ms: 0,
-    });
-  };
-
-  // ── 시킬 말 ───────────────────────────────────────────────────────────
-  // 인자로 준 것이 먼저다. 없을 때만 표준입력을 읽는다 —
-  // 둘 다 있을 때 무엇이 이기는지가 헷갈리면 스크립트가 조용히 엉뚱한 일을 한다.
-  let 시킬말 = String(opts.prompt ?? '').trim();
-  if (!시킬말) 시킬말 = (await 표준입력읽기()).trim();
-  if (!시킬말) {
-    return 못함('no-prompt', '무엇을 시킬지 적어 주세요 — deel run "..." 또는 echo "..." | deel run');
-  }
-
-  const cfg = load();
-  const prof = activeProfile(cfg);
-  if (!prof) return 못함('no-config', '저장된 연결이 없습니다. deel setup 을 먼저 실행하세요.');
-
-  // 열쇠를 방금 잠갔으면 알린다. 여기서는 stdout 을 안 쓴다 —
-  // 배치로 부르는 쪽이 stdout 을 JSON 으로 읽고 있을 수 있다.
-  const 잠금 = 잠금소식();
-  if (잠금) { try { process.stderr.write(`  ${잠금}\n`); } catch { /* 못 써도 그만 */ } }
-
-  const root = opts.root ? String(opts.root) : process.cwd();
-  const conn = {
-    kind: prof.kind, base: prof.baseUrl, auth: prof.auth,
-    key: resolveKey(prof), model: prof.model,
-    /*
-     * 열쇠를 갖고 있는 대신 **받아 오는** 설정 (safety/authcmd.js).
-     *
-     * 여기서는 설정만 싣는다. 명령은 요청 직전에 부른다 — 켤 때 한 번
-     * 받아 두면 한 시간짜리 토큰이 세 시간짜리 대화 한복판에서 죽고,
-     * 그 401 은 화면에서 「열쇠가 틀렸다」 와 구별이 안 된다.
-     */
-    열쇠받기: 받기설정(prof, { 정책값: 정책읽기().값 }),
-    ctx: opts.ctx ?? prof.ctx ?? CTX_DEFAULT,
-    // 답 길이 상한 — deel --max-tokens 32k 로 높일 수 있다(대화 화면의 /out 과 같은 값).
-    maxTokens: opts.maxTokens ?? prof.maxTokens ?? null,
-    streaming: prof.streaming ?? false,
-    tools: prof.tools ?? false, json: prof.json ?? false, think: prof.think ?? false,
-    vision: prof.vision ?? false,
-  };
-
-  /*
-   * 자물쇠는 대화 화면과 똑같이 건다. 비대화라고 느슨해질 이유가 없다 —
-   * 오히려 배치는 아무도 안 보는 자리라 더 단단해야 한다.
-   *
-   * 다른 것은 딱 하나, **물을 수가 없다**는 것이다. 파이프 뒤에는 답할 사람이
-   * 없다. 그래서 여기서는 묻는 대신 멈추고, 무엇을 붙이면 되는지를 말한다.
-   * 조용히 나가 버리면 스크립트가 바깥으로 나가고 있는 줄 아무도 모른다.
-   */
-  const 바깥연결 = 바깥인가(conn.base);
-  const 실행모드 = 지금모드({
-    online: opts.online === true,
-    // 관리 정책이 offline 을 못박아 뒀으면 옵션과 상관없이 켠다 (safety/policy.js).
-    offline: !!(opts.offline ?? prof.offline ?? cfg?.offline),
-  });
-  const 나감 = 나갈수있나(실행모드, { 바깥: 바깥연결, 허가: prof.online === true });
-  if (나감.물어볼까) {
-    const 어디 = (() => { try { return new URL(conn.base).host; } catch { return conn.base; } })();
-    return 못함('needs-online',
-      `이 연결은 이 컴퓨터 밖으로 나갑니다 (${주소가리기(어디)}). 여기서는 물어볼 수 없습니다.\n`
-      + '    나가도 된다면 --online 을 붙이거나, 대화 화면(deel)에서 한 번 허락해 두세요.\n'
-      + '    이 컴퓨터 안의 모델을 쓰려면 deel scan --save 로 붙이세요.');
-  }
-  allowEndpoint(conn.base);
-  if (실행모드.허가무시) setOffline(true);
-
-  const session = new Session(conn, {
-    root,
-    mode: opts.mode ?? 'auto',
-    work: opts.work ?? null,
-    think: opts.think ?? 'medium',
-    effort: opts.effort ?? 'save',
-    maxSteps: opts.maxSteps ?? null,   // null 이면 작업 모드가 정한다
-  });
-  // 지금 어느 실행 모드인가. 화면이 첫 줄에 이걸 그린다(ui/status.js).
-  // session 에 실어 두는 까닭은, 대화 도중 /model 로 옮겨도 같은 자리를 보게 하려는 것이다.
-  session.실행모드 = 실행모드;
-
-  const found = discover(root);
-  session.skills = found.skills;
-  session.commands = found.commands;
-  session.plugins = found.plugins;
-
-  // ── 물어보는 자리를 전부 막는다 ────────────────────────────────────────
-  //
-  // 여기가 이 파일의 핵심이다. 물어보는 함수 하나라도 기다리게 두면 그것 하나로
-  // 배치가 선다. 그래서 세 자리 모두 '기다리지 않고 바로 답을 내는' 함수로 채운다.
-  //
-  // 승인은 기본이 거부다. 반대로 하면 안 된다 — 아무도 안 보는 자리에서
-  // 되돌릴 수 없는 명령이 조용히 돌아가는 것이 이 프로그램이 제일 피하려는 일이다.
-  // 정말 맡기고 싶은 사람은 --yes 로 그 뜻을 명시한다.
-  const 승인필요 = session.mode !== 'auto';
-  const 자동승인 = opts.yes === true;
-  const ctx = {
-    scope: makeScope(root),
-    // 도구가 한 번에 돌려줄 양을 이 값에서 뽑는다 (agent/budget.js).
-    // /model 로 갈아타면 conn 이 통째로 바뀌므로 그때마다 다시 읽는다.
-    get 모델컨텍스트() { return conn.ctx ?? null; },
-    // 이 모델이 그림을 볼 수 있나 — Read 가 그림을 만났을 때 무슨 말을 할지가 여기서 갈린다.
-    get 눈있나() { return !!conn.vision; },
-    // 적어 둔 허락·금지 규칙 (safety/policy.js). 승인 모드보다 먼저 본다.
-    규칙들: 규칙모으기(cfg),
-    history: new History(root),
-    audit: new Audit(root),
-    seen: new Set(),
-    skills: found.skills,
-    loadedSkills: new Set(),
-    // 고친 뒤 진단을 볼지 (lsp/diag.js). 아래 내놓기() 에서 반드시 거둔다 —
-    // 안 거두면 배치가 끝나고도 언어 서버가 폴더를 물고 남는다.
-    lsp: { 켬: true },
-    // 되물을 사람이 없으니 기본값을 그대로 돌려준다.
-    ask: async (_label, o = {}) => o?.def ?? '',
-    // 엑셀 암호를 여기서 기다리면 그대로 선다. 없다고 바로 답한다 —
-    // 도구는 null 을 받으면 '암호가 걸려 못 읽었다' 고 정확히 말한다.
-    askPassword: async () => null,
-    confirm: async (name, args) => {
-      const 무엇 = 도구줄(name, args);
-      if (자동승인) {
-        곁(`  ${c.yellow('!')} ${c.gray(`--yes 라서 묻지 않고 실행합니다 — ${무엇}`)}`);
-        return true;
-      }
-      곁(`  ${c.yellow('⊘')} ${c.gray(`승인이 필요해 거부했습니다 (물어볼 사람이 없습니다) — ${무엇}`)}`);
-      return false;
-    },
-  };
-
-  // 거부당할 것을 모델에게 미리 알려 준다.
-  //
-  // 거부만 하고 이유를 안 알리면 모델은 같은 호출을 몇 번이고 다시 한다.
-  // 사람이 '안 돼요' 라고 한 줄 알고, 다시 물어보면 이번엔 된다고 믿는다.
-  // 그러면 걸음 수만 다 쓰고 아무것도 못 한 채 끝난다.
-  const 보낼글 = (승인필요 && !자동승인)
-    ? `${시킬말}\n\n(비대화 모드다. 사람이 없어 승인을 물어볼 수 없고, 승인이 필요한 도구 호출은 자동으로 거부된다.`
-      + ' 승인 없이 되는 방법을 골라라. 그래도 안 되면 무엇이 막혔는지 말로 알려라.)'
-    : 시킬말;
-
-  // ── 컨텍스트 길이 ─────────────────────────────────────────────────────
-  //
-  // 대화 화면과 같은 이유로 서버에 물어본다. 저장된 값을 믿으면 조용히 작아진다.
-  // 다만 알아낸 값을 설정 파일에 도로 적지는 않는다 — 배치는 같은 명령을 여러 개
-  // 동시에 띄우는 자리라, 그때마다 config.json 을 덮어쓰면 서로 밟는다.
-  // 이번 한 번만 쓰고 버린다.
-  if (opts.ctx == null) {
-    try {
-      const r = await probeCtx(conn, { timeout: 6000 });
-      if (r?.value) {
-        const 전 = conn.ctx;
-        conn.ctx = r.value;
-        if (전 !== r.value) {
-          곁(`  ${mark.ok} ${c.gray(`컨텍스트를 ${전.toLocaleString()} → ${r.value.toLocaleString()} 로 맞췄습니다 (${r.source ?? '서버'}에서 읽음)`)}`);
-        }
-      }
-    } catch { /* 못 물어보면 설정값 그대로 간다. 여기서 멈출 일은 아니다 */ }
-  }
-
-  // 종합 모드면 이 한마디를 보고 알맞은 작업 모드로 옮긴다. 대화 화면과 같다.
-  session.routed = null;
-  if (session.work === 'auto') {
-    const 골라진 = route(시킬말);
-    if (골라진.mode) {
-      session.routed = 골라진.mode;
-      const w = getWork(골라진.mode);
-      곁(`  ${c.hcyan(w.glyph)} ${c.gray(`${w.name} (${w.en}) — 말 속에 ${골라진.why} 가 있어서`)}`);
-    }
-  }
-
-  // ── 한 턴 ─────────────────────────────────────────────────────────────
-  const turn = new AbortController();
-  const 끊김 = () => { if (!turn.signal.aborted) turn.abort(); };
-  process.on('SIGINT', 끊김);
-
-  const t0 = Date.now();
-  let reason = 'done';
-  let why = '';
-  let tools = 0;
-  let steps = 0;
-  let 이번단계글 = '';   // 지금 단계에서 모델이 흘린 글. 단계가 바뀌면 비운다
-  let 답 = null;
-
-  try {
-    // 하위 작업 안쪽에서 온 이벤트는 그 겹만큼 들여 쓴다.
-    const 안쪽 = (ev) => (ev.depth ? '  '.repeat(ev.depth) : '');
-
-    for await (const ev of run(session, ctx, 보낼글, { signal: turn.signal })) {
-      switch (ev.type) {
-        case 'stage':
-          steps = ev.step;
-          이번단계글 = '';
-          break;
-
-        // 중간 단계의 말은 표준출력에 안 싣는다. "이제 파일을 읽어보겠습니다" 까지
-        // 딸려 나가면 파이프 뒤에서 답만 골라 쓸 수가 없다.
-        case 'content':
-          이번단계글 += ev.text;
-          break;
-
-        case 'tool': {
-          tools++;
-          /*
-           * 실패는 실패로 보여야 한다.
-           *
-           * 전에는 `error` 만 빨갛게 칠했다. 그런데 탈이 났는데 error 는 없는
-           * 도구가 있다 — Bash 는 종료코드 3 을, Verify 는 `탈 2개` 를 요약에
-           * 담아 돌려준다. 그것들이 회색으로 찍히면, 나중에 이 기록을 읽는
-           * 사람 눈에는 성공과 구별되지 않는다. `deel run` 의 출력은 곧
-           * 근거로 쓰이는 물건이라 그 구별이 사라지면 안 된다.
-           */
-          const 결과 = ev.result?.error
-            ? c.red(clip(String(ev.result.error).split('\n')[0], 70))
-            : ev.result?.failed
-              ? c.yellow(clip(ev.result?.summary ?? '실패', 70))
-              : c.gray(clip(ev.result?.summary ?? '완료', 70));
-          // 하위 작업 안쪽이면 한 단 들여 그린다. 안 그러면 하위가 만진 파일이
-          // 부모가 만진 것과 똑같이 찍혀서, 기록으로 읽을 때 구분이 안 된다.
-          곁(`${안쪽(ev)}  ${c.cyan('⏺')} ${c.bold(도구줄(ev.name, ev.args))}  ${결과}`);
-          /*
-           * 비밀이 지나갔으면 여기서도 적는다.
-           *
-           * 배치는 아무도 안 보는 자리이고, 이 기록이 나중에 근거가 된다.
-           * "열쇠가 대화에 들어갔다" 를 그 기록에서 빼면 안 된다 — 나중에
-           * 사고가 났을 때 언제 새어 나갔는지 알 방법이 없어진다.
-           */
-          if (ev.비밀) {
-            삐끗(`${안쪽(ev)}    ${ev.비밀.가렸나 ? c.gray('⊘') : c.yellow('!')} `
-              + `${c.gray(`${ev.비밀.말}${ev.비밀.가렸나 ? ' — 모델에 가려서 보냈습니다' : ' — 파일 내용은 가리지 않습니다'}`)}`);
-          }
-          break;
-        }
-
-        /*
-         * 하위 작업의 여닫는 줄.
-         *
-         * `deel run` 은 잡·CI 에서 돌고 그 기록이 나중에 근거가 된다. 하위가
-         * 무엇을 맡았고 끝냈는지 안 남으면, 파일 넷이 어디서 나왔는지를
-         * 기록만 보고는 알 수 없다.
-         */
-        case 'task_start':
-          곁(`${안쪽(ev)}  ${c.magenta('⌥')} ${c.bold('하위 작업')} ${clip(ev.목적, 60)}`
-            + `  ${c.gray(`따로 떨어진 대화 · 최대 ${ev.steps}걸음`)}`);
-          break;
-
-        case 'task_done': {
-          const 끝 = ev.끝 ?? {};
-          const 잘됨 = 끝.type === 'done';
-          const 셈 = (끝.files ?? []).filter((f) => !f.dir && !f.missing).length;
-          곁(`${안쪽(ev)}  ${잘됨 ? c.green('✓') : c.yellow('⚠')} ${c.gray('하위 작업')} ${clip(ev.목적, 50)}`
-            + `  ${c.gray(잘됨 ? `끝냄 · 파일 ${셈}개 · ${끝.steps ?? 0}걸음` : `다 못 했습니다 (${끝.type}) · ${끝.steps ?? 0}걸음`)}`);
-          break;
-        }
-
-        case 'retry':
-          곁(`  ${c.yellow('↻')} ${c.gray(`${ev.why} — 상한을 ${ev.from} → ${ev.to} 로 올려 다시 부릅니다`)}`);
-          break;
-
-        // 서버가 잠깐 막아서 기다렸다 다시 부른 자리 (backend/retry.js).
-        // 배치 기록에 남아야 "그날 밤 왜 12분이 걸렸나" 를 나중에 읽을 수 있다.
-        case 'backoff':
-          곁(`  ${c.yellow('↻')} ${c.gray(옮긴말('loop.backoff', 알림채움(ev)))}`);
-          break;
-
-        case 'folded':
-          곁(`  ${c.cyan('◲')} ${c.gray(`오래된 도구 결과 ${ev.접은것}개를 접었습니다 (${ev.아낀토큰.toLocaleString()} 토큰을 비움)`)}`);
-          break;
-
-        case 'images_folded':
-          곁(`  ${c.cyan('◲')} ${c.gray(`오래된 그림 ${(ev.뺀것들 ?? []).reduce((a3, x) => a3 + x.장수, 0)}장을 뺐습니다`)}`);
-          break;
-
-        case 'compacted':
-          곁(`  ${c.cyan('◱')} ${c.gray(`대화 ${ev.folded}개를 요약으로 접었습니다 (${ev.before.toLocaleString()} → ${ev.after.toLocaleString()} 토큰)`)}`);
-          break;
-
-        case 'compact_failed':
-          곁(`  ${c.gray(`(접지 못했습니다: ${ev.why})`)}`);
-          break;
-
-        case 'limit':
-          reason = 'limit';
-          why = `도구 호출 ${ev.steps}회에서 멈췄습니다. 한 번에 하기엔 큰 일입니다 — 나눠서 시키세요.`;
-          break;
-
-        case 'stuck':
-          reason = 'stuck';
-          why = String(ev.why ?? '같은 자리에서 헛돌고 있어 멈췄습니다');
-          break;
-
-        case 'aborted':
-          reason = 'aborted';
-          why = '중단했습니다';
-          break;
-
-        case 'error':
-          reason = 'error';
-          why = String(ev.text ?? '알 수 없는 오류');
-          break;
-
-        case 'done':
-          reason = 'done';
-          답 = ev.text ?? 이번단계글;
-          break;
-      }
-    }
-  } catch (err) {
-    reason = 'error';
-    why = String(err?.message ?? err);
-  } finally {
-    process.removeListener('SIGINT', 끊김);
-  }
-
-  // 끝까지 못 갔어도 여기까지 나온 말은 내준다. 빈손으로 돌려보내면
-  // 왜 안 됐는지 짐작할 거리조차 없다.
-  if (답 == null) 답 = 이번단계글;
-
-  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.in.toLocaleString()} ↓${session.usage.out.toLocaleString()}`);
-    곁(`  ${c.gray('── ' + 조각.join(' · '))}`);
-  }
-
-  return 내놓기({
-    ok: reason === 'done',
-    reason,
-    code,
-    text: String(답 ?? ''),
-    tools,
-    steps,
-    usage: {
-      in: session.usage.in, out: session.usage.out,
-      calls: session.usage.calls, ms: session.usage.ms,
-      retries: session.usage.retries ?? 0,
-    },
-    model: conn.model,
-    ms: Date.now() - t0,
-    ...(why ? { why } : {}),
-  });
-}
+// 한 번만 돌고 끝내는 비대화 모드.  deel run "..."  ·  echo "..." | deel run
+//
+// 왜 따로 냈는가:
+//   사내에 넣고 나면 곧바로 "배치에서 부르고 싶다" 는 말이 나온다. 야간 작업에
+//   끼워 검사를 돌리거나, 파일 목록을 훑어 한 건씩 시키는 식이다.
+//   그런데 대화 화면(repl.js)은 사람이 앞에 앉아 있다는 것을 전제로 만들었다 —
+//   줄을 기다리고, 승인을 물어보고, 엑셀 암호를 물어본다. 그 자리에 사람이
+//   없으면 프로그램은 터지지도 않고 그냥 서 있는다. 배치 잡의 시간 제한까지
+//   서 있다가 죽고, 로그에는 아무 단서도 안 남는다.
+//
+//   그래서 '묻는 자리' 를 전부 없앤 길을 따로 낸다. 에이전트 루프는 그대로 쓴다 —
+//   여기서 루프를 다시 짜면 두 벌이 되고, 언젠가 한쪽만 고쳐진다.
+import { c, mark, clip } from './ui/ansi.js';
+import { 규칙모으기, 정책읽기 } from './safety/policy.js';
+import { 받기설정 } from './safety/authcmd.js';
+import { run } from './agent/loop.js';
+import { Session } from './agent/session.js';
+import { makeScope } from './safety/guard.js';
+import { 모두끄기 as 언어서버다끄기 } from './lsp/client.js';
+import { History } from './safety/undo.js';
+import { Audit, 열쇠묻기 } from './safety/audit.js';
+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 { discover } from './skills/discover.js';
+import { allowEndpoint, setOffline } from './safety/network.js';
+import { 지금모드, 바깥인가, 나갈수있나 } from './safety/runmode.js';
+import { 주소가리기 } from './safety/secrets.js';
+import { probeCtx, 기본값 as CTX_DEFAULT } from './backend/ctxsize.js';
+import { route } from './agent/route.js';
+import { get as getWork } from './agent/modes.js';
+import { 모두끝내기 as 일감모두끝내기, 일감인자 } from './tools/jobs.js';
+
+/**
+ * 종료코드.
+ *
+ * 스크립트는 화면 글이 아니라 이 숫자만 본다. 그래서 '끝났다' 와 '끝난 척했다'
+ * 를 반드시 갈라 놔야 한다 — 걸음 수 상한에 걸려 멈춘 것을 0 으로 돌려주면
+ * 야간 배치가 아무 일도 안 하고 초록불을 켠다. 그게 제일 나쁜 결말이다.
+ */
+export const EXIT = {
+  done: 0,      // 끝까지 답했다
+  error: 1,     // 오류로 끝났다 (연결 없음 · 시킬 말 없음 · 모델 오류)
+  limit: 2,     // 도구 호출 걸음 수 상한에 닿았다
+  stuck: 3,     // 같은 자리에서 헛돌아 스스로 멈췄다
+  aborted: 4,   // 도중에 끊겼다 (Ctrl+C)
+  /*
+   * 서버가 끝났다는 말을 한 번도 안 주고 답을 멈췄다.
+   *
+   * 여기에 자기 코드가 있어야 한다. 전에는 이걸 아예 안 보고 `done`(0) 으로
+   * 끝냈다. `deel -p` 는 잡·CI 에서 돌고 그 뒤에 스크립트가 붙는데, 반쪽짜리
+   * 답이 0 으로 넘어가면 그 스크립트는 온전한 답으로 알고 그대로 쓴다.
+   * 사람이 나중에 결과를 보고 왜 반쪽인지 되짚을 방법이 없다.
+   */
+  cutoff: 5,
+  /*
+   * 모델이 안 하겠다고 했다 (안전 판정).
+   *
+   * 이것도 자기 코드가 있어야 한다. 거절한 답은 **아무 일도 안 한 답**인데,
+   * 도구 호출이 없다는 것 말고는 짧은 답과 겉모습이 같다. 0 으로 끝내면
+   * 뒤에 붙은 스크립트는 일이 된 줄 알고 그 다음 단계로 넘어간다.
+   *
+   * 오류(1)와도 갈라 둔다. 고칠 자리가 다르기 때문이다 — 오류는 연결이나
+   * 열쇠를 보는 일이고, 거절은 **시킨 말을 바꾸는 일**이다.
+   */
+  refusal: 6,
+};
+
+/**
+ * 표준입력에 실려 온 말을 통째로 읽는다.
+ *
+ * 터미널이면 안 읽는다. 사람이 앉아 있는 자리에서 읽으려 들면 아무도 안 치는
+ * 입력을 영영 기다린다 — 그게 바로 이 모드가 없애려는 상황이다.
+ */
+async function 표준입력읽기() {
+  if (process.stdin.isTTY) return '';
+  const 조각 = [];
+  try {
+    for await (const b of process.stdin) 조각.push(b);
+  } catch { /* 파이프가 먼저 닫히면 읽은 데까지만 쓴다 */ }
+  return Buffer.concat(조각).toString('utf8');
+}
+
+// 도구 한 줄 요약. 화면 그림이 아니라 로그에 남을 글이라 색을 아낀다.
+function 도구줄(name, args) {
+  const a = args ?? {};
+  const 첫 = a.file_path ?? a.pattern ?? a.path ?? a.url ?? a.name ?? a.purpose ?? a.목적 ??
+    (a.command ? String(a.command).replace(/\s+/g, ' ') : null) ??
+    // 뒤에서 도는 명령. 번호가 곧 그 일감의 이름이라, 이게 없으면 기록에
+    // `Jobs()` 만 여러 줄 남아 나중에 무엇을 본 것인지 알 수 없다.
+    // 이름 고르기는 jobs.js 한 군데에만 둔다 (영문 이름도 받는다).
+    (() => { const g = 일감인자(a); return g.번호 != null ? `${g.번호}번${g.끝내기 ? ' · 끝내기' : ''}` : null; })() ??
+    // 한 번에 여러 파일을 쓴 경우. 기록에 빈 괄호만 남으면 나중에 이 줄로는
+    // 무엇을 만들었는지 알 수 없다 — `deel run` 의 출력은 곧 근거로 쓰인다.
+    (Array.isArray(a.files) && a.files.length
+      ? `${a.files[0]?.file_path ?? '?'}${a.files.length > 1 ? ` 외 ${a.files.length - 1}개` : ''}`
+      : null) ??
+    (Array.isArray(a.edits) && a.edits.length
+      ? `${a.edits[0]?.file_path ?? '?'}${a.edits.length > 1 ? ` 외 ${a.edits.length - 1}군데` : ''}`
+      : null) ??
+    (Array.isArray(a.paths) && a.paths.length ? `${a.paths.length}개` : null) ??
+    (Array.isArray(a.todos) ? `${a.todos.length}건` : '');
+  const 안 = clip(String(첫 ?? ''), 48);
+  return `${name}${안 ? `(${안})` : ''}`;
+}
+
+/**
+ * 한 턴만 돌린다.
+ *
+ * @param {object} opts
+ *   prompt   시킬 말. 없으면 표준입력에서 읽는다
+ *   root/mode/work/think/effort/ctx/offline  대화 시작 옵션과 같은 뜻
+ *   yes      승인이 필요한 것도 그냥 실행 (기본은 거부)
+ *   json     결과를 JSON 한 덩이로
+ *   quiet    도구가 무엇을 했는지를 안 적는다 (오류는 그래도 적는다)
+ * @returns {Promise<number>} 종료코드
+ */
+export async function runOnce(opts = {}) {
+  const json = opts.json === true;
+  const quiet = opts.quiet === true;
+
+  // 두 갈래로 나눠 쓴다.
+  //   표준출력 — 모델의 마지막 답만. 그래야 > 파일 이나 | grep 이 그대로 먹는다.
+  //   표준오류 — 도구가 무엇을 했는지. 사람이 볼 것이지 넘겨줄 것이 아니다.
+  // 이걸 섞으면 파이프 뒤에 붙은 명령이 도구 기록까지 받아 먹는다.
+  const 삐끗 = (s = '') => process.stderr.write(s + '\n');
+  const 곁 = (s = '') => { if (!quiet) 삐끗(s); };
+
+  const 내놓기 = (r) => {
+    /*
+     * 뒤에서 돌던 명령을 반드시 거둔다.
+     *
+     * 여기가 이 모드의 모든 끝맺음이 지나는 자리다. 배치는 이걸 빠뜨리면
+     * 제일 크게 다친다 — 잡이 끝났다고 표시된 뒤에도 dev 서버가 계속 돌고,
+     * 다음 잡이 같은 포트를 잡으려다 실패한다. 그 원인은 로그 어디에도 없다.
+     */
+    const 껐다 = 일감모두끝내기();
+    if (껐다) 곁(`  ${mark.ok} ${c.gray(`뒤에서 돌던 명령 ${껐다}개를 껐습니다.`)}`);
+    // 고친 뒤 진단 때문에 뒤에서 데워진 언어 서버도 같이 거둔다.
+    // 이건 아무 말 없이 한다 — 사용자가 띄우라고 한 적이 없는 것이라,
+    // 껐다는 말부터 하면 "그건 또 뭐냐" 가 된다.
+    언어서버다끄기().catch(() => {});
+    if (json) process.stdout.write(JSON.stringify(r) + '\n');
+    else if (r.text) process.stdout.write(r.text.endsWith('\n') ? r.text : r.text + '\n');
+    return r.code;
+  };
+  // 시작도 못 한 실패. --quiet 여도 이유는 반드시 적는다 — 스크립트를 고칠 사람이 볼 유일한 글이다.
+  const 못함 = (reason, message) => {
+    삐끗(`  ${c.red('✗')} ${message}`);
+    return 내놓기({
+      ok: false, reason, code: EXIT.error, text: '', why: message,
+      tools: 0, steps: 0, usage: { in: 0, out: 0, calls: 0, ms: 0, retries: 0 }, ms: 0,
+    });
+  };
+
+  // ── 시킬 말 ───────────────────────────────────────────────────────────
+  // 인자로 준 것이 먼저다. 없을 때만 표준입력을 읽는다 —
+  // 둘 다 있을 때 무엇이 이기는지가 헷갈리면 스크립트가 조용히 엉뚱한 일을 한다.
+  let 시킬말 = String(opts.prompt ?? '').trim();
+  if (!시킬말) 시킬말 = (await 표준입력읽기()).trim();
+  if (!시킬말) {
+    return 못함('no-prompt', '무엇을 시킬지 적어 주세요 — deel run "..." 또는 echo "..." | deel run');
+  }
+
+  const cfg = load();
+  const prof = activeProfile(cfg);
+  if (!prof) return 못함('no-config', '저장된 연결이 없습니다. deel setup 을 먼저 실행하세요.');
+
+  // 열쇠를 방금 잠갔으면 알린다. 여기서는 stdout 을 안 쓴다 —
+  // 배치로 부르는 쪽이 stdout 을 JSON 으로 읽고 있을 수 있다.
+  const 잠금 = 잠금소식();
+  if (잠금) { try { process.stderr.write(`  ${잠금}\n`); } catch { /* 못 써도 그만 */ } }
+
+  const root = opts.root ? String(opts.root) : process.cwd();
+  const conn = {
+    kind: prof.kind, base: prof.baseUrl, auth: prof.auth,
+    key: resolveKey(prof), model: prof.model,
+    /*
+     * 열쇠를 갖고 있는 대신 **받아 오는** 설정 (safety/authcmd.js).
+     *
+     * 여기서는 설정만 싣는다. 명령은 요청 직전에 부른다 — 켤 때 한 번
+     * 받아 두면 한 시간짜리 토큰이 세 시간짜리 대화 한복판에서 죽고,
+     * 그 401 은 화면에서 「열쇠가 틀렸다」 와 구별이 안 된다.
+     */
+    열쇠받기: 받기설정(prof, { 정책값: 정책읽기().값 }),
+    ctx: opts.ctx ?? prof.ctx ?? CTX_DEFAULT,
+    // 답 길이 상한 — deel --max-tokens 32k 로 높일 수 있다(대화 화면의 /out 과 같은 값).
+    maxTokens: opts.maxTokens ?? prof.maxTokens ?? null,
+    streaming: prof.streaming ?? false,
+    tools: prof.tools ?? false, json: prof.json ?? false, think: prof.think ?? false,
+    vision: prof.vision ?? false,
+  };
+
+  /*
+   * 잠근 열쇠를 못 풀었으면 그 까닭을 표준오류로 낸다.
+   *
+   * 배치로 부르는 쪽은 표준출력을 JSON 으로 읽으므로 거기에 섞으면 안 된다.
+   * 그렇다고 조용히 넘기면 여기가 더 나쁘다 — 아무도 안 보고 있는 자리라
+   * 401 하나 남기고 끝난다. 위 잠금소식 과 같은 자리, 같은 규칙이다.
+   */
+  const 열쇠탈 = 열쇠탈소식();
+  if (열쇠탈) { try { process.stderr.write(`  ${열쇠탈}\n`); } catch { /* 못 써도 그만 */ } }
+
+  /*
+   * 자물쇠는 대화 화면과 똑같이 건다. 비대화라고 느슨해질 이유가 없다 —
+   * 오히려 배치는 아무도 안 보는 자리라 더 단단해야 한다.
+   *
+   * 다른 것은 딱 하나, **물을 수가 없다**는 것이다. 파이프 뒤에는 답할 사람이
+   * 없다. 그래서 여기서는 묻는 대신 멈추고, 무엇을 붙이면 되는지를 말한다.
+   * 조용히 나가 버리면 스크립트가 바깥으로 나가고 있는 줄 아무도 모른다.
+   */
+  const 바깥연결 = 바깥인가(conn.base);
+  const 실행모드 = 지금모드({
+    online: opts.online === true,
+    // 관리 정책이 offline 을 못박아 뒀으면 옵션과 상관없이 켠다 (safety/policy.js).
+    offline: !!(opts.offline ?? prof.offline ?? cfg?.offline),
+  });
+  const 나감 = 나갈수있나(실행모드, { 바깥: 바깥연결, 허가: prof.online === true });
+  if (나감.물어볼까) {
+    const 어디 = (() => { try { return new URL(conn.base).host; } catch { return conn.base; } })();
+    return 못함('needs-online',
+      `이 연결은 이 컴퓨터 밖으로 나갑니다 (${주소가리기(어디)}). 여기서는 물어볼 수 없습니다.\n`
+      + '    나가도 된다면 --online 을 붙이거나, 대화 화면(deel)에서 한 번 허락해 두세요.\n'
+      + '    이 컴퓨터 안의 모델을 쓰려면 deel scan --save 로 붙이세요.');
+  }
+  allowEndpoint(conn.base);
+  if (실행모드.허가무시) setOffline(true);
+
+  const session = new Session(conn, {
+    root,
+    mode: opts.mode ?? 'auto',
+    work: opts.work ?? null,
+    think: opts.think ?? 'medium',
+    effort: opts.effort ?? 'save',
+    maxSteps: opts.maxSteps ?? null,   // null 이면 작업 모드가 정한다
+  });
+  // 지금 어느 실행 모드인가. 화면이 첫 줄에 이걸 그린다(ui/status.js).
+  // session 에 실어 두는 까닭은, 대화 도중 /model 로 옮겨도 같은 자리를 보게 하려는 것이다.
+  session.실행모드 = 실행모드;
+
+  /*
+   * 전선 카드와 이 실행의 이름 (backend/wire.js).
+   *
+   * 여기는 배운 것을 읽을 자리가 없다(배치는 대화 이력을 안 들고 돈다).
+   * 그래도 짐작만으로 충분하다 — 짐작이 틀리면 첫 400 에서 그 자리 안에
+   * 고쳐서 다시 부른다. 이름을 실어 보내는 것은 한 번의 실행이 게이트웨이
+   * 대시보드에서 한 줄로 묶이게 하려는 것이다.
+   */
+  전선붙이기(conn);
+  session.세션이름 = 세션이름짓기(newId());
+  conn.세션이름 = session.세션이름;
+
+  const found = discover(root);
+  session.skills = found.skills;
+  session.commands = found.commands;
+  session.plugins = found.plugins;
+
+  // ── 물어보는 자리를 전부 막는다 ────────────────────────────────────────
+  //
+  // 여기가 이 파일의 핵심이다. 물어보는 함수 하나라도 기다리게 두면 그것 하나로
+  // 배치가 선다. 그래서 세 자리 모두 '기다리지 않고 바로 답을 내는' 함수로 채운다.
+  //
+  // 승인은 기본이 거부다. 반대로 하면 안 된다 — 아무도 안 보는 자리에서
+  // 되돌릴 수 없는 명령이 조용히 돌아가는 것이 이 프로그램이 제일 피하려는 일이다.
+  // 정말 맡기고 싶은 사람은 --yes 로 그 뜻을 명시한다.
+  const 승인필요 = session.mode !== 'auto';
+  const 자동승인 = opts.yes === true;
+  const ctx = {
+    scope: makeScope(root),
+    // 도구가 한 번에 돌려줄 양을 이 값에서 뽑는다 (agent/budget.js).
+    // /model 로 갈아타면 conn 이 통째로 바뀌므로 그때마다 다시 읽는다.
+    get 모델컨텍스트() { return conn.ctx ?? null; },
+    // 이 모델이 그림을 볼 수 있나 — Read 가 그림을 만났을 때 무슨 말을 할지가 여기서 갈린다.
+    get 눈있나() { return !!conn.vision; },
+    // 적어 둔 허락·금지 규칙 (safety/policy.js). 승인 모드보다 먼저 본다.
+    규칙들: 규칙모으기(cfg),
+    history: new History(root),
+    audit: new Audit(root, { 열쇠들: 열쇠묻기(conn) }),
+    seen: new Set(),
+    skills: found.skills,
+    loadedSkills: new Set(),
+    // 고친 뒤 진단을 볼지 (lsp/diag.js). 아래 내놓기() 에서 반드시 거둔다 —
+    // 안 거두면 배치가 끝나고도 언어 서버가 폴더를 물고 남는다.
+    lsp: { 켬: true },
+    // 되물을 사람이 없으니 기본값을 그대로 돌려준다.
+    ask: async (_label, o = {}) => o?.def ?? '',
+    // 엑셀 암호를 여기서 기다리면 그대로 선다. 없다고 바로 답한다 —
+    // 도구는 null 을 받으면 '암호가 걸려 못 읽었다' 고 정확히 말한다.
+    askPassword: async () => null,
+    confirm: async (name, args) => {
+      const 무엇 = 도구줄(name, args);
+      if (자동승인) {
+        곁(`  ${c.yellow('!')} ${c.gray(`--yes 라서 묻지 않고 실행합니다 — ${무엇}`)}`);
+        return true;
+      }
+      곁(`  ${c.yellow('⊘')} ${c.gray(`승인이 필요해 거부했습니다 (물어볼 사람이 없습니다) — ${무엇}`)}`);
+      return false;
+    },
+  };
+
+  // 거부당할 것을 모델에게 미리 알려 준다.
+  //
+  // 거부만 하고 이유를 안 알리면 모델은 같은 호출을 몇 번이고 다시 한다.
+  // 사람이 '안 돼요' 라고 한 줄 알고, 다시 물어보면 이번엔 된다고 믿는다.
+  // 그러면 걸음 수만 다 쓰고 아무것도 못 한 채 끝난다.
+  const 보낼글 = (승인필요 && !자동승인)
+    ? `${시킬말}\n\n(비대화 모드다. 사람이 없어 승인을 물어볼 수 없고, 승인이 필요한 도구 호출은 자동으로 거부된다.`
+      + ' 승인 없이 되는 방법을 골라라. 그래도 안 되면 무엇이 막혔는지 말로 알려라.)'
+    : 시킬말;
+
+  // ── 컨텍스트 길이 ─────────────────────────────────────────────────────
+  //
+  // 대화 화면과 같은 이유로 서버에 물어본다. 저장된 값을 믿으면 조용히 작아진다.
+  // 다만 알아낸 값을 설정 파일에 도로 적지는 않는다 — 배치는 같은 명령을 여러 개
+  // 동시에 띄우는 자리라, 그때마다 config.json 을 덮어쓰면 서로 밟는다.
+  // 이번 한 번만 쓰고 버린다.
+  if (opts.ctx == null) {
+    try {
+      const r = await probeCtx(conn, { timeout: 6000 });
+      if (r?.value) {
+        const 전 = conn.ctx;
+        conn.ctx = r.value;
+        if (전 !== r.value) {
+          곁(`  ${mark.ok} ${c.gray(`컨텍스트를 ${전.toLocaleString()} → ${r.value.toLocaleString()} 로 맞췄습니다 (${r.source ?? '서버'}에서 읽음)`)}`);
+        }
+      }
+    } catch { /* 못 물어보면 설정값 그대로 간다. 여기서 멈출 일은 아니다 */ }
+  }
+
+  // 종합 모드면 이 한마디를 보고 알맞은 작업 모드로 옮긴다. 대화 화면과 같다.
+  session.routed = null;
+  if (session.work === 'auto') {
+    const 골라진 = route(시킬말);
+    if (골라진.mode) {
+      session.routed = 골라진.mode;
+      const w = getWork(골라진.mode);
+      곁(`  ${c.hcyan(w.glyph)} ${c.gray(`${w.name} (${w.en}) — 말 속에 ${골라진.why} 가 있어서`)}`);
+    }
+  }
+
+  // ── 한 턴 ─────────────────────────────────────────────────────────────
+  const turn = new AbortController();
+  const 끊김 = () => { if (!turn.signal.aborted) turn.abort(); };
+  process.on('SIGINT', 끊김);
+
+  const t0 = Date.now();
+  let reason = 'done';
+  let why = '';
+  let tools = 0;
+  let steps = 0;
+  let 이번단계글 = '';   // 지금 단계에서 모델이 흘린 글. 단계가 바뀌면 비운다
+  let 답 = null;
+  // 서버가 끝났다는 말 없이 멈춘 적이 있나. 뒤에 오는 done 이 이걸 못 지운다.
+  let 말없이끊겼나 = false;
+
+  try {
+    // 하위 작업 안쪽에서 온 이벤트는 그 겹만큼 들여 쓴다.
+    const 안쪽 = (ev) => (ev.depth ? '  '.repeat(ev.depth) : '');
+
+    for await (const ev of run(session, ctx, 보낼글, { signal: turn.signal })) {
+      switch (ev.type) {
+        case 'stage':
+          steps = ev.step;
+          이번단계글 = '';
+          break;
+
+        // 중간 단계의 말은 표준출력에 안 싣는다. "이제 파일을 읽어보겠습니다" 까지
+        // 딸려 나가면 파이프 뒤에서 답만 골라 쓸 수가 없다.
+        case 'content':
+          이번단계글 += ev.text;
+          break;
+
+        case 'tool': {
+          tools++;
+          /*
+           * 실패는 실패로 보여야 한다.
+           *
+           * 전에는 `error` 만 빨갛게 칠했다. 그런데 탈이 났는데 error 는 없는
+           * 도구가 있다 — Bash 는 종료코드 3 을, Verify 는 `탈 2개` 를 요약에
+           * 담아 돌려준다. 그것들이 회색으로 찍히면, 나중에 이 기록을 읽는
+           * 사람 눈에는 성공과 구별되지 않는다. `deel run` 의 출력은 곧
+           * 근거로 쓰이는 물건이라 그 구별이 사라지면 안 된다.
+           */
+          const 결과 = ev.result?.error
+            ? c.red(clip(String(ev.result.error).split('\n')[0], 70))
+            : ev.result?.failed
+              ? c.yellow(clip(ev.result?.summary ?? '실패', 70))
+              : c.gray(clip(ev.result?.summary ?? '완료', 70));
+          // 하위 작업 안쪽이면 한 단 들여 그린다. 안 그러면 하위가 만진 파일이
+          // 부모가 만진 것과 똑같이 찍혀서, 기록으로 읽을 때 구분이 안 된다.
+          곁(`${안쪽(ev)}  ${c.cyan('⏺')} ${c.bold(도구줄(ev.name, ev.args))}  ${결과}`);
+          /*
+           * 비밀이 지나갔으면 여기서도 적는다.
+           *
+           * 배치는 아무도 안 보는 자리이고, 이 기록이 나중에 근거가 된다.
+           * "열쇠가 대화에 들어갔다" 를 그 기록에서 빼면 안 된다 — 나중에
+           * 사고가 났을 때 언제 새어 나갔는지 알 방법이 없어진다.
+           */
+          if (ev.비밀) {
+            삐끗(`${안쪽(ev)}    ${ev.비밀.가렸나 ? c.gray('⊘') : c.yellow('!')} `
+              + `${c.gray(`${ev.비밀.말}${ev.비밀.가렸나 ? ' — 모델에 가려서 보냈습니다' : ' — 파일 내용은 가리지 않습니다'}`)}`);
+          }
+          break;
+        }
+
+        /*
+         * 하위 작업의 여닫는 줄.
+         *
+         * `deel run` 은 잡·CI 에서 돌고 그 기록이 나중에 근거가 된다. 하위가
+         * 무엇을 맡았고 끝냈는지 안 남으면, 파일 넷이 어디서 나왔는지를
+         * 기록만 보고는 알 수 없다.
+         */
+        case 'task_start':
+          곁(`${안쪽(ev)}  ${c.magenta('⌥')} ${c.bold('하위 작업')} ${clip(ev.목적, 60)}`
+            + `  ${c.gray(`따로 떨어진 대화 · 최대 ${ev.steps}걸음`)}`);
+          break;
+
+        case 'task_done': {
+          const 끝 = ev.끝 ?? {};
+          const 잘됨 = 끝.type === 'done';
+          const 셈 = (끝.files ?? []).filter((f) => !f.dir && !f.missing).length;
+          곁(`${안쪽(ev)}  ${잘됨 ? c.green('✓') : c.yellow('⚠')} ${c.gray('하위 작업')} ${clip(ev.목적, 50)}`
+            + `  ${c.gray(잘됨 ? `끝냄 · 파일 ${셈}개 · ${끝.steps ?? 0}걸음` : `다 못 했습니다 (${끝.type}) · ${끝.steps ?? 0}걸음`)}`);
+          break;
+        }
+
+        case 'retry':
+          곁(`  ${c.yellow('↻')} ${c.gray(`${ev.why} — 상한을 ${ev.from} → ${ev.to} 로 올려 다시 부릅니다`)}`);
+          break;
+
+        // 서버가 잠깐 막아서 기다렸다 다시 부른 자리 (backend/retry.js).
+        // 배치 기록에 남아야 "그날 밤 왜 12분이 걸렸나" 를 나중에 읽을 수 있다.
+        case 'backoff':
+          // 맞고 물러난 것과 맞기 전에 비킨 것은 다른 일이다. 같은 말로 적으면
+          // 있지도 않은 429 가 배치 기록에 남는다.
+          곁(ev.미리
+            ? `  ${c.yellow('⏸')} ${c.gray(옮긴말('loop.quotaAhead', { 초: 알림채움(ev).초 }))}`
+            : `  ${c.yellow('↻')} ${c.gray(옮긴말('loop.backoff', 알림채움(ev)))}`);
+          break;
+
+        // 서버가 안 받는 칸이 있어 전선 카드를 고쳤다 (backend/wire.js).
+        case 'wire':
+          곁(`  ${c.cyan('⚙')} ${c.gray(옮긴말('loop.wire', { 무엇: ev.무엇 }))}`);
+          break;
+
+        case 'folded':
+          곁(`  ${c.cyan('◲')} ${c.gray(`오래된 도구 결과 ${ev.접은것}개를 접었습니다 (${ev.아낀토큰.toLocaleString()} 토큰을 비움)`)}`);
+          break;
+
+        case 'images_folded':
+          곁(`  ${c.cyan('◲')} ${c.gray(`오래된 그림 ${(ev.뺀것들 ?? []).reduce((a3, x) => a3 + x.장수, 0)}장을 뺐습니다`)}`);
+          break;
+
+        case 'compacted':
+          곁(`  ${c.cyan('◱')} ${c.gray(`대화 ${ev.folded}개를 요약으로 접었습니다 (${ev.before.toLocaleString()} → ${ev.after.toLocaleString()} 토큰)`)}`);
+          break;
+
+        case 'compact_failed':
+          곁(`  ${c.gray(`(접지 못했습니다: ${ev.why})`)}`);
+          break;
+
+        /*
+         * ── 여기 넷은 여태 아예 안 보고 있었다 ────────────────────────
+         *
+         * 대화창은 넷 다 화면에 적어 준다. 한 방 실행은 안 적었다. 그래서
+         * 잘린 답이 **온전한 답인 척** 파이프 뒤로 넘어갔다. `deel -p` 는
+         * 잡·CI 에서 돌고 그 기록이 나중에 근거가 되는 물건이라, 여기서
+         * 빠지면 왜 반쪽인지 되짚을 자리가 아무 데도 없다.
+         */
+        case 'capped':
+          곁(`  ${c.yellow('⚠')} ${c.gray(옮긴말('ev.capped', { 한계: ev.cap.toLocaleString() }))}`);
+          break;
+
+        /*
+         * 말없이 끊긴 것은 **종료코드까지** 바꾼다.
+         *
+         * 뒤에 done 이 따라오므로 그대로 두면 0 으로 끝난다. 잘렸다는 사실을
+         * 화면에만 적고 코드로는 성공이라고 하면, 스크립트는 화면을 안 읽으니
+         * 아무 일도 없던 것이 된다. 다만 여기서 곧바로 reason 을 바꾸지는
+         * 않는다 — 뒤에 오는 done 이 덮어쓰기 때문에 표시만 해 두고
+         * 루프가 끝난 뒤에 판정한다.
+         */
+        case 'cutoff':
+          말없이끊겼나 = true;
+          곁(`  ${c.yellow('⚠')} ${c.gray(옮긴말('ev.cutoff'))}`);
+          break;
+
+        case 'nudge':
+          곁(`  ${c.gray(`↺ ${ev.why === '요청누락'
+            ? 옮긴말('ev.nudgeMissed', { n: ev.빠진?.length ?? 0 })
+            : 옮긴말('ev.nudgeRead')}`)}`);
+          break;
+
+        /*
+         * 모델이 안 하겠다고 했다.
+         *
+         * 화면에만 적고 종료코드는 0 으로 두면, 뒤에 붙은 스크립트가 일이
+         * 된 줄 알고 다음 단계로 넘어간다. 거절은 **아무 일도 안 한 것**이라
+         * 그렇게 넘어가면 안 된다. 여기서 곧바로 정한다 — 이 뒤에는 done 이
+         * 안 온다(루프가 그 자리에서 끝낸다).
+         */
+        case 'refusal':
+          reason = 'refusal';
+          why = 옮긴말('run.refusal');
+          /*
+           * 모델이 **뭐라고 하면서** 거절했는지도 내놓는다.
+           *
+           * 이 규격도 거절 글을 조각으로 보내기는 하는데, 그 조각을 답
+           * 자리로 흘려보내지 않고 맨 끝에 한 번에 모아 준다(backend/adapter.js
+           * 의 흡수). 그래서 여기서 안 담으면 화면에도 파이프 뒤에도 아무 글이
+           * 안 남고 「거절당했습니다」 한 줄만 보인다 — 무엇을 고쳐 다시
+           * 물어야 할지 알 길이 없다.
+           */
+          if (ev.text) 답 = ev.text;
+          곁(`  ${c.yellow('⚠')} ${c.gray(옮긴말('run.refusal'))}`);
+          if (ev.왜 && ev.왜 !== 'refusal') 곁(`     ${c.gray(옮긴말('run.refusalWhy', { 왜: ev.왜 }))}`);
+          break;
+
+        case 'note':
+          곁(`  ${c.gray(`· ${ev.text}`)}`);
+          break;
+
+        // 자리가 다 차서 비웠다. 오류가 아니라 이어 가는 중이라, 종료코드는 안 건드린다.
+        case 'reset':
+          곁(`  ${c.cyan('◱')} ${c.gray((ev.kept?.할일 ?? 0)
+            ? 옮긴말('ev.reset', { 버린수: ev.dropped, 할일: ev.kept.할일 })
+            : 옮긴말('ev.resetBare', { 버린수: ev.dropped }))}`);
+          break;
+        case 'learned':
+          곁(`  ${c.cyan('◎')} ${c.gray(ev.what === 'ctx'
+            ? 옮긴말('ev.learnedCtx', { 한계: ev.limit.toLocaleString() })
+            : 옮긴말('ev.learnedOut', { 한계: ev.limit.toLocaleString() }))}`);
+          break;
+
+        case 'limit':
+          reason = 'limit';
+          why = `도구 호출 ${ev.steps}회에서 멈췄습니다. 한 번에 하기엔 큰 일입니다 — 나눠서 시키세요.`;
+          break;
+
+        case 'stuck':
+          reason = 'stuck';
+          why = String(ev.why ?? '같은 자리에서 헛돌고 있어 멈췄습니다');
+          break;
+
+        case 'aborted':
+          reason = 'aborted';
+          why = '중단했습니다';
+          break;
+
+        case 'error':
+          reason = 'error';
+          why = String(ev.text ?? '알 수 없는 오류');
+          break;
+
+        case 'done':
+          reason = 'done';
+          답 = ev.text ?? 이번단계글;
+          break;
+      }
+    }
+  } catch (err) {
+    reason = 'error';
+    why = String(err?.message ?? err);
+  } finally {
+    process.removeListener('SIGINT', 끊김);
+  }
+
+  // 끝까지 못 갔어도 여기까지 나온 말은 내준다. 빈손으로 돌려보내면
+  // 왜 안 됐는지 짐작할 거리조차 없다.
+  if (답 == null) 답 = 이번단계글;
+
+  /*
+   * 말없이 끊긴 답은 '다 됐다' 로 안 넘긴다.
+   *
+   * done 이 뒤따라오므로 그냥 두면 reason 이 done 으로 덮인다. 그런데 그
+   * 답은 중간에서 끊긴 물건이다. 여기서 갈라 주지 않으면 파이프 뒤 스크립트가
+   * 반쪽을 온전한 것으로 받아 쓴다 — 그러고도 아무 표시가 안 남는다.
+   * 진짜 탈(error·limit·stuck)이 이미 잡혔으면 그쪽이 먼저다.
+   */
+  if (말없이끊겼나 && reason === 'done') {
+    reason = 'cutoff';
+    why = 옮긴말('ev.cutoff');
+  }
+
+  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()}`);
+    곁(`  ${c.gray('── ' + 조각.join(' · '))}`);
+  }
+
+  return 내놓기({
+    ok: reason === 'done',
+    reason,
+    code,
+    text: String(답 ?? ''),
+    tools,
+    steps,
+    usage: {
+      /*
+       * `in` 은 여태와 같은 뜻으로 둔다 — 서버가 새로 읽었다고 센 만큼이다.
+       * 파이프 뒤 스크립트가 이 이름을 이미 쓰고 있어서 뜻을 바꾸면 안 된다.
+       * 보낸 것 전체는 이름을 새로 붙여 **더한다** (backend/adapter.js 의 보낸토큰).
+       */
+      in: session.usage.in, out: session.usage.out,
+      prompt: session.usage.prompt || session.usage.in,
+      cacheRead: session.usage.cacheRead ?? 0,
+      cacheWrite: session.usage.cacheWrite ?? 0,
+      calls: session.usage.calls, ms: session.usage.ms,
+      retries: session.usage.retries ?? 0,
+    },
+    model: conn.model,
+    ms: Date.now() - t0,
+    ...(why ? { why } : {}),
+  });
+}