deel-local-cli 2.1.2 → 2.1.3

package/src/backend/probe.js

@@ -13,6 +13,7 @@ import {
   assistantMessage, toolMessage,
 } from './adapter.js';
 import { 벤더 } from './toolfit.js';
+import { 글속부름 } from './textcalls.js';
 import { 세션이름짓기, 기본카드 } from './wire.js';
 import { 말 } from '../i18n/index.js';
 
@@ -446,18 +447,31 @@ export async function probe(conn, onStep = () => {}) {
    * 판정한다 — 위 머리말과 거꾸로 된 틀림이다.
    */
   const 모양틀림 = 잘린인자 && tcalls[0]?.argsCut === false;
+  /*
+   * 모양만 틀린 인자는 이제 deel 이 느슨하게 읽는다 (2.1.3 · adapter.js 인자읽기). 읽혔으니 「거절당한다」
+   * 는 아니지만, 이 모델이 규격 밖 JSON 을 쓴다는 것은 남긴다 — 다른 도구는 그걸 거절한다.
+   */
+  const 고쳐읽음 = gotCall && tcalls[0]?.argsRepaired === true;
+  /*
+   * 도구를 **글로** 부르는 모델 (2.1.3 · backend/textcalls.js). 서버가 그 모델의 부름 꼴을 몰라
+   * tool_calls 는 비었는데 답 글에 <tool_call> 이 실렸다. 여태는 「글로만 답합니다」 로 적어 도구를
+   * 못 쓰는 모델처럼 보였다. deel 은 그 글을 알아듣는다 — 경고로 두고, 서버의 도구 틀을 켜라고 적는다.
+   */
+  const 글로부름 = !gotCall && tl.ok ? 글속부름(읽기(tl).content, [READ_TOOL.function.name]) : null;
   const 원문에있나 = 잘린인자 && !모양틀림 && String(tcalls[0]?.rawArgs ?? '').includes('config');
   add({
     id: 'tools',
     label: '도구 호출',
-    status: gotCall ? (argOk || 원문에있나 ? 'ok' : 'warn') : 'no',
+    status: gotCall ? (고쳐읽음 ? 'warn' : argOk || 원문에있나 ? 'ok' : 'warn') : 글로부름 ? 'warn' : 'no',
     detail: gotCall
-      ? `${tcalls[0]?.name} 호출됨${argOk ? ''
+      ? `${tcalls[0]?.name} 호출됨${고쳐읽음 ? ' — 인자 JSON 모양이 틀려(홑따옴표·끝 쉼표 같은 것) deel 이 느슨하게 읽었습니다'
+        : argOk ? ''
         : 원문에있나 ? ` — 인자가 우리 상한(${도구상한}토큰)에 잘렸을 뿐, 값은 제대로 왔습니다`
           : 모양틀림 ? ' — 인자 JSON 모양이 틀렸습니다 (홑따옴표·끝 쉼표 같은 것 — 편집 도구가 자주 거절당합니다)'
           : 잘린인자 ? ' — 인자 JSON 이 잘려 왔습니다 (상한을 올려 다시 보세요)'
             : ' — 인자가 부정확, 편집 신뢰성 작업이 더 필요합니다'}`
-      : tl.ok ? '도구를 안 부르고 글로만 답합니다' : serverMessage(tl),
+      : 글로부름 ? '도구를 글로 부릅니다(<tool_call> 같은 꼴) — deel 이 알아듣지만, 서버의 도구 틀(채팅 템플릿)을 켜면 더 낫습니다'
+        : tl.ok ? '도구를 안 부르고 글로만 답합니다' : serverMessage(tl),
     ms: tl.ms,
   });
   facts.tools = gotCall;

package/src/backend/textcalls.js

@@ -0,0 +1,196 @@
+/*
+ * 글 속에 적힌 도구 부름을 건진다 (2.1.3).
+ *
+ * ── 왜 필요한가 ─────────────────────────────────────────────────────────
+ *
+ * 작은 모델은 도구를 **글로** 부른다. 서버가 그 모델의 부름 꼴을 모르거나(채팅 틀이 없는 GGUF ·
+ * 오래된 Ollama 틀 · 사내 게이트웨이의 변환 누락), 모델이 배운 꼴과 서버가 기다리는 꼴이 다르면
+ * `tool_calls` 는 비어 오고 답 글에 이런 것이 실린다.
+ *
+ *     <tool_call>{"name": "Read", "arguments": {"file_path": "a.js"}}</tool_call>     Hermes · Qwen
+ *     <function=Read>{"file_path": "a.js"}</function>                                 Llama 3.1
+ *     <tool_call><function=Read><parameter=file_path>a.js</parameter></function>…      Qwen3-Coder
+ *     [TOOL_CALLS] [{"name": "Read", "arguments": {...}}]                              Mistral
+ *     ```json {"name": "Read", "arguments": {...}} ```                                 표 없는 것
+ *
+ * 여태 이것을 「도구를 안 부르고 글로만 답했다」 로 읽고 턴을 끝냈다. 모델은 일을 하려 했는데 우리가
+ * 못 알아들은 것이다. 이제 **우리가 내준 도구 이름**으로 적힌 것만 건져 진짜 부름으로 돌린다.
+ * 건진 부름도 네이티브 부름과 같은 관문(모드 · 승인 · 정책 바닥)을 지난다 — 건졌다고 덜 묻지 않는다.
+ *
+ * ── 무엇을 안 건지나 ────────────────────────────────────────────────────
+ *
+ *   · 내준 적 없는 이름. 글 속 예시(`{"name": "search", ...}`)를 부름으로 읽으면 안 된다. 한 덩이에
+ *     모르는 이름이 하나라도 섞이면 그 덩이는 통째로 안 건진다.
+ *   · 울타리(```) 안에 든 표는 예시다 — 형식을 설명하는 답이 그렇게 적는다.
+ *   · 울타리나 맨 JSON 꼴은 **답이 거의 그것 하나뿐일 때만** 건진다. 설명 글 사이에 든 예시를
+ *     부름으로 읽으면, 쓰기·명령 도구는 사람이 시키지 않은 일을 한다. 울타리가 둘 이상이면 예시를
+ *     늘어놓은 글로 본다. 표(<tool_call> 따위)가 붙은 꼴은 모델이 부르려고 쓴 것이라 어디에 있든 건진다.
+ */
+
+import { 읽어보기 } from './loosejson.js';
+
+const 객체인가 = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+
+/*
+ * 이름과 인자를 한 덩이에서 뽑는다. 모델마다 칸 이름이 다르다 —
+ * `arguments`(OpenAI · Hermes) · `parameters`(Llama) · `args` · `input`(Anthropic 을 흉내 낸 것).
+ * `function: {name, arguments}` 로 한 겹 싸서 오기도 한다.
+ */
+function 부름꼴(v) {
+  if (!객체인가(v)) return null;
+  const 속 = 객체인가(v.function) ? v.function : v;
+  const 이름 = typeof 속.name === 'string' ? 속.name : null;
+  if (!이름) return null;
+  let 인자 = 속.arguments ?? 속.parameters ?? 속.args ?? 속.input ?? {};
+  if (typeof 인자 === 'string') 인자 = 읽어보기(인자.trim() || '{}');
+  if (!객체인가(인자)) return null;
+  return { 이름, 인자 };
+}
+
+/** 한 덩이 JSON 이 부름 하나거나 부름 여럿의 배열이면 [{이름, 인자}], 아니면 null. */
+function 부름들로(v) {
+  const 목록 = Array.isArray(v) ? v : [v];
+  if (!목록.length) return null;
+  const out = [];
+  for (const x of 목록) {
+    const 하나 = 부름꼴(x);
+    if (!하나) return null;
+    out.push(하나);
+  }
+  return out;
+}
+
+/*
+ * Qwen3-Coder 꼴: <function=이름> <parameter=칸>값</parameter> … </function>. 값은 JSON 이면 JSON 으로.
+ *
+ * 수는 **글자 그대로 되돌아올 때만** 수로 읽는다. 칸 값은 날글이라 `01234`(번호) · `1.50`(판) 도 온다 —
+ * 수로 읽으면 앞 0 과 끝 0 이 사라진 다른 값이 도구로 간다(2차 눈이 짚었다).
+ */
+function 칸꼴(몸) {
+  const 인자 = {};
+  const 칸무늬 = /<parameter=([^>\s]+)>\s*([\s\S]*?)\s*<\/parameter>/g;
+  let m;
+  let 있었나 = false;
+  while ((m = 칸무늬.exec(몸))) {
+    있었나 = true;
+    const 날것 = m[2];
+    const t = 날것.trim();
+    let 읽은;
+    if (/^[[{"]|^(?:true|false|null|True|False|None)$/.test(t)) 읽은 = 읽어보기(t);
+    else if (/^-?\d/.test(t) && String(Number(t)) === t) 읽은 = Number(t);
+    인자[m[1]] = 읽은 === undefined ? 날것 : 읽은;
+  }
+  return 있었나 ? 인자 : null;
+}
+
+/*
+ * <function=이름> 덩이들. 한 <tool_call> 안에 여럿이 올 수 있다 — 한 무늬로 통째로 잡으면 앞 것의 끝 표까지
+ * 몸으로 삼켜 뒤 것 인자로 부름 **하나**가 됐다. 다음 <function= 앞에서도 끊는다.
+ */
+function 함수덩이들(몸) {
+  const out = [];
+  const 무늬 = /<function=([^>\s]+)>\s*([\s\S]*?)\s*(?:<\/function>|(?=<function=)|$)/g;
+  let m;
+  while ((m = 무늬.exec(몸))) {
+    const 인자 = 칸꼴(m[2]) ?? (m[2].trim() ? 읽어보기(m[2].trim()) : {});
+    if (!객체인가(인자)) return null;
+    out.push({ 이름: m[1], 인자 });
+  }
+  return out.length ? out : null;
+}
+
+/**
+ * 글 속 부름을 건진다.
+ *
+ * @param {string} 글      모델이 낸 답 글
+ * @param {string[]} 이름들 이번에 내준 도구 이름들
+ * @returns {{부름: Array<{name, args}>, 남은글: string} | null}  건진 것이 없으면 null
+ */
+export function 글속부름(글, 이름들) {
+  const s = String(글 ?? '');
+  if (!s.trim() || !이름들?.length) return null;
+  // 이름은 대소문자를 안 가려 맞추고, 돌려줄 때는 우리 이름으로 적는다(read → Read).
+  const 우리이름 = new Map(이름들.map((n) => [String(n).toLowerCase(), String(n)]));
+  const 맞춤 = (n) => 우리이름.get(String(n ?? '').trim().toLowerCase()) ?? null;
+  const 부름 = [];
+  const 뗄곳 = [];
+  const 담기 = (목록, 시작, 끝) => {
+    const 맞춘 = [];
+    for (const x of 목록) {
+      const 이름 = 맞춤(x.이름);
+      if (!이름) return false;
+      맞춘.push({ name: 이름, args: x.인자 });
+    }
+    부름.push(...맞춘);
+    뗄곳.push([시작, 끝]);
+    return true;
+  };
+
+  // ── 1. 표가 붙은 꼴 — 울타리 밖이면 어디에 있든 건진다 ──────────────────
+  // 울타리(```) 안의 표는 형식을 보여 주는 예시다. 건지면 설명하다 적은 명령이 돈다.
+  // 안 닫힌 울타리는 글 끝까지다 — 길이 제한으로 잘린 답이 예시를 열어 둔 채 끝난다.
+  const 울타리자리 = [...s.matchAll(/```[\s\S]*?(?:```|$)/g)].map((u) => [u.index, u.index + u[0].length]);
+  const 울안 = (i) => 울타리자리.some(([a, b]) => i >= a && i < b);
+  // <tool_call> … </tool_call> (끝 표 없이 글이 끝나도 받는다 — 서버가 멈춤 낱말로 끝 표를 떼는 일이 있다).
+  // 몸은 다음 <tool_call> 을 넘지 않는다 — 말로 꺼낸 표 하나가 뒤따르는 진짜 부름까지 몸으로 삼켰다.
+  const 표무늬 = /<tool_call>\s*((?:(?!<tool_call>)[\s\S])*?)\s*(?:<\/tool_call>|(?=<tool_call>)|$)/g;
+  let m;
+  while ((m = 표무늬.exec(s))) {
+    const 몸 = m[1];
+    if (!몸.trim() || 울안(m.index)) continue;
+    if (몸.trim().startsWith('<function=')) {
+      const 목록 = 함수덩이들(몸);
+      if (목록) 담기(목록, m.index, m.index + m[0].length);
+      continue;
+    }
+    const 목록 = 부름들로(읽어보기(몸.trim()));
+    if (목록) 담기(목록, m.index, m.index + m[0].length);
+  }
+  // <function=이름>{…}</function> 이 <tool_call> 밖에 홀로 온 꼴 (Llama 3.1)
+  const 함수무늬 = /<function=([^>\s]+)>\s*([\s\S]*?)\s*<\/function>/g;
+  while ((m = 함수무늬.exec(s))) {
+    if (울안(m.index) || 뗄곳.some(([a, b]) => m.index >= a && m.index < b)) continue;
+    const 인자 = 칸꼴(m[2]) ?? (m[2].trim() ? 읽어보기(m[2].trim()) : {});
+    if (객체인가(인자)) 담기([{ 이름: m[1], 인자 }], m.index, m.index + m[0].length);
+  }
+  // [TOOL_CALLS] [ … ] (Mistral) — 뒤는 JSON 배열 하나. 배열 뒤에 말이 붙기도 해서, 닫는 ] 를 뒤에서부터
+  // 하나씩 대 보며 부름 배열로 읽히는 첫 자리까지만 뗀다.
+  const 미스트랄 = /\[TOOL_CALLS\]\s*(?=\[)/.exec(s);
+  if (미스트랄 && !울안(미스트랄.index)) {
+    const 시작 = 미스트랄.index + 미스트랄[0].length;
+    for (let 끝 = s.lastIndexOf(']'), 번 = 0; 끝 > 시작 && 번 < 20; 끝 = s.lastIndexOf(']', 끝 - 1), 번++) {
+      const 목록 = 부름들로(읽어보기(s.slice(시작, 끝 + 1)));
+      if (!목록) continue;
+      담기(목록, 미스트랄.index, 끝 + 1);
+      break;
+    }
+  }
+  if (부름.length) return 마무리(s, 부름, 뗄곳);
+
+  // ── 2. 울타리·맨 JSON — 답이 거의 그것뿐일 때만 ─────────────────────
+  const 곁글한도 = 200;
+  const 울타리무늬 = /```(?:json|tool_call|tool|function)?\s*\n?([\s\S]*?)\n?```/gi;
+  const 울타리들 = [...s.matchAll(울타리무늬)];
+  // 울타리가 **하나일 때만** 본다. 둘 이상이면 예시를 늘어놓은 글이다 — 부름 여럿은 한 울타리에 배열로 온다.
+  if (울타리들.length === 1) {
+    const u = 울타리들[0];
+    const 목록 = 부름들로(읽어보기(u[1].trim()));
+    const 곁글 = (s.slice(0, u.index) + s.slice(u.index + u[0].length)).trim();
+    if (목록 && 곁글.length <= 곁글한도 && 담기(목록, u.index, u.index + u[0].length)) return 마무리(s, 부름, 뗄곳);
+    return null;
+  }
+  if (울타리들.length) return null;
+  const 맨 = s.trim();
+  if (/^[[{]/.test(맨)) {
+    const 목록 = 부름들로(읽어보기(맨));
+    if (목록 && 담기(목록, 0, s.length)) return 마무리(s, 부름, 뗄곳);
+  }
+  return null;
+}
+
+function 마무리(s, 부름, 뗄곳) {
+  const 차례 = [...뗄곳].sort((a, b) => b[0] - a[0]);
+  let 남은 = s;
+  for (const [a, b] of 차례) 남은 = 남은.slice(0, a) + 남은.slice(b);
+  return { 부름, 남은글: 남은.replace(/\n{3,}/g, '\n\n').trim() };
+}

package/src/commands.js

@@ -2,6 +2,7 @@
 import { writeFileSync, existsSync } from 'node:fs';
 import { 마지막할당량, 할당량말, 아슬아슬한가 } from './backend/quota.js';
 import { 세션요금, 돈셈, 돈말, 어디서온값, 요금적는법 } from './backend/price.js';
+import { 생성속도 } from './agent/session.js';
 import { join } from 'node:path';
 import { c, say, rule, pad, mark, width, clip } from './ui/ansi.js';
 import { compact } from './agent/compact.js';
@@ -83,6 +84,8 @@ import { list as listSessions } from './agent/store.js';
 import { MODES as WORK_MODES, ORDER as WORK_ORDER, normalize as normWork, get as getWork, canWrite, 보일이름, 보일한줄 } from './agent/modes.js';
 import { COMMANDS, 설정남기기 } from './commands/common.js';
 import { 딴이름들 } from './cmdnames.js';
+// 슬래시 명령 찾기는 src/slash.js 에 있다 — deel run 이 이 파일 전체를 안 읽게 (2.1.3).
+import { 슬래시명령찾기, 비슷한슬래시명령, MCP프롬프트펴기 } from './slash.js';
 import { doPlugin, 미리보기, showSkills, 미리보기끄기 } from './commands/extend.js';
 import { help, showLevel, 강조, showThink, showContext, showWork } from './commands/view.js';
 import { 갈래명령, 증거명령, 붙여넣기명령, 리뷰명령, 커밋명령, 카드명령, 못박기명령, 배움명령, 바뀐것보기 } from './commands/work.js';
@@ -177,39 +180,8 @@ function 비슷한이름(친것, 이름들) {
     .map(([n]) => n);
 }
 
-/** `ext:ReviewCode` 의 꼬리 — 언제나 낮춰서 돌려준다. 찾기와 「비슷한 것」 이 같은 잣대를 쓰게 한다. */
-const 꼬리이름 = (이름) => String(이름 ?? '').split(':').pop().toLowerCase();
-
-/*
- * ── 이 PC 에서 찾은 슬래시 명령을 이름으로 찾는다 ───────────────────────
- *
- * 대화 화면(아래 default 갈래)과 배치(oneshot.js)가 **같은 규칙**을 써야 한다. 같은 글자를
- * 쳤는데 창에 따라 되고 안 되면 사람은 어느 쪽을 믿을지 정할 수 없다. 그래서 두 벌로 적지
- * 않고 여기 한 군데에 둔다.
- *
- * 찾는 차례는 셋이다 — 적은 그대로 · 대소문자 무시 · 꼬리 이름.
- * 마지막 칸이 `x.name.split(':').pop() === 낮춘` 이었다 (8회차 그밖 명령2). 왼쪽은 파일에
- * 적힌 그대로고 오른쪽은 낮춘 말이라 둘이 만날 수가 없다. `ext:ReviewCode` 는 `/ReviewCode`
- * 로도 `/reviewcode` 로도 「모르는 명령」 이었고, 「비슷한 것」 에도 안 떴다 — 깔려 있는
- * 명령이 어느 길로도 안 보이는 자리다. 배치에서는 그대로 1 로 선다.
- */
-export function 슬래시명령찾기(목록, 부른이름) {
-  const 것들 = 목록 ?? [];
-  const 낮춘 = String(부른이름 ?? '').toLowerCase();
-  return 것들.find((x) => x.name === 부른이름)
-    ?? 것들.find((x) => x.name.toLowerCase() === 낮춘)
-    ?? 것들.find((x) => 꼬리이름(x.name) === 낮춘)
-    ?? null;
-}
-
-/** 못 찾았을 때 「비슷한 것」 으로 늘어놓을 것. 찾기와 같은 잣대(낮춘 꼬리)를 쓴다. */
-export function 비슷한슬래시명령(목록, 부른이름, 몇 = 5) {
-  const 낮춘 = String(부른이름 ?? '').toLowerCase();
-  if (!낮춘) return [];
-  return (목록 ?? [])
-    .filter((x) => x.name.toLowerCase().includes(낮춘) || 낮춘.includes(꼬리이름(x.name)))
-    .slice(0, 몇);
-}
+// 부르던 자리(검사 · 다른 모듈)가 그대로 쓰게 여기서도 내보낸다.
+export { 슬래시명령찾기, 비슷한슬래시명령, MCP프롬프트펴기 };
 
 export async function handle(line, session, ctx) {
   // 일본어·중국어 입력기의 전각 빗금(／help). 그대로 두면 명령이 말이 되어 모델에게 간다(ui/complete.js).
@@ -1192,6 +1164,9 @@ export async function handle(line, session, ctx) {
         })}`);
       }
       say(`  ${c.gray(pad(말('cost.toolMs'), 14))} ${말('unit.sec', { n: (session.usage.ms / 1000).toFixed(1) })}`);
+      // 생성 속도 — 흘려받은 부름만 잰다. 못 쟀으면 줄을 안 적는다 (session.js 의 생성속도).
+      const 속도 = 생성속도(session.usage);
+      if (속도 !== null) say(`  ${c.gray(pad(말('cost.speed'), 14))} ${속도} tok/s`);
       // 서버가 잠깐 막아 다시 부른 횟수. 0 이면 안 적는다 — 없는 일을 줄로 남기면 표만 길어진다.
       if (session.usage.retries) say(`  ${c.gray(pad(말('cost.retries'), 14))} ${말('unit.calls', { n: session.usage.retries })}`);
       say(`  ${c.gray(pad(말('cost.elapsed'), 14))} ${말('unit.min', { n: mins })}`);
@@ -1300,7 +1275,7 @@ export async function handle(line, session, ctx) {
        * 있는 그대로 적는다 (safety/authcmd.js).
        */
       if (session.conn.열쇠받기) {
-        const 상태 = 지금열쇠상태();
+        const 상태 = 지금열쇠상태(session.conn.열쇠받기);
         const 남은말 = 상태
           ? 말('auth.leftMin', { 분: Math.round(상태.남은초 / 60) })
           : 말('auth.notYet');
@@ -1592,7 +1567,7 @@ export async function handle(line, session, ctx) {
     }
 
     case 'mcp': {
-      const { 설정읽기, 설정자리, 도구최대, 되살리기최대 } = await import('./backend/mcp.js');
+      const { 설정읽기, 설정자리, 도구최대, 되살리기최대, 적을주소 } = await import('./backend/mcp.js');
       const 붙은것 = session.mcp ?? [];
       rule('밖에서 붙인 도구 (MCP)', 70);
 
@@ -1610,6 +1585,8 @@ export async function handle(line, session, ctx) {
         say('');
         say(`  ${c.gray('붙이려면')} ${c.white('.deel/mcp.json')} ${c.gray('에 이렇게 적습니다 —')}`);
         say(`  ${c.gray('{ "mcpServers": { "사내위키": { "command": "node", "args": ["wiki-mcp.js"] } } }')}`);
+        // 주소로 붙는 서버도 받는다 (2.1.3) — 열쇠는 ${환경변수} 로 적어 저장소에 안 남긴다.
+        say(`  ${c.gray('{ "mcpServers": { "이슈": { "type": "http", "url": "https://mcp.사내.example/mcp", "headers": { "Authorization": "Bearer ${ISSUE_TOKEN}" } } } }')}`);
         say('');
         say(`  ${c.yellow('※')} ${c.gray('MCP 서버는 남의 프로그램입니다. 사내 반입 심사를 따로 받으셔야 합니다.')}`);
         say('');
@@ -1629,8 +1606,12 @@ export async function handle(line, session, ctx) {
          */
         const 상태 = s.살아있나() ? c.green('●') : (s.대기 ? c.yellow('◐') : c.red('○'));
         const 이름들 = s.도구.map((t) => t.name);
-        say(`  ${상태} ${c.bold(s.이름)}  ${c.gray(s.정보?.name ? `${s.정보.name} ${s.정보.version ?? ''}` : s.설정.command)}`);
+        // HTTP 로 붙은 것은 주소를 적는다 — 이름·비밀번호·물음표 뒤는 떼고 (적을주소).
+        const 어디 = s.설정.url ? 적을주소(s.설정.url) : s.설정.command;
+        say(`  ${상태} ${c.bold(s.이름)}  ${c.gray(s.정보?.name ? `${s.정보.name} ${s.정보.version ?? ''}` : 어디)}${s.설정.url && s.정보?.name ? c.gray(` · ${어디}`) : ''}`);
         say(`      ${c.gray('도구 ' + s.도구.length + '개')}  ${c.gray(clip(이름들.join(' · '), 60))}`);
+        // 서버가 낸 프롬프트는 슬래시 명령으로 선다 (2.1.3 · 아래 default 갈래).
+        if (s.프롬프트?.length) say(`      ${c.gray('프롬프트 ' + s.프롬프트.length + '개')}  ${c.gray(clip(s.프롬프트.map((p) => `/mcp__${s.이름}__${p.name}`).join(' · '), 60))}`);
         if (s.대기) say(`      ${c.gray('아직 안 띄웠습니다 — 적어 둔 목록입니다. 이 도구를 부르면 그때 뜹니다.')}`);
         if (s.잘림) say(`      ${mark.warn} ${c.gray(`${s.잘림}개는 뺐습니다 — 한 서버에 ${도구최대}개까지만 받습니다(컨텍스트가 줄어듭니다)`)}`);
         if (s.달라짐) {
@@ -1836,8 +1817,16 @@ export async function handle(line, session, ctx) {
     case 'plugins': return await doPlugin(session, arg), { handled: true };
 
     default: {
+      // MCP 서버가 낸 프롬프트인가 (2.1.3 · src/slash.js 의 MCP프롬프트펴기). 받은 글을 모델에게 보낸다.
+      const 프롬프트 = await MCP프롬프트펴기(session.mcp, raw, arg);
+      if (프롬프트?.탈) { say(`  ${c.red(프롬프트.탈)}`); say(''); return { handled: true }; }
+      if (프롬프트) {
+        ctx?.audit?.write?.('mcp', { 이름: 프롬프트.서버이름, 프롬프트: 프롬프트.이름 });
+        say(`  ${c.cyan('⌘')} ${raw} ${c.gray(`MCP 프롬프트 · ${프롬프트.서버이름}`)}`);
+        return { handled: false, text: 프롬프트.text };
+      }
       // 이 PC 에서 찾은 슬래시 명령인지 본다. 있으면 그 내용을 모델에게 보낸다.
-      // 찾는 규칙은 배치(oneshot.js)와 한 군데에서 같이 쓴다 — 위 슬래시명령찾기.
+      // 찾는 규칙은 배치(oneshot.js)와 한 군데에서 같이 쓴다 — src/slash.js 의 슬래시명령찾기.
       const found = 슬래시명령찾기(session.commands, raw);
       if (found) {
         const { text, error } = loadCommand(found, arg);

package/src/completion.js

@@ -93,6 +93,7 @@ export const 깃발들 = [
   { 이름: '--check', 뜻: 'run: 끝내기 전에 돌릴 검사 명령', en: 'run: check command to pass before finishing', 값: null },
   { 이름: '--check-rounds', 뜻: 'run: 검사를 몇 번까지 돌리나 (1~10)', en: 'run: how many times the check runs (1-10)', 값: null },
   { 이름: '--check-timeout', 뜻: 'run: 검사 한 번의 제한 시간(초)', en: 'run: time limit per check run (seconds)', 값: null },
+  { 이름: '--events', 뜻: 'run: 사건을 이 파일에 JSONL 로', en: 'run: stream events to this file as JSONL', 값: '파일' },
   { 이름: '--repeat', 뜻: 'eval: 과제마다 몇 번 돌릴까', en: 'eval: runs per task', 값: null },
   { 이름: '--init', 뜻: 'eval: 예제 과제를 만든다', en: 'eval: write the example tasks', 값: false },
   { 이름: '--only', 뜻: 'eval: 고른 과제만 (쉼표) · sbom: 한 가지만', en: 'eval: only these tasks (comma); sbom: only one part', 값: null },

package/src/exit.js

@@ -84,8 +84,10 @@ export function 실패덩이({ reason, code, why = '', model = null }) {
   return {
     ok: false, reason, code, text: '',
     tools: 0, steps: 0,
-    usage: { in: 0, out: 0, prompt: 0, cacheRead: 0, cacheWrite: 0, calls: 0, ms: 0, 못잰것: 0, retries: 0 },
+    usage: { in: 0, out: 0, prompt: 0, cacheRead: 0, cacheWrite: 0, calls: 0, ms: 0, 못잰것: 0, retries: 0, genMs: 0, tokPerSec: null },
     model,
+    // 바뀐 파일과 대화 이름 (2.1.3) — 시작도 못 했으니 비었다. 칸은 성공과 같게 둔다.
+    files: [], session: null,
     ms: 0,
     ...(why ? { why } : {}),
   };

package/src/i18n/en.js

@@ -518,6 +518,7 @@ export const en = {
   'ev.hookNote': 'hook: {말}',
   'ev.hookBlock': 'A hook blocked this',
   'ev.nudgeRead': 'It was about to finish having only read things — pushed back once',
+  'ev.textCalls': 'The model wrote {n} tool call(s) as text — running them: {이름}',
   'check.start': 'Completion check ({판}/{최대}) — {명령}',
   'check.clamped': '{칸} {준값} is over the limit — using {쓴값}',
   'check.invalid': '{칸} {준값} is not a usable value — using the default {쓴값}',
@@ -528,6 +529,8 @@ export const en = {
   'check.skipped': 'Could not run the completion check — {까닭}',
   'cli.checkFlag': 'run this check before finishing; failures go back to be fixed, and still failing ends with 8',
   'cli.checkRoundsFlag': 'for this run only: how many times the check runs (1-10; fixes = runs - 1) and the time limit per run (s)',
+  'cli.runResumeFlag': 'runs are saved in .deel/sessions like chats and can be continued — the name is session in --json',
+  'cli.eventsFlag': 'stream events to this file, one JSON per line (the last line is the result)',
   'cli.evalTitle': 'Golden set',
   'cli.evalWhy': '— run a set of tasks on the real model and measure how many it gets done',
   'cli.evalInit': 'create five example tasks in golden/',
@@ -577,11 +580,13 @@ export const en = {
   'cost.tokIn': 'Input tokens',
   'cost.tokOut': 'Output tokens',
   'cost.toolMs': 'Time in tools',
+  'cost.speed': 'Generation speed',
   'cost.elapsed': 'Elapsed',
   'cost.money': 'Cost',
   // ── Cache, wire card, automatic effort ────────────────────────────────
   'status.wire': 'wire',
   'wire.think': 'thinking',
+  'run.notSaving': 'Could not write all of this run to disk ({까닭}) — {n} lines lost. session is empty in --json — this run cannot be resumed.',
   'run.refusal': 'The model declined this request — stopping here instead of pushing again',
   'run.refusalWhy': 'reason {왜}',
   'wire.rungs': 'rungs',

package/src/i18n/ja.js

@@ -476,6 +476,7 @@ export const ja = {
   'ev.hookNote': 'フック: {말}',
   'ev.hookBlock': 'フックが止めました',
   'ev.nudgeRead': '読むだけで終えようとしたので、一度押し戻しました',
+  'ev.textCalls': 'モデルがテキストで書いたツール呼び出し{n}件を読み取って実行します — {이름}',
   'check.start': '完了チェック ({판}/{최대}) — {명령}',
   'check.clamped': '{칸} {준값} は上限を超えるため {쓴값} にしました',
   'check.invalid': '{칸} {준값} は使えない値のため既定の {쓴값} を使います',
@@ -486,6 +487,8 @@ export const ja = {
   'check.skipped': '完了チェックを回せませんでした — {까닭}',
   'cli.checkFlag': '終える前にこのチェックを回し、通れば終了（失敗なら直させ、最後まで失敗なら 8）',
   'cli.checkRoundsFlag': 'この実行だけ：チェックを回す回数（1〜10、直す機会は回数−1）と1回の制限時間（秒）',
+  'cli.runResumeFlag': '会話画面と同じく .deel/sessions に残り、続けられます — 名前は --json の session',
+  'cli.eventsFlag': 'イベントをこのファイルに1行1つの JSON で（最後の行は結果）',
   'cli.evalTitle': 'ゴールデンセット',
   'cli.evalWhy': '— 課題集を実際のモデルで回し、いくつこなせるかを測ります',
   'cli.evalInit': 'golden/ に例題を五つ作ります',
@@ -534,11 +537,13 @@ export const ja = {
   'cost.tokIn': '入力トークン',
   'cost.tokOut': '出力トークン',
   'cost.toolMs': 'ツール時間',
+  'cost.speed': '生成速度',
   'cost.elapsed': '経過',
   'cost.money': '料金',
   // ── キャッシュ・配線カード・自動強度 ──────────────────────────────────
   'status.wire': '配線',
   'wire.think': '思考',
+  'run.notSaving': 'この実行の会話をファイルに書き切れませんでした（{까닭}）— {n}行を失いました。--json の session は空です — この会話は続けられません。',
   'run.refusal': 'モデルがこの依頼を断りました — 押し直さずにここで止めます',
   'run.refusalWhy': '理由 {왜}',
   'wire.rungs': '目盛り',

package/src/i18n/ko.js

@@ -550,6 +550,7 @@ export const ko = {
   'ev.hookNote': '훅: {말}',
   'ev.hookBlock': '훅이 막았습니다',
   'ev.nudgeRead': '읽기만 하고 끝내려고 해서 한 번 되밀었습니다',
+  'ev.textCalls': '모델이 글로 적은 도구 부름 {n}개를 알아듣고 돌립니다 — {이름}',
   'check.start': '완료 검사 ({판}/{최대}) — {명령}',
   'check.clamped': '{칸} {준값} 은 상한을 넘어 {쓴값} 으로 줄였습니다',
   'check.invalid': '{칸} {준값} 은 쓸 수 없는 값이라 기본값 {쓴값} 을 씁니다',
@@ -560,6 +561,8 @@ export const ko = {
   'check.skipped': '완료 검사를 못 돌렸습니다 — {까닭}',
   'cli.checkFlag': '끝내려 할 때 이 검사를 돌려 통과해야 끝남 (실패하면 고치게 하고, 끝내 실패면 8)',
   'cli.checkRoundsFlag': '이번 실행에서만 검사 판수(1~10, 고칠 기회는 판수−1)·한 번의 제한 시간(초)을 덮음',
+  'cli.runResumeFlag': '대화 화면처럼 .deel/sessions 에 남고 이어 합니다 — 이름은 --json 의 session',
+  'cli.eventsFlag': '사건을 이 파일에 한 줄에 하나씩 JSON 으로 (마지막 줄은 결과)',
   'cli.evalTitle': '골든셋',
   'cli.evalWhy': '— 과제 모음을 실제 모델로 돌려 몇 개를 해내나 잽니다',
   'cli.evalInit': '예제 과제 다섯을 golden/ 에 만듭니다',
@@ -625,11 +628,13 @@ export const ko = {
   'cost.tokIn': '입력 토큰',
   'cost.tokOut': '출력 토큰',
   'cost.toolMs': '도구 시간',
+  'cost.speed': '생성 속도',
   'cost.elapsed': '경과',
   'cost.money': '요금',
   // ── 캐시·전선·자동 강도 (backend/wire.js · backend/cachemark.js) ──────
   'status.wire': '전선',
   'wire.think': '생각',
+  'run.notSaving': '이 실행의 대화를 파일에 다 못 적었습니다 ({까닭}) — {n}줄을 잃었습니다. --json 의 session 을 비웠습니다 — 이 대화는 이어 할 수 없습니다.',
   'run.refusal': '모델이 이 요청을 거절했습니다 — 되밀지 않고 여기서 멈춥니다',
   'run.refusalWhy': '까닭 {왜}',
   'wire.rungs': '눈금',

package/src/i18n/zh.js

@@ -476,6 +476,7 @@ export const zh = {
   'ev.hookNote': '钩子：{말}',
   'ev.hookBlock': '钩子拦下了这一步',
   'ev.nudgeRead': '只看不动就要收尾，已经推回去一次',
+  'ev.textCalls': '模型以文字写出了 {n} 个工具调用，已识别并执行 — {이름}',
   'check.start': '完成检查 ({판}/{최대}) — {명령}',
   'check.clamped': '{칸} {준값} 超过上限，改用 {쓴값}',
   'check.invalid': '{칸} {준값} 不是可用的值，改用默认值 {쓴값}',
@@ -486,6 +487,8 @@ export const zh = {
   'check.skipped': '没能跑完成检查 — {까닭}',
   'cli.checkFlag': '结束前跑这个检查，通过才结束（失败就让它修，最后仍失败则返回 8）',
   'cli.checkRoundsFlag': '仅本次运行：检查跑几次（1~10，修复机会 = 次数 − 1）和每次的时限（秒）',
+  'cli.runResumeFlag': '与对话界面一样保存在 .deel/sessions 并可继续 — 名称是 --json 的 session',
+  'cli.eventsFlag': '把事件逐行以 JSON 写入此文件（最后一行是结果）',
   'cli.evalTitle': '黄金集',
   'cli.evalWhy': '— 用真实模型跑一组任务，测它能完成多少',
   'cli.evalInit': '在 golden/ 里建五个示例任务',
@@ -534,11 +537,13 @@ export const zh = {
   'cost.tokIn': '输入 token',
   'cost.tokOut': '输出 token',
   'cost.toolMs': '工具耗时',
+  'cost.speed': '生成速度',
   'cost.elapsed': '已用时',
   'cost.money': '费用',
   // ── 缓存 · 线路卡 · 自动强度 ──────────────────────────────────────────
   'status.wire': '线路',
   'wire.think': '思考',
+  'run.notSaving': '本次运行的对话没能全部写入文件（{까닭}）— 丢失 {n} 行。--json 的 session 为空 — 无法继续这段对话。',
   'run.refusal': '模型拒绝了这个请求 — 不再重试，就此停止',
   'run.refusalWhy': '原因 {왜}',
   'wire.rungs': '档位',

package/src/lsp/diag.js

@@ -100,7 +100,8 @@ export async function 편집후진단(뿌리, abs, { 시한 = 기다릴시한 }
  */
 export function 붙이기(결과, 진단, 보일이름) {
   if (!진단 || (!진단.오류 && !진단.경고)) return 결과;
-  const 머리 = `언어 서버 — ${보일이름}: `
+  // 언어 서버가 못 준 자리에서 문법만 본 것(tools/verify.js 의 한파일문법)은 그렇게 적는다 — 뜻까지 본 것처럼 읽히면 안 된다.
+  const 머리 = `${진단.출처 ? `문법 검사(${진단.출처})` : '언어 서버'} — ${보일이름}: `
     + [진단.오류 ? `오류 ${진단.오류}개` : '', 진단.경고 ? `경고 ${진단.경고}개` : ''].filter(Boolean).join(' · ');
   return {
     ...결과,