deel-local-cli 1.6.3 → 1.8.0

package/src/tools/index.js

@@ -31,7 +31,17 @@ import { 읽을줄수, 찾을개수, 찾을줄수, 설명길이 } from '../agent
 import { 도구설명EN } from './desc.en.js';
 import { 그림인가, 그림읽기, 크기말, 기본한도 } from '../backend/vision.js';
 import { 빠르게찾기, 엔진말, 안볼정규식 } from './fastgrep.js';
-import { 지시말 } from '../i18n/index.js';
+import { 지시말, 말, 세말 } from '../i18n/index.js';
+
+/*
+ * 도구 결과 한 줄을 잇는다 — `1개 파일 · 3건 · rg`.
+ *
+ * 빈 조각은 버린다. 조건부 조각을 `조건 ? '· 뭐' : ''` 로 이어 붙이면
+ * 어느 말에서는 가운뎃점이 둘 붙거나(`· ·`) 줄 끝에 하나 남는다.
+ * 그 자리를 부르는 쪽마다 살피게 두면 반드시 어딘가는 빠진다.
+ */
+const 이어 = (...조각들) => 조각들.filter((x) => x != null && String(x) !== '').join(' · ');
+import { 표몇군데, 표막는말 } from '../safety/secrets.js';
 
 /*
  * 한 번에 돌려줄 양은 **모델에 맞춰** 정한다 (agent/budget.js).
@@ -190,6 +200,23 @@ function 그림잃나(abs, 새내용) {
  * 것이 반드시 나온다. 내용을 보고 정하면 목록을 관리할 일이 없다.
  * @returns {string|null} 막을 이유. 써도 되면 null.
  */
