deel-local-cli 2.0.1 → 2.1.0

package/src/i18n/ko.js

@@ -312,6 +312,10 @@ export const ko = {
   'approve.strict.name': '모두 확인',
   'approve.strict.short': '모두',
   'approve.strict.line': '파일을 고치거나 명령을 돌리기 전에 매번 물어봅니다',
+  'approve.newFile': '새 파일',
+  'approve.locked': '관리 정책이 승인을 {바닥} 아래로 못 내리게 걸어 두었습니다 — {곳}',
+  'approve.lockedUnknown': '관리 정책의 approval 값 "{값}" 을 몰라 제일 좁은 strict 로 칩니다 — {곳}',
+  'approve.noAlways': '관리 정책이 승인을 걸어 두어 「앞으로 묻지 않기」 는 없습니다',
   'work.title': '작업 모드',
   'work.canEdit': '파일 바꿈',
   'work.readOnly': '읽기만',
@@ -388,6 +392,8 @@ export const ko = {
   'plan.ask': '이대로 진행할까요?',
   'plan.hint': '⏎ 진행 · y 한마디 붙여 진행 · 3 그 단계에 한마디 · n 취소',
   'plan.cancelled': '그만뒀습니다. 계획은 위에 남아 있으니 이어서 말씀하셔도 됩니다.',
+  'plan.timedOut': '{초}초 동안 답이 없어 계획대로 진행합니다.',
+  'plan.autoGo': '자율 모드라 묻지 않고 계획대로 진행합니다.',
   'plan.going': '계획대로 진행합니다.',
   'plan.goingWith': '한마디를 얹어 진행합니다 — {말}',
   'plan.replan': '그 점을 반영해 계획을 다시 냅니다.',
@@ -406,6 +412,9 @@ export const ko = {
   'ask.freePrompt': '답',
   // 물어보는 도중에 ESC 를 눌렀다. 물음이 화면에 걸린 채로 남으면 안 된다.
   'ask.stopped': '멈췄습니다 — 답하지 않은 것으로 넘어갑니다.',
+  'ask.autoWait': '{초}초 안에 답이 없으면 알아서 진행합니다',
+  'ask.timedOut': '{초}초 동안 답이 없어 알아서 진행합니다.',
+  'ask.autoSkip': '자율 모드라 묻지 않고 진행합니다 — {물음}',
 
   // ── 잠깐 막혔을 때 (backend/retry.js) ─────────────────────────────────
   'loop.backoff': '서버가 잠시 막았습니다 ({무엇}) — {초}초 뒤 다시 부릅니다 ({n}/{max})',
@@ -540,6 +549,17 @@ export const ko = {
   'ev.hookNote': '훅: {말}',
   'ev.hookBlock': '훅이 막았습니다',
   'ev.nudgeRead': '읽기만 하고 끝내려고 해서 한 번 되밀었습니다',
+  'check.start': '완료 검사 ({판}/{최대}) — {명령}',
+  'check.pass': '완료 검사 통과 — {명령}',
+  'check.fail': '완료 검사 실패 ({판}/{최대}) — {요약}',
+  'check.retry': '실패 내용을 돌려주고 다시 고치게 합니다',
+  'check.gaveUp': '{판}번 돌렸는데도 실패했습니다 — 실패로 끝냅니다',
+  'check.skipped': '완료 검사를 못 돌렸습니다 — {까닭}',
+  'cli.checkFlag': '끝내려 할 때 이 검사를 돌려 통과해야 끝남 (실패하면 고치게 하고, 끝내 실패면 8)',
+  'cli.evalTitle': '골든셋',
+  'cli.evalWhy': '— 과제 모음을 실제 모델로 돌려 몇 개를 해내나 잽니다',
+  'cli.evalInit': '예제 과제 다섯을 golden/ 에 만듭니다',
+  'cli.evalRun': '과제마다 임시 폴더에서 deel run 을 돌리고, 끝난 뒤 정답 검사로 채점합니다',
   'ev.learnedCtx': '서버가 알려 준 컨텍스트 한계 {한계} 로 맞추고 다시 부릅니다',
   'ev.learnedOut': '서버가 알려 준 답 길이 한계 {한계} 로 맞추고 다시 부릅니다',
   /*

package/src/i18n/zh.js

@@ -290,6 +290,10 @@ export const zh = {
   'approve.strict.name': '每次都问',
   'approve.strict.short': '每次',
   'approve.strict.line': '每改一个文件、每跑一条命令都问',
+  'approve.newFile': '新文件',
+  'approve.locked': '管理策略把审批锁在 {바닥} 或更严 — {곳}',
+  'approve.lockedUnknown': '不认识管理策略的 approval 值「{값}」，按最严的 strict 处理 — {곳}',
+  'approve.noAlways': '管理策略锁定了审批，没有「以后不再问」',
   'work.title': '工作模式',
   'work.canEdit': '会改文件',
   'work.readOnly': '只读',
@@ -353,6 +357,8 @@ export const zh = {
   'plan.ask': '就按这个做吗?',
   'plan.hint': '⏎ 开始 · y 加一句再开始 · 3 对那一步说一句 · n 取消',
   'plan.cancelled': '停下了。计划还在上面，接着说就行。',
+  'plan.timedOut': '{초}秒没有回答，按计划继续。',
+  'plan.autoGo': '自动模式，不问直接按计划继续。',
   'plan.going': '按计划开始。',
   'plan.goingWith': '带上你这句话开始 — {말}',
   'plan.replan': '按这一点重新出计划。',
@@ -363,6 +369,9 @@ export const zh = {
   'ask.pickPrompt': '1-{끝}（后面可以加一句话），或者自己写',
   'ask.freePrompt': '回答',
   'ask.stopped': '已停止 — 按没有回答继续。',
+  'ask.autoWait': '{초}秒内没有回答就自己继续',
+  'ask.timedOut': '{초}秒没有回答，自己继续。',
+  'ask.autoSkip': '自动模式，不问直接继续 — {물음}',
   'loop.backoff': '服务端把请求推回来了 ({무엇}) — {초} 秒后再试 ({n}/{max})',
   'cost.retries': '重试',
   // ── 计数词 ────────────────────────────────────────────────────────────
@@ -466,6 +475,17 @@ export const zh = {
   'ev.hookNote': '钩子：{말}',
   'ev.hookBlock': '钩子拦下了这一步',
   'ev.nudgeRead': '只看不动就要收尾，已经推回去一次',
+  'check.start': '完成检查 ({판}/{최대}) — {명령}',
+  'check.pass': '完成检查通过 — {명령}',
+  'check.fail': '完成检查失败 ({판}/{최대}) — {요약}',
+  'check.retry': '把失败内容交回去重新修',
+  'check.gaveUp': '跑了 {판} 次仍然失败 — 按失败结束',
+  'check.skipped': '没能跑完成检查 — {까닭}',
+  'cli.checkFlag': '结束前跑这个检查，通过才结束（失败就让它修，最后仍失败则返回 8）',
+  'cli.evalTitle': '黄金集',
+  'cli.evalWhy': '— 用真实模型跑一组任务，测它能完成多少',
+  'cli.evalInit': '在 golden/ 里建五个示例任务',
+  'cli.evalRun': '每个任务在临时文件夹里跑 deel run，结束后用它没见过的检查评分',
   'ev.learnedCtx': '按服务端给出的上下文上限 {한계} 重新调用',
   'ev.learnedOut': '按服务端给出的回答长度上限 {한계} 重新调用',
   'ev.reset': '位置不够，已清掉前面 {버린수} 条对话继续做 — 还剩 {할일} 件待办',

package/src/jsonl.js

@@ -0,0 +1,42 @@
+/**
+ * 한 줄씩 덧붙여 가는 기록 파일(대화 · 감사기록 · 되돌리기 이력)이 같이 쓰는 두 손질.
+ *
+ * agent/store.js · safety/audit.js · safety/undo.js 에 바이트까지 같은 사본이 세 벌 있었다
+ * (2.0.0 7회차에 적어 둠). 한 벌을 고치고 두 벌을 잊는 날이 오므로 여기 한 벌만 둔다 (2.0.2).
+ *
+ * node:fs 말고는 아무것도 안 들여온다 — 되돌리기는 설정이 깨져도 돌아야 한다(undo.js 머리말).
+ * 그래서 `진짜자리()` 쌍둥이(guard · undo)는 여기로 안 모은다.
+ */
+import { statSync, openSync, readSync, closeSync, chmodSync } from 'node:fs';
+
+/**
+ * 파일이 개행으로 끝나나. 없거나 비었거나 못 읽으면 참 — 붙일 반쪽이 없다.
+ *
+ * 앞 판이 한 줄을 반만 적고 죽으면, 이어 적는 첫 줄이 그 반쪽 **뒤에 그대로 붙어** 한 줄이
+ * 되고, 그 줄은 JSON 이 아니라 다음에 읽을 때 통째로 건너뛴다. 부르는 쪽은 파일마다 처음
+ * 적을 때 한 번 이것을 보고, 아니면 개행부터 붙인다.
+ */
+export function 줄로끝나나(file) {
+  let fd = null;
+  try {
+    const 크기 = statSync(file).size;
+    if (!크기) return true;
+    fd = openSync(file, 'r');
+    const 한바이트 = Buffer.alloc(1);
+    readSync(fd, 한바이트, 0, 1, 크기 - 1);
+    return 한바이트[0] === 0x0a;
+  } catch { return true; }         // 없거나 못 읽으면 붙일 반쪽도 없다
+  finally { if (fd != null) { try { closeSync(fd); } catch { /* 닫다 터져도 적기는 한다 */ } } }
+}
+
+/**
+ * 본인만 읽게 잠근다. 건 결과를 돌려준다 — `{모드}` 면 걸었고, `{못함}` 이면 못 걸었다.
+ *
+ * 윈도우에서 chmod 는 **아무 일도 안 하고 성공한다.** 그 성공을 그대로 적으면 「잠근 척」
+ * 이 된다 — 같은 PC 를 여럿이 쓰는 사람이 화면만 보고 안심한다. 안 걸었으면 안 걸었다고 적는다.
+ */
+export function 본인만잠그기(file) {
+  if (process.platform === 'win32') return { 못함: 'windows' };
+  try { chmodSync(file, 0o600); return { 모드: 0o600 }; }
+  catch (err) { return { 못함: err?.code ?? String(err) }; }
+}

package/src/lsp/client.js

@@ -30,6 +30,7 @@ import { pathToFileURL, fileURLToPath } from 'node:url';
 import { readFileSync } from 'node:fs';
 import { 갈래, 고르기, 언어아이디 } from './servers.js';
 import { 틀, 받개 } from './rpc.js';
+import { 신호에거두기, 다시보낼까 } from '../reap.js';
 
 // 켜는 데 이만큼 넘게 걸리면 포기한다. rust-analyzer 처럼 무거운 것도
 // **악수(initialize)** 자체는 빠르다 — 오래 걸리는 것은 그 뒤의 색인이다.
@@ -606,53 +607,12 @@ export const 아이들데려가기 = () => {
 process.on('exit', 아이들데려가기);
 
 /*
- * ── 치우고 나면 **원래대로 죽어야 한다** ────────────────────────────────
- *
- * 여기는 세 신호에 같은 손을 달아 두고 치우기만 했다. 그런데 Node 는
- * SIGINT·SIGTERM 에 손이 하나라도 달려 있으면 **기본 동작(끝내기)을 안 한다.**
- * 그래서 이 파일이 한 번이라도 불려 들어온 프로그램은 —
- *
- *     kill <pid>   →  언어 서버는 죽고, deel 은 그대로 산다
- *
- * 유닉스에서 SIGTERM 을 **삼키는** 프로그램이 되어 있었다. 잡 관리자·컨테이너
- * 종료·systemd 가 전부 이 신호로 정리하는데, 그것들이 하나같이 시간을 다
- * 기다린 뒤 SIGKILL 로 때려잡게 된다. 그러면 정작 아이 정리는 못 하고 죽는다.
- *
- * 그래서 치운 다음 우리 손을 떼고 같은 신호를 자신에게 다시 보낸다. 그러면
- * 기본 동작이 돌아 128+n 로 끝난다 — 셸이 기대하는 그 값이다.
- *
- * 다만 **남이 그 신호를 맡고 있으면 안 건드린다.** 한 방 실행은 SIGINT 로
- * 턴만 끊고 살아 있어야 하고(oneshot.js), 대화 화면의 Ctrl+C 는 readline 이
- * 따로 받는다. 우리 것 말고 다른 손이 달려 있으면 그쪽 뜻이 먼저다.
- */
-/**
- * 치운 다음 그 신호로 진짜 죽어야 하나.
- *
- * 갈림을 함수로 빼 둔 까닭: 윈도우에서는 이 길을 통째로 밟아 볼 수가 없다
- * (SIGTERM 을 보내면 손이 돌기도 전에 Node 가 죽인다). 그런데 갈림 자체가
- * 틀리면 유닉스에서 한 방 실행의 Ctrl+C 가 턴만 끊는 대신 프로그램을 죽인다 —
- * 어느 판에서든 재어 볼 수 있어야 하는 자리다.
- *
- * @param 셈  이 신호에 달린 손의 수. 우리 것 하나만이면 우리가 마지막이다.
+ * 신호(SIGINT·SIGTERM)로 끝날 때도 거둔다. 손은 reap.js 에 하나만 단다 — 여기 따로 달면
+ * MCP·일감이 거둬지지 않고, 둘이 따로 달면 서로 「남이 맡았다」 고 보고 deel 이 SIGTERM 을
+ * 삼킨다(그 머리말). 다시보낼까 는 검사가 여기서 부르던 그대로 내보낸다.
  */
-export function 다시보낼까(신호, 셈 = process.listenerCount(신호)) {
-  return Number(셈) <= 1;
-}
-
-for (const 신호 of ['SIGINT', 'SIGTERM']) {
-  const 손 = () => {
-    /*
-     * 갈림을 **거두기보다 먼저** 본다. 거두고 나서 갈랐었다 — 그래서 대화 화면의 Ctrl+C 가
-     * 턴만 끊고 세션은 사는데 언어 서버는 전부 죽고 풀도 비었다(2.0.0 6회차 사냥). 남이
-     * 맡은 신호로 결국 끝나면 'exit' 그물(아이들데려가기)이 그때 거둔다.
-     */
-    if (!다시보낼까(신호)) return;   // 남이 맡고 있다 — 그쪽 뜻이 먼저다
-    아이들데려가기();
-    process.removeListener(신호, 손);
-    try { process.kill(process.pid, 신호); } catch { process.exit(신호 === 'SIGINT' ? 130 : 143); }
-  };
-  process.on(신호, 손);
-}
+신호에거두기(아이들데려가기);
+export { 다시보낼까 };
 
 /**
  * 켠 지 얼마 안 됐나.

package/src/oneshot.js

@@ -12,7 +12,7 @@
 //   여기서 루프를 다시 짜면 두 벌이 되고, 언젠가 한쪽만 고쳐진다.
 import { statSync } from 'node:fs';
 import { c, mark, clip, 화면글거르기 } from './ui/ansi.js';
-import { 규칙모으기, 정책읽기 } from './safety/policy.js';
+import { 규칙모으기, 정책읽기, 승인바닥 } from './safety/policy.js';
 import { 훅읽기 } from './safety/hooks.js';
 import { 에이전트읽기 } from './agent/agents.js';
 import { 스키마읽기, 맞나, 답에서JSON뽑기, 시킬말 as 스키마시킬말 } from './agent/outschema.js';
@@ -33,6 +33,7 @@ import { 알림채움, 알림말 } from './backend/retry.js';
 import { 전선붙이기, 세션이름짓기 } from './backend/wire.js';
 import { newId } from './agent/store.js';
 import { discover, loadCommand } from './skills/discover.js';
+import { 다붙이기 } from './backend/mcp.js';
 import { 명령들 } from './cmdnames.js';
 // 슬래시 명령을 찾는 규칙은 대화 화면과 **같은 것 하나**를 쓴다 (commands.js 의 슬래시명령찾기 머리말).
 import { 슬래시명령찾기, 비슷한슬래시명령 } from './commands.js';
@@ -46,6 +47,7 @@ import { route } from './agent/route.js';
 import { get as getWork, 보일이름 } from './agent/modes.js';
 import { 모두끝내기 as 일감모두끝내기, 일감인자 } from './tools/jobs.js';
 import { 첫이름 } from './tools/label.js';
+import { 검사설정 } from './agent/donecheck.js';
 
 /**
  * 종료코드.
@@ -91,6 +93,16 @@ export const EXIT = {
    * 이건 스키마나 시킨 말을 바꾸는 일이다.
    */
   schema: 7,
+  /*
+   * 완료 검사가 통과하지 않은 채 끝났다 (agent/donecheck.js · 2.1.0).
+   *
+   * 모델은 「다 됐습니다」 라고 했는데 사람이 정해 둔 검사(`--check` · 설정의 `check`)가
+   * 정해 둔 판수를 다 돌고도 빨갛거나, 관문에 막혀 아예 못 돌았다. 0 으로 끝내면 야간
+   * 배치가 빨간 검사 위에 초록불을 켠다 — 이 기능이 없애려던 바로 그 결말이다.
+   *
+   * 오류(1)와 가른다. 고칠 자리가 다르다 — 연결이 아니라 코드나 검사 쪽이다.
+   */
+  check: 8,
   /*
    * 인자를 잘못 줬다 — 모르는 깃발 · 값 없는 깃발 · 모르는 모드 이름 · 못 읽는 --ctx.
    *
@@ -98,7 +110,7 @@ export const EXIT = {
    * 「걸음 수 상한」 이다. `deel run --jsn …` 을 CI 에 건 사람은 오타 하나로 「일이 커서
    * 멈췄다」 를 받고 작업을 쪼개러 간다. 고칠 자리가 스크립트 한 줄인데.
    *
-   * 64 는 sysexits.h 의 EX_USAGE 다. 1~7 과 안 겹치고, 셸·CI 도구들이 「부른 모양이
+   * 64 는 sysexits.h 의 EX_USAGE 다. 1~8 과 안 겹치고, 셸·CI 도구들이 「부른 모양이
    * 틀렸다」 로 이미 알아듣는 수라 새로 지어내지 않았다. 이 경우는 모델을 한 번도 안 부른다.
    */
   usage: 64,
@@ -193,6 +205,8 @@ export async function runOnce(opts = {}) {
   let 출력스키마 = null;
   // 실패덩이에 실을 모델 이름 (사냥5 B5-10). 프로필을 찾기 전에 선 실패는 null 이다.
   let 알려진모델 = null;
+  // 붙인 MCP 서버. 아래 내놓기 가 닫는다 — 그래서 여기서 선언한다 (2.0.2 · 문 맞춤).
+  let mcp서버들 = [];
 
   const 내놓기 = (r) => {
     /*
@@ -208,6 +222,8 @@ export async function runOnce(opts = {}) {
     // 이건 아무 말 없이 한다 — 사용자가 띄우라고 한 적이 없는 것이라,
     // 껐다는 말부터 하면 "그건 또 뭐냐" 가 된다.
     언어서버다끄기().catch(() => {});
+    // 붙인 MCP 서버도 거둔다. 안 닫으면 잡이 끝난 뒤에도 남의 프로그램이 폴더를 물고 남는다.
+    for (const 서버 of mcp서버들) { try { 서버.닫기(); } catch { /* 닫다 터져도 끝맺음은 간다 */ } }
     /*
      * 문서를 글로 바꾸며 떨군 임시 파일도 거둔다 (tools/convert.js 의 임시치우기).
      *
@@ -461,6 +477,21 @@ export async function runOnce(opts = {}) {
 
   const found = discover(root);
   session.skills = found.skills;
+  /*
+   * 밖에서 붙인 도구(MCP) — 대화 화면·에디터와 **같은 규칙으로** 붙인다 (2.0.2 · 문 맞춤).
+   *
+   * 한 번 실행만 이 자리가 없었다. `.deel/mcp.json` 에 적어 둔 도구가 대화 화면에서는 되고
+   * `deel run` 에서는 **말없이 없었다** — 모델은 없는 도구 대신 셸로 돌아가고, 왜 없는지는
+   * 어디에도 안 남았다. 기본은 꺼져 있고(사람이 직접 적어야 뜬다) 봉인이면 안 띄우는 것도 같다.
+   * 못 붙은 것은 표준오류에 적는다 — 표준출력은 답 자리다.
+   */
+  const mcp붙임 = await 다붙이기(root, {
+    offline: 봉인됐나({ 깃발: opts.offline, prof, cfg }),
+    audit: new Audit(root, { 열쇠들: 열쇠묻기(conn) }),
+  }).catch((err) => ({ 서버들: [], 못한것: [{ 이름: '(전부)', 왜: String(err?.message ?? err) }] }));
+  mcp서버들 = mcp붙임.서버들;
+  session.mcp = mcp붙임.서버들;
+  for (const m of mcp붙임.못한것 ?? []) 곁(`  ${mark.warn} ${c.yellow(`MCP ${m.이름} 을 못 붙였습니다 — ${m.왜}`)}`);
   session.commands = found.commands;
   session.plugins = found.plugins;
 
@@ -549,7 +580,16 @@ export async function runOnce(opts = {}) {
   // 승인은 기본이 거부다. 반대로 하면 안 된다 — 아무도 안 보는 자리에서
   // 되돌릴 수 없는 명령이 조용히 돌아가는 것이 이 프로그램이 제일 피하려는 일이다.
   // 정말 맡기고 싶은 사람은 --yes 로 그 뜻을 명시한다.
-  const 자동승인 = opts.yes === true;
+  /*
+   * 관리 정책이 승인 바닥을 걸었으면 --yes 는 안 먹는다 (safety/policy.js 의 승인바닥).
+   * 바닥은 「바꾸기 전에 사람이 본다」 는 약속인데, --yes 는 바로 그 사람을 빼는 깃발이다.
+   * 둘이 같이 오면 정책이 이긴다 — 조용히 무시하지 않고 왜 안 먹는지 적는다.
+   */
+  const 바닥 = 승인바닥();
+  const 자동승인 = opts.yes === true && 바닥.바닥 === 'auto';
+  if (opts.yes === true && !자동승인) {
+    곁(`  ${c.yellow('⊘')} ${c.gray(`--yes 를 안 씁니다 — ${옮긴말('approve.locked', { 바닥: 바닥.바닥, 곳: 바닥.곳 ?? '' })}`)}`);
+  }
   /*
    * 사람이 적어 둔 훅을 읽는다 (safety/hooks.js).
    *
@@ -581,11 +621,15 @@ export async function runOnce(opts = {}) {
     history: new History(root),
     audit: new Audit(root, { 열쇠들: 열쇠묻기(conn) }),
     seen: new Set(),
+    // 붙은 MCP 서버. 도구를 부를 때 여기서 찾는다.
+    mcp: mcp붙임.서버들,
     skills: found.skills,
     loadedSkills: new Set(),
     // 고친 뒤 진단을 볼지 (lsp/diag.js). 아래 내놓기() 에서 반드시 거둔다 —
     // 안 거두면 배치가 끝나고도 언어 서버가 폴더를 물고 남는다.
     lsp: { 켬: true },
+    // 끝내려는 자리에서 돌릴 검사 (agent/donecheck.js). `--check` 가 설정의 check 를 이긴다.
+    완료검사: 검사설정(cfg, opts.check),
     // 되물을 사람이 없으니 기본값을 그대로 돌려준다.
     ask: async (_label, o = {}) => o?.def ?? '',
     // 엑셀 암호를 여기서 기다리면 그대로 선다. 없다고 바로 답한다 —
@@ -709,6 +753,8 @@ export async function runOnce(opts = {}) {
   let steps = 0;
   let 이번단계글 = '';   // 지금 단계에서 모델이 흘린 글. 단계가 바뀌면 비운다
   let 답 = null;
+  // 완료 검사의 마지막 결과 (agent/donecheck.js). 안 돌았으면 null 이다.
+  let 검사결과 = null;
   // 서버가 끝났다는 말 없이 멈춘 적이 있나. 뒤에 오는 done 이 이걸 못 지운다.
   let 말없이끊겼나 = false;
   // 비우느라 시킨 말 뒤가 잘렸나 (사냥5 B5-01). 무엇으로 끝났든 이것이 까닭이 된다.
@@ -881,6 +927,20 @@ export async function runOnce(opts = {}) {
           곁(`  ${c.yellow('✗')} ${c.gray(옮긴말('ev.hookBlock'))}`);
           break;
 
+        case 'check_start':
+          곁(`  ${c.cyan('⧗')} ${c.gray(옮긴말('check.start', { 판: ev.판, 최대: ev.최대, 명령: ev.명령 }))}`);
+          break;
+
+        case 'check':
+          if (ev.ok === true) 곁(`  ${mark.ok} ${c.gray(옮긴말('check.pass', { 명령: ev.명령 }))}`);
+          else if (ev.ok === false) {
+            곁(`  ${c.red('✗')} ${c.gray(옮긴말('check.fail', { 판: ev.판, 최대: ev.최대, 요약: ev.요약 }))}`);
+            // 실패 출력의 끝 몇 줄 — 배치 로그를 보는 사람이 무엇이 틀렸는지 여기서 안다.
+            for (const 줄 of String(ev.꼬리 ?? '').trim().split('\n').slice(-8)) if (줄.trim()) 곁(`     ${c.gray(줄)}`);
+            곁(`     ${c.gray(ev.판 < ev.최대 ? 옮긴말('check.retry') : 옮긴말('check.gaveUp', { 판: ev.판 }))}`);
+          } else 곁(`  ${c.yellow('⊘')} ${c.gray(옮긴말('check.skipped', { 까닭: ev.까닭 }))}`);
+          break;
+
         case 'nudge':
           곁(`  ${c.gray(`↺ ${ev.why === '요청누락'
             ? 옮긴말('ev.nudgeMissed', { n: ev.빠진?.length ?? 0 })
@@ -965,6 +1025,7 @@ export async function runOnce(opts = {}) {
         case 'done':
           reason = 'done';
           답 = ev.text ?? 이번단계글;
+          검사결과 = ev.검사 ?? null;
           break;
       }
     }
@@ -1097,6 +1158,19 @@ export async function runOnce(opts = {}) {
     }
   }
 
+  /*
+   * 모델은 끝났다고 했는데 완료 검사가 통과하지 않았다 — 종료코드 8 (위 EXIT.check).
+   *
+   * 모양 판정(7)보다 **뒤에** 본다. 모양도 틀렸으면 그쪽을 먼저 고쳐야 답을 읽을 수 있다.
+   * 아무것도 안 바꾼 턴은 검사가 안 돌아 검사결과가 null 이다 — 그건 실패가 아니다.
+   */
+  if (reason === 'done' && 검사결과 && 검사결과.ok !== true) {
+    reason = 'check';
+    why = 검사결과.ok === false
+      ? 옮긴말('check.gaveUp', { 판: 검사결과.판 }) + ` — ${검사결과.명령}`
+      : 옮긴말('check.skipped', { 까닭: 검사결과.까닭 });
+  }
+
   /*
    * SIGINT 손은 **되물음까지 끝난 뒤에** 뗀다 (사냥5 B5-02).
    *
@@ -1143,6 +1217,14 @@ export async function runOnce(opts = {}) {
     // 모양을 못 박았을 때만 실린다. --json 으로 받는 쪽은 text 를 다시 파싱할
     // 필요 없이 이 칸을 그대로 쓰면 된다.
     ...(스키마값 !== null ? { schema: 스키마값 } : {}),
+    // 완료 검사를 돌렸을 때만 실린다. ok 가 null 이면 못 돌린 것이다(why 에 까닭).
+    ...(검사결과 ? {
+      check: {
+        ok: 검사결과.ok, command: 검사결과.명령, rounds: 검사결과.판, max: 검사결과.최대,
+        ...(검사결과.요약 ? { summary: 검사결과.요약 } : {}),
+        ...(검사결과.까닭 ? { why: 검사결과.까닭 } : {}),
+      },
+    } : {}),
     ms: Date.now() - t0,
     ...(why ? { why } : {}),
   });

package/src/pack/selfpack.js

@@ -34,7 +34,7 @@ function walk(dir, base, out) {
   return out;
 }
 
-export function shippedFiles(root = repoRoot()) {
+function shippedFiles(root = repoRoot()) {
   const out = [];
   for (const d of SHIP) if (existsSync(join(root, d))) walk(join(root, d), root, out);
   for (const f of SHIP_FILES) if (existsSync(join(root, f))) out.push(f);
@@ -59,7 +59,7 @@ const PROBES = [
     note: '없어야 정상입니다' },
 ];
 
-export function scanCalls(root = repoRoot(), files = shippedFiles(root)) {
+function scanCalls(root = repoRoot(), files = shippedFiles(root)) {
   const found = Object.fromEntries(PROBES.map((p) => [p.id, []]));
   for (const f of files) {
     if (!f.endsWith('.js')) continue;

package/src/pack/zip.js

@@ -56,13 +56,26 @@ const UTF8_NAMES = 0x0800;   // 플래그 11번 비트 — 이름이 UTF-8 이
  */
 export const 풀기총상한 = 256 * 1024 * 1024;
 
+/*
+ * ── zip64 없이 담을 수 있는 끝 (2.0.2 · Z5) ───────────────────────────────────
+ *
+ * 이 zip 은 zip64 를 안 쓴다. 항목 수·이름 길이는 16비트, 크기·자리는 32비트 칸이다.
+ * 넘으면 `writeUInt16LE` 가 날것 RangeError(「must be >= 0 and <= 65535」)를 던졌다 —
+ * 그것도 파일 수만 개를 **다 눌러 담은 뒤** 맨 끝 표식을 쓰다가. 무엇이 넘었는지 사람
+ * 말로, 넘는 순간에 멈춘다. 검사에서 끝을 좁혀 잴 수 있게 한도는 넘겨받는다.
+ */
+export const zip한도 = { 개수: 0xffff, 이름: 0xffff, 크기: 0xffffffff };
+
 /**
  * @param {Array<{name:string, data:Buffer, mtime?:Date, mode?:number}>} entries
  *        name 은 zip 안에서의 경로. 구분자는 항상 '/'.
  *        mode 는 유닉스 권한(예: 0o755). 실행 파일에 필요하다.
  * @returns {Buffer}
  */
-export function makeZip(entries) {
+export function makeZip(entries, 한도 = zip한도) {
+  if (entries.length > 한도.개수) {
+    throw new Error(`zip 에 담을 파일이 ${entries.length.toLocaleString('en-US')}개입니다 — 한 묶음에 ${한도.개수.toLocaleString('en-US')}개까지 담습니다 (zip64 는 만들지 않습니다). 나눠서 묶으세요.`);
+  }
   const locals = [];
   const central = [];
   let offset = 0;
@@ -77,6 +90,10 @@ export function makeZip(entries) {
     const useDeflate = packed.length < raw.length;
     const body = useDeflate ? packed : raw;
     const method = useDeflate ? 8 : 0;
+    if (nameBuf.length > 한도.이름) throw new Error(`zip 에 담을 이름이 너무 깁니다 (${nameBuf.length}바이트) — ${한도.이름}바이트까지: ${e.name.slice(0, 80)}…`);
+    if (raw.length > 한도.크기 || offset + 30 + nameBuf.length + body.length > 한도.크기) {
+      throw new Error(`zip 이 zip64 없이 담는 크기(${한도.크기.toLocaleString('en-US')}바이트 · 약 4GB)를 넘습니다 — 나눠서 묶으세요 (넘은 자리: ${e.name})`);
+    }
 
     const when = 담을시각(e.mtime ?? new Date());
     const time = dosTime(when);

package/src/plugins/manage.js

@@ -6,7 +6,7 @@ import { execFile } from 'node:child_process';
 import { homeDir } from '../config.js';
 import { join, dirname, basename, resolve, relative, sep } from 'node:path';
 import {
-  existsSync, mkdirSync, writeFileSync, readFileSync, rmSync,
+  existsSync, mkdirSync, writeFileSync, readFileSync, rmSync, renameSync,
   readdirSync, statSync,
 } from 'node:fs';
 import { untargz, stripTop, 밖을가리키는것 } from '../pack/tar.js';
@@ -107,13 +107,26 @@ export function 묶음풀기(dest, files) {
    * 고 하고 하나만 남겼다. 쓰기 전에 전부 재 보고 사람 말로 거절한다.
    */
   const 뿌리 = resolve(dest);
-  const 자리들 = new Map();                 // 소문자 상대 자리 → 적힌 이름
+  /*
+   * ── 쓸 이름도 **잰 이름과 같게** (2.0.2 · P3 · P1) ──────────────────────────
+   *
+   * 아래 재기는 역슬래시를 빗금으로 보고 쟀는데, 쓸 때는 적힌 이름 그대로 `join` 했다.
+   * 윈도에서는 둘이 같지만 리눅스·맥에서는 역슬래시가 **이름 글자**라, 윈도에서 만든
+   * 묶음의 `sub\file.txt` 가 `sub` 폴더 안이 아니라 뿌리에 한 파일로 풀렸다 — 스킬이
+   * 제자리를 못 찾는다. 이름을 한 번 빗금으로 편 것을 재기와 쓰기가 같이 쓴다.
+   *
+   * 같은 자리 견주기에는 NFC 도 맞춘다. 맥은 `한글`(NFC)과 `한글`(NFD)을 한 파일로
+   * 보므로, 두 꼴이 같이 든 묶음은 맥에서 하나가 말없이 사라진다. 대소문자만 다른
+   * 이름과 같은 대접으로 묶음째 거절한다.
+   */
+  const 편이름 = (f) => String(f.name ?? '').replace(/\\/g, '/');
+  const 자리들 = new Map();                 // 소문자·NFC 상대 자리 → 적힌 이름
   for (const f of files) {
-    const 상대 = relative(뿌리, resolve(뿌리, String(f.name ?? '').replace(/\\/g, '/'))).replace(/\\/g, '/');
+    const 상대 = relative(뿌리, resolve(뿌리, 편이름(f))).replace(/\\/g, '/');
     if (!상대) return { error: `묶음 안에 풀 폴더 그 자체를 가리키는 파일이 있습니다 — 풀지 않았습니다: ${f.name}` };
-    const 열쇠 = 상대.toLowerCase();
+    const 열쇠 = 상대.normalize('NFC').toLowerCase();
     if (자리들.has(열쇠)) {
-      return { error: `묶음 안에 같은 자리를 가리키는 이름이 둘 있습니다(대소문자만 다를 수 있음) — 풀지 않았습니다: ${자리들.get(열쇠)} · ${f.name}` };
+      return { error: `묶음 안에 같은 자리를 가리키는 이름이 둘 있습니다(대소문자나 한글 자모 꼴만 다를 수 있음) — 풀지 않았습니다: ${자리들.get(열쇠)} · ${f.name}` };
     }
     자리들.set(열쇠, f.name);
   }
@@ -126,13 +139,32 @@ export function 묶음풀기(dest, files) {
   }
   rmSync(dest, { recursive: true, force: true });
   for (const f of files) {
-    const p = join(dest, f.name);
+    const p = join(dest, 편이름(f));
     mkdirSync(dirname(p), { recursive: true });
     writeFileSync(p, f.data);
   }
   return { 푼것: files.length };
 }
 
+/*
+ * ── git 없이 받을 주소들 (2.0.2 · P5) ─────────────────────────────────────────
+ *
+ * `#v1.0.0` 처럼 **태그**를 적어도 `refs/heads/` 만 물어서, git 이 없는 PC 에서는 늘
+ * 「받지 못했습니다 — 가지 이름을 확인하세요」 였다. git 이 있으면 `clone --branch` 가
+ * 태그도 받으니, 같은 명령이 git 유무에 따라 되고 안 됐다. 가지를 먼저 묻고 없으면
+ * 태그를 묻는다(같은 이름이면 git 도 가지를 먼저 고른다).
+ */
+export function 받을주소들(spec) {
+  const 뿌리 = `https://codeload.github.com/${spec.owner}/${spec.repo}/tar.gz`;
+  if (spec.ref) {
+    return [
+      { branch: spec.ref, url: `${뿌리}/refs/heads/${spec.ref}` },
+      { branch: spec.ref, url: `${뿌리}/refs/tags/${spec.ref}` },
+    ];
+  }
+  return ['main', 'master'].map((b) => ({ branch: b, url: `${뿌리}/refs/heads/${b}` }));
+}
+
 // 받는 방법 두 가지. git 이 있으면 clone, 없으면 tarball 을 내려받아 푼다.
 async function fetchInto(spec, dest, onStep) {
   if (await has('git')) {
@@ -150,8 +182,7 @@ async function fetchInto(spec, dest, onStep) {
 
   onStep?.('tarball 내려받기');
   if (isOffline()) return { error: '오프라인 모드입니다 — 받아 올 수 없습니다. 풀어 놓은 폴더 경로를 주세요.' };
-  for (const branch of spec.ref ? [spec.ref] : ['main', 'master']) {
-    const url = `https://codeload.github.com/${spec.owner}/${spec.repo}/tar.gz/refs/heads/${branch}`;
+  for (const { branch, url } of 받을주소들(spec)) {
     // 사용자가 이 명령을 친 동안만 github 를 연다. 끝나면 바로 닫는다.
     const close = allowTemporarily(url);
     let gz;
@@ -183,7 +214,7 @@ async function fetchInto(spec, dest, onStep) {
     if (푼것.error) return { error: 푼것.error };
     return { how: 'tarball', branch };
   }
-  return { error: '받지 못했습니다 — 저장소 주소나 가지 이름을 확인하세요' };
+  return { error: '받지 못했습니다 — 저장소 주소나 가지·태그 이름을 확인하세요' };
 }
 
 /**
@@ -246,7 +277,7 @@ export function 이름한칸(이름) {
  * 자르는 자가 언젠가 틀릴 수 있다. 그때 마지막으로 서는 그물이다. 지우고
  * 쓰는 자리라 두 겹으로 막는다.
  */
-export function 플러그인자리인가(base, dest) {
+function 플러그인자리인가(base, dest) {
   const 뿌리 = resolve(base);
   const 갈곳 = resolve(dest);
   return 갈곳 !== 뿌리 && 갈곳.startsWith(뿌리 + sep);
@@ -312,7 +343,7 @@ export async function install(spec, 옵션 = {}) {
   }
 }
 
-async function 설치하기(spec, { home = homeDir(), onStep } = {}, 치울것 = []) {
+async function 설치하기(spec, { home = homeDir(), onStep, 복사 = copyDir } = {}, 치울것 = []) {
   const base = pluginsDir(home);
 
   // 이미 풀어 놓은 폴더를 그대로 넣는 길. 오프라인 기기에서 이쪽을 쓴다.
@@ -383,9 +414,43 @@ async function 설치하기(spec, { home = homeDir(), onStep } = {}, 치울것 =
     return { error: `스킬도 명령도 없습니다. 플러그인이 맞는지 확인하세요 (${isLocal ? asPath : parsed.owner + '/' + parsed.repo})` };
   }
 
-  rmSync(dest, { recursive: true, force: true });
+  /*
+   * ── 옛것을 **먼저 지우지 않는다** (2.0.2 · P7) ──────────────────────────────
+   *
+   * 다시 설치(업데이트)는 옛 폴더를 지우고 새것을 베꼈다. 베끼다 넘어지면(디스크가
+   * 꽉 참 · 잠긴 파일 · 긴 경로) **둘 다 잃었다** — 옛것은 지웠고 새것은 반쪽이다.
+   * 업데이트 한 번에 쓰던 플러그인이 사라지는 것이다.
+   *
+   * 옛것을 점 이름(`.old-…` — list() 가 안 보는 이름)으로 비켜 두고 베낀다. 다 베끼면
+   * 비켜 둔 것을 버리고, 넘어지면 반쪽을 치우고 비켜 둔 것을 제자리로 되돌린다.
+   * 비키기(rename)부터 안 되면(윈도에서 그 폴더의 파일을 연 프로그램이 있으면 흔하다)
+   * 아무것도 안 건드리고 그렇다고 말한다.
+   */
   mkdirSync(dirname(dest), { recursive: true });
-  copyDir(tmp, dest, { skipped: 건너뛴것 });
+  const 옛것있나 = existsSync(dest);
+  const 비켜둘곳 = join(base, `.old-${name}-${process.pid}-${Date.now()}`);
+  if (옛것있나) {
+    try { renameSync(dest, 비켜둘곳); }
+    catch (err) {
+      rmSync(tmp, { recursive: true, force: true });
+      return { error: `깔려 있던 ${name} 을 비키지 못해 다시 설치하지 않았습니다 — 쓰던 것은 그대로입니다 (${err?.code ?? err?.message ?? err}). 그 폴더의 파일을 연 프로그램을 닫고 다시 하세요.` };
+    }
+  }
+  try {
+    복사(tmp, dest, { skipped: 건너뛴것 });
+  } catch (err) {
+    try { rmSync(dest, { recursive: true, force: true }); } catch { /* 반쪽을 못 치우면 아래 되돌리기가 넘어진다 — 그 말도 한다 */ }
+    let 되돌림 = '쓰던 것은 그대로입니다';
+    if (옛것있나) {
+      try { renameSync(비켜둘곳, dest); }
+      catch { 되돌림 = `쓰던 것은 ${비켜둘곳} 에 남아 있습니다 — 폴더 이름을 ${name} 으로 되돌리면 됩니다`; }
+    } else {
+      되돌림 = '반쪽은 치웠습니다';
+    }
+    rmSync(tmp, { recursive: true, force: true });
+    return { error: `${name} 을 베끼지 못해 설치하지 않았습니다 — ${되돌림} (${err?.code ?? err?.message ?? err})` };
+  }
+  if (옛것있나) { try { rmSync(비켜둘곳, { recursive: true, force: true }); } catch { /* 못 버려도 list() 는 점 이름을 안 본다 */ } }
   rmSync(tmp, { recursive: true, force: true });
   // 개수는 **깔린 자리**에서 다시 센다. 복사하다 빠진 것이 여기서 빠진다.
   const counts = countIn(dest);
@@ -569,7 +634,9 @@ export function pack(outFile, { home = homeDir(), only = null } = {}) {
   ].join('\n');
   entries.unshift({ name: '사용안내.txt', data: Buffer.from(manifest, 'utf8') });
 
-  const zip = makeZip(entries);
+  // 한도(파일 65,535개 · 4GB)를 넘으면 makeZip 이 사람 말로 던진다 — 명령째 죽지 않게 받아 올린다 (2.0.2 · Z5).
+  let zip;
+  try { zip = makeZip(entries); } catch (err) { return { error: String(err?.message ?? err) }; }
   mkdirSync(dirname(outFile), { recursive: true });
   writeFileSync(outFile, zip);
   return { out: outFile, plugins: included, files: entries.length, skipped, bytes: zip.length, manifest };