+/*
+ * 우리가 가린 표를 파일에 되돌려 쓰려 하나.
+ *
+ * 명령 출력의 비밀은 이미 가리고 있다(safety/secrets.js). 그런데 모델은 그
+ * «가림:…» 을 **진짜 값으로 알고** 파일에 그대로 옮겨 쓸 수 있다. 그러면
+ * 진짜 열쇠가 있던 자리에 표가 적힌다 — 비밀을 지키려다 비밀을 지우는 셈이고,
+ * 파일은 멀쩡해 보여서 사람은 무엇이 없어졌는지조차 모른다.
+ *
+ * "이건 진짜 값이 아닙니다" 라고 일러 주고는 있지만 그건 부탁이지 자물쇠가
+ * 아니다. 못 알아들은 모델 하나면 그것으로 끝이다. 그림잃나() 와 같은 자리,
+ * 같은 까닭이다 — **우리가 안 보여 준 것을 모델이 지우게 두지 않는다.**
+ */
+function 가린표되돌리나(보인이름, 새내용) {
+  const 몇 = 표몇군데(새내용);
+  return 몇 ? 표막는말(보인이름, 몇) : null;
+}
+
 function 바이너리인가(abs) {
   if (!existsSync(abs)) return null;
   let buf;
@@ -516,7 +543,7 @@ function 한개옮기기({ from, to, overwrite = false }, ctx) {
    * 겹쳤다고 알려 주면 모델이 이름을 고쳐서 다시 부른다.
    */
   if (existsSync(뒤) && !overwrite) {
-    return { error: `이미 있습니다: ${to}\n  덮어쓰려면 overwrite: true 를 주세요.` };
+    return { error: `${말('err.alreadyThere', { 경로: to })}\n  ${말('err.overwriteHint')}` };
   }
 
   /*
@@ -618,7 +645,7 @@ function 여러개옮기기(목록, ctx) {
       + 된것.map((c) => `  ✓ ${c.replace(/^옮김: /, '')}`).join('\n')
       + (안된것.length ? `\n${안된것.map((e) => `  ✗ ${e.split('\n')[0]}`).join('\n')}` : '')
       + (안된것.length ? '\n\n실패한 것만 다시 보내세요. 된 것은 다시 안 보내도 됩니다.' : ''),
-    summary: `${된것.length}개 옮김${안된것.length ? ` · ${안된것.length}개 실패` : ''}`,
+    summary: 이어(말('sum.moved', { n: 된것.length }), 안된것.length ? 말('sum.filesFailed', { n: 안된것.length }) : ''),
     바뀐것들,
   };
 }
@@ -645,6 +672,9 @@ function 한파일쓰기(args, ctx) {
     // 우리가 안 보여 준 그림을 모델이 지우게 두지 않는다 (그림잃나 머리말).
     const 그림막기 = 그림잃나(abs, args.content);
     if (그림막기) return { error: 그림막기 };
+    // 우리가 가린 비밀도 마찬가지다 (가린표되돌리나 머리말).
+    const 표막기 = 가린표되돌리나(ctx.scope.show(abs), args.content);
+    if (표막기) return { error: 표막기 };
     ctx.history.snapshot(abs, 'Write');
     const existed = existsSync(abs);
     // 덮어쓰기 전 내용. 바뀐 자리를 보여주려면 지금 떠 놔야 한다.
@@ -670,7 +700,7 @@ function 한파일쓰기(args, ctx) {
     const 표기 = 원래 !== 'utf-8' ? ` · ${encLabel(원래)}` : '';
     return {
       content: `${existed ? '덮어씀' : '새로 만듦'}: ${ctx.scope.show(abs)} (${n}줄${표기})`,
-      summary: `${n}줄${표기}`,
+      summary: 이어(세말('lines', n), 원래 !== 'utf-8' ? encLabel(원래) : ''),
       changed: abs,
       diff: 바뀐자리(이전, args.content),
     };
@@ -714,8 +744,11 @@ function 여러파일쓰기(목록, ctx) {
     content: `${된것.length}개 만들었습니다${안된것.length ? `, ${안된것.length}개 실패` : ''}.\n`
       + 줄들.join('\n')
       + (안된것.length ? '\n\n실패한 것만 다시 보내세요. 된 것은 다시 안 보내도 됩니다.' : ''),
-    summary: `${된것.length}개 · ${된것.reduce((a, r) => a + (r.lines ?? 0), 0)}줄`
-      + (안된것.length ? ` · ${안된것.length}개 실패` : ''),
+    summary: 이어(
+      세말('count', 된것.length),
+      세말('lines', 된것.reduce((a, r) => a + (r.lines ?? 0), 0)),
+      안된것.length ? 말('sum.filesFailed', { n: 안된것.length }) : '',
+    ),
     // 화면과 루프가 파일별로 처리하도록 그대로 넘긴다. changed 는 안 넣는다 —
     // 넣으면 그 한 개만 세어지고 나머지가 조용히 빠진다.
     여럿: 결과,
@@ -731,7 +764,7 @@ function 여러파일쓰기(목록, ctx) {
  */
 function 한군데고치기(args, ctx) {
   const abs = ctx.scope.resolve(args.file_path);
-  if (!existsSync(abs)) return { error: `파일이 없습니다: ${args.file_path}` };
+  if (!existsSync(abs)) return { error: 말('err.noSuchFile', { 경로: args.file_path }) };
   const 못고치는이유 = 내부살림(abs);
   if (못고치는이유) return { error: 못고치는이유 };
   // 엑셀 파일은 Read 로 읽히긴 하지만 고칠 수 있는 물건이 아니다.
@@ -741,6 +774,10 @@ function 한군데고치기(args, ctx) {
   if (isPdfPath(abs)) return { error: pdf는못고침(args.file_path) };
   if (!ctx.seen.has(abs)) return { error: `먼저 Read 로 읽어야 합니다: ${args.file_path}` };
   if (args.old_string === args.new_string) return { error: 'old_string 과 new_string 이 같습니다' };
+  // 새로 넣을 글에만 본다. old_string 쪽은 **찾는 말**이라 표가 들어 있어도
+  // 파일이 안 바뀐다 — 못 찾고 끝날 뿐이다 (가린표되돌리나 머리말).
+  const 표막기 = 가린표되돌리나(ctx.scope.show(abs), args.new_string);
+  if (표막기) return { error: 표막기 };
 
   const 읽음 = readTextFull(abs);
   const text = 읽음.text;
@@ -784,7 +821,12 @@ function 한군데고치기(args, ctx) {
   const 표기 = 읽음.encoding !== 'utf-8' ? ` · ${encLabel(읽음.encoding)}` : '';
   return {
     content: `고침: ${ctx.scope.show(abs)} (${n}군데${how}${표기})`,
-    summary: `${n}군데${how}${표기}`,
+    summary: 이어(
+      세말('spots', n),
+      // 화면 말로. TIER_LABELS 는 한국어 원본이라 content 쪽에만 남긴다.
+      m.tier === 'exact' ? '' : 말(`tier.${m.tier}`),
+      읽음.encoding !== 'utf-8' ? encLabel(읽음.encoding) : '',
+    ),
     changed: abs,
     tier: m.tier,
     diff: 바뀐자리(text, next),
@@ -844,7 +886,11 @@ function 여러군데고치기(목록, ctx) {
         ? '\n\n실패한 것만 다시 보내세요. 된 것은 다시 안 보내도 됩니다.'
           + ' 앞엣것이 이미 반영됐으니 **파일을 다시 Read 해서** 지금 내용을 보고 old_string 을 잡으세요.'
         : ''),
-    summary: `${파일수}개 파일 · ${군데수}군데` + (안된것.length ? ` · ${안된것.length}개 실패` : ''),
+    summary: 이어(
+      세말('files', 파일수),
+      세말('spots', 군데수),
+      안된것.length ? 말('sum.spotsFailed', { n: 안된것.length }) : '',
+    ),
     // 화면과 루프가 자리별로 처리하도록 그대로 넘긴다. changed 는 안 넣는다 —
     // 넣으면 그 한 개만 세어지고 나머지가 조용히 빠진다 (여러파일쓰기 와 같다).
     여럿: 결과,
@@ -875,7 +921,7 @@ function 그림보기(abs, ctx) {
     return { error: `${show} — ${것.왜}` };
   }
   ctx.seen.add(abs);
-  const 잰것 = `그림 · ${크기말(것.bytes)} · ${것.mime}`;
+  const 잰것 = 이어(말('sum.image'), 크기말(것.bytes), 것.mime);
 
   if (!눈있나) {
     return {
@@ -883,7 +929,7 @@ function 그림보기(abs, ctx) {
         + '지금 붙어 있는 모델은 그림을 못 봅니다 — 그래서 보내지 않았습니다.\n'
         + '이 파일을 코드처럼 읽으려 하지 마세요. 무엇이 찍혀 있는지 알아야 한다면'
         + ' 사용자에게 말로 설명해 달라고 하세요.',
-      summary: `${잰것} · 이 모델은 못 봄`,
+      summary: 이어(잰것, 말('sum.noVision')),
       그림없음: true,
     };
   }
@@ -915,7 +961,7 @@ export const TOOLS = {
     },
     async run(args, ctx) {
       const abs = ctx.scope.resolve(args.file_path);
-      if (!existsSync(abs)) return { error: `파일이 없습니다: ${args.file_path}` };
+      if (!existsSync(abs)) return { error: 말('err.noSuchFile', { 경로: args.file_path }) };
       if (statSync(abs).isDirectory()) return { error: `폴더입니다. Glob 을 쓰세요: ${args.file_path}` };
       // 제 살림·남의 도구 살림은 안 읽는다 — fsutil 의 내부살림() 머리말 참고.
       const 막을이유 = 내부살림(abs);
@@ -998,9 +1044,13 @@ export const TOOLS = {
       const 다못줌 = start + count < lines.length || start > 0;
       return {
         content: clip(body + more + 줄인것.알림),
-        summary: (다못줌 ? `${준줄수}/${lines.length}줄 (일부만)` : `${lines.length}줄`)
-          + (줄인것.줄인바이트 ? ` · 그림 ${몇KB(줄인것.줄인바이트)} 생략` : '')
-          + (별난인코딩 ? ` · ${encLabel(읽음.encoding)}` : ''),
+        summary: 이어(
+          다못줌
+            ? `${말('sum.linesOf', { 준: 준줄수, 전체: lines.length })} (${말('sum.partial')})`
+            : 세말('lines', lines.length),
+          줄인것.줄인바이트 ? 말('sum.imageDropped', { 크기: 몇KB(줄인것.줄인바이트) }) : '',
+          별난인코딩 ? encLabel(읽음.encoding) : '',
+        ),
       };
     },
   },
@@ -1079,6 +1129,10 @@ export const TOOLS = {
       const existed = existsSync(abs);
       if (existed && statSync(abs).isDirectory()) return { error: `폴더입니다: ${args.file_path}` };
 
+      // 이어 붙이는 조각에도 가린 표가 섞이면 안 된다 (가린표되돌리나 머리말).
+      const 표막기 = 가린표되돌리나(ctx.scope.show(abs), args.content);
+      if (표막기) return { error: 표막기 };
+
       // Append 는 한 턴에 여러 번 불리는 것이 정상이다. 그래도 되돌리기 이력에
       // 사본이 쌓이지 않는다 — History.snapshot 이 턴마다 한 번만 뜬다(undo.js).
       ctx.history.snapshot(abs, 'Append');
@@ -1108,7 +1162,11 @@ export const TOOLS = {
       return {
         content: `${existed ? '이어 붙임' : '새로 만듦'}: ${ctx.scope.show(abs)}`
           + ` (+${붙인줄}줄, 지금 전체 ${전체줄}줄${표기})`,
-        summary: `+${붙인줄}줄 · 전체 ${전체줄}줄${표기}`,
+        summary: 이어(
+          말('sum.addedLines', { 줄: 세말('lines', 붙인줄) }),
+          말('sum.total', { 줄: 세말('lines', 전체줄) }),
+          원래 !== 'utf-8' ? encLabel(원래) : '',
+        ),
         changed: abs,
         // 이어 붙이기는 앞부분이 그대로다. 전후를 통째로 견줄 이유가 없다 —
         // 큰 파일에서 그 비용이 그대로 기다리는 시간이 된다.
@@ -1248,7 +1306,7 @@ export const TOOLS = {
       if (!files.length) {
         return {
           content: `${전부.잘림 ? '본 데까지는 찾은 파일 없음' : '찾은 파일 없음'}: ${args.pattern}${건너뜀}`,
-          summary: 전부.잘림 ? '0개 (다 못 봄)' : '0개',
+          summary: 전부.잘림 ? `${세말('count', 0)} (${말('sum.notAllSeen')})` : 세말('count', 0),
         };
       }
       // 잘랐으면 잘랐다고 말한다. 전에는 '200개' 라고만 해서, 모델이 그게 전부인 줄
@@ -1258,7 +1316,9 @@ export const TOOLS = {
         : '';
       return {
         content: files.map((f) => ctx.scope.show(f.path)).join('\n') + 잘림 + 건너뜀,
-        summary: 맞는것.length > files.length ? `${files.length}/${맞는것.length}개` : `${files.length}개`,
+        summary: 맞는것.length > files.length
+          ? 말('sum.countOf', { n: files.length, 전체: 맞는것.length })
+          : 세말('count', files.length),
       };
     },
   },
@@ -1342,17 +1402,17 @@ export const TOOLS = {
           '(.gitignore·.deelignore 는 지켰습니다. 건너뛴 수는 안 셌습니다)',
         ].filter(Boolean).join(' ');
         const 붙이기2 = (t) => (꼬리2 ? [t, '', 꼬리2].join('\n') : t);
-        if (!total) return { content: 붙이기2(`일치 없음: ${args.pattern}`), summary: `0건 · ${빠른것.엔진}` };
-        if (mode === 'content') return { content: 붙이기2(clip(lines.join('\n'))), summary: `${total}건 · ${빠른것.엔진}` };
+        if (!total) return { content: 붙이기2(`일치 없음: ${args.pattern}`), summary: 이어(세말('hits', 0), 빠른것.엔진) };
+        if (mode === 'content') return { content: 붙이기2(clip(lines.join('\n'))), summary: 이어(세말('hits', total), 빠른것.엔진) };
         if (mode === 'count') {
           return {
             content: 붙이기2(hitFiles.slice(0, limit).map((f) => `${f.n}\t${f.rel}`).join('\n')),
-            summary: `${hitFiles.length}개 파일 · ${빠른것.엔진}`,
+            summary: 이어(세말('files', hitFiles.length), 빠른것.엔진),
           };
         }
         return {
           content: 붙이기2(hitFiles.slice(0, limit).map((f) => f.rel).join('\n')),
-          summary: `${hitFiles.length}개 파일 · ${total}건 · ${빠른것.엔진}`,
+          summary: 이어(세말('files', hitFiles.length), 세말('hits', total), 빠른것.엔진),
         };
       }
 
@@ -1420,14 +1480,14 @@ export const TOOLS = {
       if (!total) {
         return {
           content: 붙이기(다못봄 ? `본 데까지는 일치 없음: ${args.pattern}` : `일치 없음: ${args.pattern}`),
-          summary: 다못봄 ? '0건 (다 못 봄)' : '0건',
+          summary: 다못봄 ? `${세말('hits', 0)} (${말('sum.notAllSeen')})` : 세말('hits', 0),
         };
       }
-      if (mode === 'content') return { content: 붙이기(clip(lines.join('\n'))), summary: `${total}건` };
+      if (mode === 'content') return { content: 붙이기(clip(lines.join('\n'))), summary: 세말('hits', total) };
       if (mode === 'count') {
-        return { content: 붙이기(hitFiles.map((f) => `${f.n}\t${f.rel}`).join('\n')), summary: `${hitFiles.length}개 파일` };
+        return { content: 붙이기(hitFiles.map((f) => `${f.n}\t${f.rel}`).join('\n')), summary: 세말('files', hitFiles.length) };
       }
-      return { content: 붙이기(hitFiles.map((f) => f.rel).join('\n')), summary: `${hitFiles.length}개 파일 · ${total}건` };
+      return { content: 붙이기(hitFiles.map((f) => f.rel).join('\n')), summary: 이어(세말('files', hitFiles.length), 세말('hits', total)) };
     },
   },
 
@@ -1459,7 +1519,8 @@ export const TOOLS = {
       ctx.loadedSkills?.add(hit.name);
       return {
         content: `# 스킬: ${hit.name}\n\n${body}`,
-        summary: `${Math.round(body.length / 100) / 10}k자${cut ? ' (일부 잘림)' : ''}`,
+        summary: 말('unit.kchars', { n: Math.round(body.length / 100) / 10 })
+          + (cut ? ` (${말('sum.cut')})` : ''),
       };
     },
   },
@@ -1523,8 +1584,11 @@ export const TOOLS = {
         return {
           content: `${r.번호}번으로 띄웠습니다: ${cmd}\n`
             + (r.출력?.trim() ? `\n${clip(r.출력, 4000)}\n` : '')
-            + `\n계속 돌고 있습니다. 새 출력은 Jobs({번호: ${r.번호}}) 로 읽고, 일이 끝나면 Jobs({번호: ${r.번호}, 끝내기: true}) 로 정리해라.`,
-          summary: `${r.번호}번으로 띄움`,
+            // 여기 적는 이름은 **Jobs 설명서에 실린 그 이름**이어야 한다.
+            // 별칭(번호·끝내기)도 받아 주긴 하지만, 설명서와 다른 이름을
+            // 모델에게 시키면 엄격한 게이트웨이가 그 호출을 튕긴다.
+            + `\n계속 돌고 있습니다. 새 출력은 Jobs({job: ${r.번호}}) 로 읽고, 일이 끝나면 Jobs({job: ${r.번호}, stop: true}) 로 정리해라.`,
+          summary: 말('sum.jobStarted', { n: r.번호 }),
           일감번호: r.번호,
           뒤에서: true,
           되돌릴것: 뜬것,
@@ -1590,7 +1654,9 @@ export const TOOLS = {
           const 꼬리 = 잘됨 ? '' : 시그널 ? `\n\n[${시그널} 시그널로 죽었습니다 — 정상 종료가 아닙니다]` : `\n\n[종료코드 ${code}]`;
           done({
             content: clip(out || '(출력 없음)') + 꼬리,
-            summary: 잘됨 ? '성공' : 시그널 ? `${시그널} 로 죽음` : `종료코드 ${code}`,
+            summary: 잘됨 ? 말('sum.ok')
+              : 시그널 ? 말('sum.killedBy', { 시그널 })
+                : 말('sum.exitCode', { code }),
             failed: !잘됨,
             exitCode: code,
             signal: 시그널,
@@ -1689,7 +1755,7 @@ export const TOOLS = {
        * 첫 문장에 제일 중요한 것을 둔다 — 좁은 창에서는 설명줄이기가
        * **뒤에서부터 문장째로** 잘라 낸다. 8k 에서 남는 것은 앞 90자다.
        */
-      description: '갈림길에서 사람에게 하나 묻는다. **먼저 `이해` 에 이번 요청을 무엇으로'
+      description: '갈림길에서 사람에게 하나 묻는다. **먼저 `understanding` 에 이번 요청을 무엇으로'
         + ' 알아들었는지 한 줄로 적고**, 그러고도 정말 정할 것이 남았을 때만 묻는다.'
         + ' 글로 "알려주세요" 하고 끝내지 마라 — 턴이 끝나서 여태 본 것이 버려진다.'
         + ' options 에 2~4개를 주면 숫자로 답한다.'
@@ -1698,7 +1764,19 @@ export const TOOLS = {
       parameters: {
         type: 'object',
         properties: {
-          이해: {
+          /*
+           * 인자 이름은 **영문·숫자·`_.-` 만** 쓴다.
+           *
+           * 이 이름은 우리끼리 쓰는 것이 아니라 도구 설명서에 실려 서버로 나간다.
+           * Bedrock 은 `^[a-zA-Z0-9_.-]{1,64}$` 로 검사하고, 안 맞으면 **첫 한마디가
+           * 통째로 400** 이다. 화면에는 그냥 「BadRequest」 라서, 사람은 열쇠가
+           * 틀린 줄 알고 다시 발급받으러 간다.
+           *
+           * 로컬 모델도 OpenAI 호환 서버도 이 검사를 안 한다. 그래서 바깥에
+           * 붙어 보기 전까지는 멀쩡해 보였다. 검사가 이제 그 자리를 잰다
+           * (test/toolargs.test.js).
+           */
+          understanding: {
             type: 'string',
             description: '이번 요청을 무엇으로 알아들었는지 한 줄. 사람은 이 줄을 보고 네가'
               + ' 제대로 읽었는지 판단한다. "요청을 이해했습니다" 같은 인사말은 안 된다 —'
@@ -1711,7 +1789,7 @@ export const TOOLS = {
             description: '고를 것 2~4개. 각각 한 줄로, 무엇이 달라지는지 알 수 있게',
           },
         },
-        required: ['이해', 'question'],
+        required: ['understanding', 'question'],
       },
     },
     async run(args, ctx) {
@@ -1720,7 +1798,9 @@ export const TOOLS = {
 
       const 고를것 = (Array.isArray(args.options) ? args.options : [])
         .map((x) => String(x ?? '').trim()).filter(Boolean).slice(0, 4);
-      const 이해 = String(args.이해 ?? '').trim();
+      // 옛 이름(`이해`)도 받는다. 이름을 바꾼 것은 서버가 검사하기 때문이지
+      // 뜻이 달라져서가 아니다 — 옛 이름으로 부르던 자리가 조용히 비면 안 된다.
+      const 이해 = String(args.understanding ?? args.이해 ?? '').trim();
 
       /*
        * 물어볼 자리가 없는 데서도 안 죽어야 한다 — `deel -p` 한 방 실행, 파이프,
@@ -1831,7 +1911,7 @@ export const TOOLS = {
         return `[${h.세션} · ${날} · ${h.누구}] ${h.토막}`;
       });
       return {
-        summary: `지난 대화에서 ${r.전체맞음}건 중 ${r.맞은것.length}건`
+        summary: 말('sum.recall', { 전체: r.전체맞음, 맞음: r.맞은것.length })
           + (r.예산초과 ? ` (${r.전체파일}개 중 ${r.본파일}개만 뒤짐)` : ''),
         hits: r.맞은것.map((h) => ({ session: h.세션, when: h.언제, who: h.누구, text: h.토막 })),
         text: 줄들.join('\n'),
@@ -1871,7 +1951,7 @@ export const TOOLS = {
       const r = 더하기(ctx.scope.root, args.text);
       if (!r.ok) return { summary: r.why, remembered: false };
       return {
-        summary: `기억했습니다 (${r.줄수}줄)` + (r.넘침 ? ' · 자리가 차서 오래된 것을 뺐습니다' : ''),
+        summary: 이어(말('sum.remembered', { n: r.줄수 }), r.넘침 ? 말('sum.rememberFull') : ''),
         remembered: true,
         line: r.줄,
         // 화면에 무엇을 적었는지 보여 주려고 같이 넘긴다. 사람이 못 보면
@@ -1943,7 +2023,7 @@ export function 설명줄이기(schema, 한도) {
     // 이름만 봐도 아는 인자는 아주 좁은 창에서 설명을 통째로 뺀다.
     // `file_path` 가 무엇인지 설명하는 데 토큰을 쓰는 것은, 8k 모델에서는
     // 그 토큰만큼 대화를 잘라먹는 것과 같다. 헷갈릴 만한 것(offset·files·
-    // replace_all·목적·할일)은 그대로 둔다 — 거기서 틀리면 일이 안 된다.
+    // replace_all·purpose·task)은 그대로 둔다 — 거기서 틀리면 일이 안 된다.
     if (한도 <= 100 && 뻔한인자.has(이름)) { 새속성[이름] = { type: 값.type }; continue; }
     /*
      * 배열 안쪽 설명은 좁은 창에서 통째로 뺀다.
@@ -2002,14 +2082,28 @@ function 눈붙이기(fn, 이름, vision) {
   if (이름 !== 'Read' || !vision) return fn;
   // 화면 말을 그대로 본다. 설명 글자를 보고 짐작하면 안 된다 — 줄이기가 문장
   // 한복판을 자르므로 마지막 글자가 무엇일지 정해져 있지 않다.
-  const 덧말 = 지시말() === 'en'
+  // 위 영어설명() 과 같은 갈림이어야 한다. 여기만 'en' 을 보면, 일본어로
+  // 켠 사람은 영어 설명 뒤에 한국어 한 문장이 붙은 것을 받는다.
+  const 덧말 = 지시말() !== 'ko'
     ? ' Screenshots and images (.png/.jpg/.gif/.webp) can be opened too — this model can see them.'
     : ' 화면 사진·그림(.png/.jpg/.gif/.webp)도 그대로 열 수 있다 — 지금 붙어 있는 모델은 그림을 본다.';
   return { ...fn, description: String(fn.description ?? '') + 덧말 };
 }
 
-function 영어설명(schema, 이름) {
-  if (지시말() !== 'en') return schema;
+/*
+ * 도구 설명을 영어 표로 갈아 끼운다.
+ *
+ * 쓸말을 밖에서 받는다. 두 군데가 서로 다른 말을 봐야 해서다 —
+ * **모델에게 주는 글**은 지시말() 을 따르고, `/tools` 로 **사람이 보는
+ * 화면**은 언어() 를 따른다. 여태 한 함수가 지시말() 만 봐서, `/tools` 는
+ * 이 함수를 아예 안 거치고 원본(한국어)을 그대로 찍고 있었다.
+ *
+ * ko 가 아니면 영어를 쓴다. 일본어·중국어 표에는 도구 설명이 없는데,
+ * 그 사람들에게는 한국어보다 영어가 낫다 — i18n 의 물러날곳(ja→en→ko)이
+ * 이미 그렇게 정해 두었고, 여기만 그 규칙 밖에 있었다.
+ */
+export function 영어설명(schema, 이름, 쓸말 = 지시말()) {
+  if (쓸말 === 'ko') return schema;
   const 것 = 도구설명EN[이름];
   if (!것) return schema;
 
@@ -2064,8 +2158,9 @@ export function toolSchemas(names = null, { hasSkills = false, web = true, work
    * 다음 영어로 통째로 바꾸는 셈이라, 자른 것이 아무 뜻이 없어지고 영어 글은
    * 한도를 넘긴 채로 실린다.
    *
-   * 이름과 인자 이름은 안 건드린다 — 그건 식별자다. Task 의 목적·할일처럼
-   * 한글로 된 인자 이름을 바꾸면 그 도구가 아예 안 불린다.
+   * 이름과 인자 이름은 안 건드린다 — 그건 식별자다. 여기서 인자 이름을
+   * 갈아 끼우면 모델이 부른 이름과 우리가 읽는 이름이 어긋나 도구가 아예
+   * 안 불린다. (인자 이름 자체는 이미 다 영문이다 — test/toolargs.test.js.)
    */
   const 우리것 = list.map((n) => ({
     type: 'function',
@@ -2210,7 +2305,10 @@ async function runMcpTool(name, args, ctx) {
       if (out.isError) return { error: out.text || '도구가 오류를 냈습니다' };
       const 글 = out.text ?? '';
       const 줄 = 글 ? 글.split(/\r?\n/).length : 0;
-      return { summary: 글 ? `${줄}줄 · ${글.length.toLocaleString()}자` : '빈 답', content: clip(글) };
+      return {
+        summary: 글 ? 이어(세말('lines', 줄), 말('unit.chars', { n: 글.length.toLocaleString() })) : 말('sum.emptyAnswer'),
+        content: clip(글),
+      };
     } catch (e) {
       return { error: e.message };
     }

package/src/tools/jobs.js

@@ -26,6 +26,10 @@
 import { spawn, execFileSync } from 'node:child_process';
 import { decode as decodeBytes, consoleCodepage } from './encoding.js';
 import { 셸명령 } from './shell.js';
+import { 말, 세말 } from '../i18n/index.js';
+
+/* 결과 한 줄을 잇는다 — 빈 조각은 버린다(tools/index.js 의 이어 와 같은 것). */
+const 이어 = (...조각들) => 조각들.filter((x) => x != null && String(x) !== '').join(' · ');
 
 // 한 일감이 **들고 있을** 출력 상한. 넘으면 앞을 버리고 뒤를 남긴다 —
 // 오래 도는 것에서 필요한 건 언제나 **방금** 나온 쪽이다.
@@ -500,9 +504,9 @@ process.once('exit', () => { try { 모두끝내기(); } catch { /* 끝나는 중
  * 두 벌이 되면 한쪽만 고쳐지고, 그때부터 화면과 실제가 어긋난다.
  */
 const 인자이름 = {
-  번호: ['번호', 'job', 'job_id', 'jobId', 'id', 'number'],
-  끝내기: ['끝내기', 'stop', 'kill'],
-  처음부터: ['처음부터', 'from_start', 'fromStart', 'full'],
+  번호: ['job', 'job_id', 'jobId', 'id', 'number', '번호'],
+  끝내기: ['stop', 'kill', '끝내기'],
+  처음부터: ['from_start', 'fromStart', 'full', '처음부터'],
 };
 const 아는이름 = new Set(Object.values(인자이름).flat());
 
@@ -555,14 +559,14 @@ export const JOBS_TOOL = {
   schema: {
     name: 'Jobs',
     description: '뒤에서 도는 명령(Bash 의 background)을 보고·읽고·끝낸다.'
-      + ' 번호 없이 부르면 목록. 번호를 주면 그동안 새로 나온 출력.'
-      + ' 서버를 띄웠으면 일이 끝날 때 반드시 끝내기로 정리해라.',
+      + ' job 없이 부르면 목록. job 을 주면 그동안 새로 나온 출력.'
+      + ' 서버를 띄웠으면 일이 끝날 때 반드시 stop 으로 정리해라.',
     parameters: {
       type: 'object',
       properties: {
-        번호: { type: 'number', description: '볼 일감 번호 (job). 없으면 목록' },
-        끝내기: { type: 'boolean', description: 'true 면 그 일감을 끝낸다 (stop)' },
-        처음부터: { type: 'boolean', description: 'true 면 처음부터 다시 읽는다 (from_start)' },
+        job: { type: 'number', description: '볼 일감 번호. 없으면 목록' },
+        stop: { type: 'boolean', description: 'true 면 그 일감을 끝낸다' },
+        from_start: { type: 'boolean', description: 'true 면 처음부터 다시 읽는다' },
       },
       required: [],
     },
@@ -612,7 +616,7 @@ export const JOBS_TOOL = {
         };
       }
       const ls = 목록();
-      if (!ls.length) return { content: '뒤에서 도는 명령이 없습니다.', summary: '0개' };
+      if (!ls.length) return { content: '뒤에서 도는 명령이 없습니다.', summary: 세말('count', 0) };
       const 줄들 = ls.map((j) => {
         const 상 = j.상태 === '도는중' ? `도는중 ${j.초}초` : j.시그널 ? `${j.시그널} 로 죽음` : `끝남 (종료코드 ${j.종료코드})`;
         const 새것 = j.안읽은글자 ? ` · 안 읽은 출력 ${j.안읽은글자}자` : '';
@@ -626,17 +630,17 @@ export const JOBS_TOOL = {
        * 그러면 포트가 물려서 안 뜨고, 왜 안 되는지도 모른다.
        */
       if (치운것) 줄들.push(`  (오래된 것 ${치운것}개는 자리를 위해 지웠습니다)`);
-      return { content: 줄들.join('\n'), summary: `${ls.length}개`, 일감수: ls.length };
+      return { content: 줄들.join('\n'), summary: 세말('count', ls.length), 일감수: ls.length };
     }
 
     if (받은것.끝내기) {
       const r = await 끝내기(번호);
       if (!r) return { error: `${번호}번 일감이 없습니다. 번호 없이 Jobs 를 불러 목록을 보세요.` };
-      if (r.이미) return { content: `${번호}번은 이미 끝나 있었습니다: ${r.명령}`, summary: '이미 끝남' };
+      if (r.이미) return { content: `${번호}번은 이미 끝나 있었습니다: ${r.명령}`, summary: 말('sum.jobEndedAlready') };
       return {
         content: `${번호}번을 끝냈습니다 (${r.초}초 돌았습니다): ${r.명령}`
           + (r.남은 ? `\n\n마지막 출력:\n${뒤만(r.남은, 2000).글}` : ''),
-        summary: `끝냄 · ${r.초}초`,
+        summary: 이어(말('sum.jobStopped'), 말('unit.sec', { n: r.초 })),
       };
     }
 
@@ -652,7 +656,7 @@ export const JOBS_TOOL = {
       : '(지난번 읽은 뒤로 새 출력이 없습니다)';
     return {
       content: `${머리}\n\n${몸}`,
-      summary: (r.상태 === '도는중' ? `도는중 · ${r.초}초` : 끝난말(r))
+      summary: (r.상태 === '도는중' ? 이어(말('sum.jobRunning'), 말('unit.sec', { n: r.초 })) : 끝난말(r))
         + (잘라낸.줄임 ? ' · 일부만' : ''),
       // 끝난 일감이 종료코드 0 이 아니면 실패로 물들인다 — Bash 와 같은 규칙이다.
       // 시그널로 죽은 것도 실패다 — 그때 종료코드는 null 이라 !== 0 으로 잡힌다.

package/src/tools/lsp.js

@@ -27,6 +27,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { 얻기, 색인중일까 } from '../lsp/client.js';
 import { 갈래, 프로젝트갈래 } from '../lsp/servers.js';
 import { 찾을개수 } from '../agent/budget.js';
+import { 말, 세말 } from '../i18n/index.js';
 
 /** 한 자리를 사람이 읽을 한 줄로. 그 줄의 글까지 붙여야 열어 보지 않고도 안다. */
 function 한줄(scope, uri, 범위) {
@@ -240,11 +241,11 @@ export const DEF_TOOL = {
       곳들 = 후보.map((c) => 한줄(ctx.scope, c.uri, c.range));
       어디서 = 'workspace/symbol';
     }
-    if (!곳들.length) return { summary: `${이름}: 정의를 못 찾았습니다. Grep 으로 찾아보세요.`, found: 0 };
+    if (!곳들.length) return { summary: `${이름}: ${말('lsp.noDef')}`, found: 0 };
 
     const 여럿 = 여럿이면(후보, ctx.scope);
     return {
-      summary: `${이름} — 정의 ${곳들.length}곳${여럿 ? `\n${여럿}` : ''}`,
+      summary: `${이름} — ${말('lsp.defs', { n: 세말('places', 곳들.length) })}${여럿 ? `\n${여럿}` : ''}`,
       found: 곳들.length,
       source: 어디서,
       locations: 곳들,
@@ -288,7 +289,7 @@ export const REFS_TOOL = {
     const 곳들 = 자리들펴기(답.값).map((x) => 한줄(ctx.scope, x.uri, x.range));
     if (!곳들.length) {
       return {
-        summary: `${이름}: 쓰는 자리가 없습니다.`
+        summary: `${이름}: ${말('lsp.noRefs')}`
           + ' 정말 안 쓰는 것일 수도 있고, 언어 서버가 아직 색인 중일 수도 있습니다 —'
           + ' 지우기 전에 Grep 으로 한 번 더 보세요.',
         found: 0,
@@ -314,7 +315,7 @@ export const REFS_TOOL = {
 
     const 여럿 = 여럿이면(후보, ctx.scope);
     return {
-      summary: `${이름} — 쓰는 자리 ${곳들.length}곳 · 파일 ${묶음.size}개`
+      summary: `${이름} — ${말('lsp.refs', { 자리: 세말('places', 곳들.length), 파일: 세말('files', 묶음.size) })}`
         + (남은 ? ` (${남은}곳은 자리가 모자라 안 실었습니다)` : '')
         + (여럿 ? `\n${여럿}` : ''),
       found: 곳들.length,

package/src/tools/outline.js

@@ -35,6 +35,10 @@ import { walk, SKIP_DIRS, globToRegex, 내부살림 } from './fsutil.js';
 import { 건너뜀말 } from './ignore.js';
 import { decode, looksBinary } from './encoding.js';
 import { 찾을개수, 뼈대줄수 } from '../agent/budget.js';
+import { 말, 세말 } from '../i18n/index.js';
+
+/* 결과 한 줄을 잇는다 — 빈 조각은 버린다(tools/index.js 의 이어 와 같은 것). */
+const 이어 = (...조각들) => 조각들.filter((x) => x != null && String(x) !== '').join(' · ');
 
 /**
  * 언어별로 '뼈대' 를 이루는 것들.
@@ -243,7 +247,7 @@ export const OUTLINE_TOOL = {
       파일들 = 파일들.filter((f) => re.test(f.rel) || re.test(f.rel.split('/').pop()));
     }
 
-    if (!파일들.length) return { content: '볼 파일이 없습니다.', summary: '0개' };
+    if (!파일들.length) return { content: '볼 파일이 없습니다.', summary: 세말('count', 0) };
 
     // 최근에 손댄 것부터. 지금 하는 일과 가까울 가능성이 높다.
     파일들.sort((a, b) => (b.mtime ?? 0) - (a.mtime ?? 0));
@@ -327,8 +331,8 @@ export const OUTLINE_TOOL = {
 
     return {
       content: 줄들.join('\n').trimEnd() + 건너뜀,
-      summary: `${뼈대있는파일}개 파일 · ${항목수}곳`
-        + (못읽은것.size ? ` · 못 읽음 ${[...못읽은것.values()].reduce((a, x) => a + x.length, 0)}개` : ''),
+      summary: 이어(세말('files', 뼈대있는파일), 세말('places', 항목수))
+        + (못읽은것.size ? ` · ${말('sum.unread', { n: [...못읽은것.values()].reduce((a, x) => a + x.length, 0) })}` : ''),
     };
   },
 };

package/src/tools/task.js

@@ -43,19 +43,19 @@ export const TASK_TOOL = {
       + ' 처음부터 끝까지 일하고, 너에게는 결과 요약만 돌아온다 — 하위가 읽은 파일 내용은'
       + ' 네 창에 안 쌓인다. 그래서 파일 여러 개를 만들거나 고치는 일은 이걸로 나눠야 끝까지 간다.'
       + ' 덩이 하나는 혼자 끝낼 수 있는 크기여야 한다 (예: "index.html 과 style.css 만들기").'
-      + ' 하위는 네 대화를 못 본다 — 필요한 것은 할일 안에 다 적어 줘라.'
+      + ' 하위는 네 대화를 못 본다 — 필요한 것은 task 안에 다 적어 줘라.'
       + ' 짧은 일 하나를 할 때는 쓰지 마라. 그냥 직접 하는 편이 빠르다.',
     parameters: {
       type: 'object',
       properties: {
-        목적: { type: 'string', description: '이 덩이를 한 줄로 (예: "대시보드 화면 뼈대 만들기")' },
-        할일: {
+        purpose: { type: 'string', description: '이 덩이를 한 줄로 (예: "대시보드 화면 뼈대 만들기")' },
+        task: {
           type: 'string',
           description:
             '하위가 할 일을 빠짐없이. 하위는 지금 대화를 못 보니 필요한 배경·정한 것·파일 경로를'
             + ' 여기 다 적어라. 무엇이 끝나면 다 된 것인지도 적어라.',
         },
-        모드: {
+        mode: {
           type: 'string',
           description: '하위가 일할 방식: code(만들고 고침) · debug(원인 찾기) · ask(읽고 답만). 안 적으면 code.',
         },
@@ -72,7 +72,7 @@ export const TASK_TOOL = {
          * 약속을 그 자리에서 깨는 것이다. 실제 판단은 loop.js 가 한다 —
          * 부탁으로 막지 않는다.
          */
-        모델: {
+        model: {
           type: 'string',
           description:
             '이 덩이를 **다른 모델**에게 맡긴다. 사람이 설정에 적어 둔 프로필 이름만 쓸 수 있다'
@@ -81,7 +81,11 @@ export const TASK_TOOL = {
             + ' 판단이 필요한 일은 네가 직접 해라.',
         },
       },
-      required: ['목적', '할일'],
+      // 위 properties 와 **같은 이름**이어야 한다. 이름을 바꾸면서 여기만
+      // 옛 이름으로 남겨 두면, 서버는 "없는 인자를 필수라고 한다" 고 거절하거나
+      // (더 나쁘게) 그냥 받아 놓고 모델이 아무것도 안 채우게 둔다.
+      // test/toolargs.test.js 가 이 짝을 맞춰 본다.
+      required: ['purpose', 'task'],
     },
   },