deel-local-cli 1.1.1 → 1.4.0

package/src/agent/compact.js

@@ -15,6 +15,101 @@ export const COMPACT_AT = 0.8;
 export const KEEP_TAIL_RATIO = 0.3;   // 최근 대화 중 남길 비율
 export const KEEP_HEAD = 2;           // 맨 처음 요청은 언제나 남긴다 (목표가 거기 있다)
 
+/*
+ * ── 그 전에, 도구 결과부터 접는다 ──────────────────────────────────────
+ *
+ * 요약 압축은 잃는 것이 크다. 사람이 한 말도, 모델이 왜 그렇게 정했는지도
+ * 세 줄로 줄어든다. 그런데 자리를 실제로 먹고 있는 것은 대개 그쪽이 아니다.
+ *
+ *   Read 로 600줄짜리 파일을 한 번 열면 32k 창의 15% 가 그 자리에서 사라지고,
+ *   그 사본은 대화가 끝날 때까지 이력에 그대로 눌러앉는다. 이미 다 읽고 고친
+ *   파일인데도 그렇다. 세 번 읽으면 창의 절반이 옛날 파일 내용이다.
+ *
+ * 그래서 80% 에서 통째로 요약하기 전에, 먼저 **오래된 도구 결과만** 한 줄로
+ * 접는다. 사람 말과 모델의 판단은 한 글자도 안 건드린다. 무엇을 읽었는지는
+ * 남기므로 모델은 필요하면 그 파일을 다시 읽으면 된다 — 읽는 값은 싸고,
+ * 하던 일을 잊는 값은 비싸다.
+ *
+ * 최근 것은 안 접는다. 방금 읽은 것을 접으면 그 자리에서 다시 읽게 되고,
+ * 그러면 접은 보람이 없다.
+ */
+export const FOLD_AT = 0.55;      // 이 아래로는 접을 이유가 없다
+export const KEEP_RECENT = 4;     // 최근 도구 결과 이만큼은 원문 그대로 둔다
+export const FOLD_MIN = 300;      // 이보다 작으면 접어도 자리가 안 준다 (글자 수)
+export const 접힘표 = '(접힘)';
+
+/** 인자에서 사람이 알아볼 한 조각만 뽑는다. 경로가 제일 쓸모 있다. */
+function 어디(args) {
+  if (!args || typeof args !== 'object') return '';
+  for (const k of ['file_path', 'path', 'pattern', 'command', 'query', 'url', '목적']) {
+    const v = args[k];
+    if (typeof v === 'string' && v.trim()) return v.trim().replace(/\s+/g, ' ').slice(0, 60);
+  }
+  return '';
+}
+
+export function shouldFold(session, at = FOLD_AT) {
+  const b = session.breakdown();
+  return b.total > 0 && b.used / b.total >= at;
+}
+
+/**
+ * 오래된 도구 결과를 한 줄로 접는다.
+ *
+ * 짝은 안 건드린다 — 메시지를 지우는 게 아니라 **내용만** 바꾸므로 호출과
+ * 결과의 짝이 그대로다. 규격이 깨질 자리가 아예 없다.
+ *
+ * @returns {{접은것: number, 아낀토큰: number}}
+ */
+export function foldToolResults(session, { keep = KEEP_RECENT, min = FOLD_MIN } = {}) {
+  const ms = session.messages ?? [];
+
+  // 호출 쪽에서 이름과 인자를 가져온다. 결과 메시지에는 그게 안 실려 있다.
+  const 이름표 = new Map();
+  for (const m of ms) {
+    for (const c of m?.tool_calls ?? []) {
+      let args = {};
+      try { args = JSON.parse(c?.function?.arguments ?? '{}'); } catch { /* 못 읽으면 그만 */ }
+      if (c?.id) 이름표.set(c.id, { name: c?.function?.name ?? '도구', args });
+    }
+  }
+
+  const 자리 = [];
+  ms.forEach((m, i) => {
+    if (m?.role !== 'tool') return;
+    const 글 = typeof m.content === 'string' ? m.content : '';
+    if (글.startsWith(접힘표)) return;      // 이미 접은 것
+    자리.push({ i, 글 });
+  });
+
+  const 접을것 = 자리.slice(0, Math.max(0, 자리.length - keep)).filter((x) => x.글.length >= min);
+  let 아낀토큰 = 0;
+  // 무엇을 버렸는지 이름으로 남긴다.
+  //
+  // 조용히 버리면 사람이 모른다 — "아까 그 파일 내용 어디 갔지" 를 스스로 답할
+  // 길이 없다. 접힌 자리에 표시가 남긴 하지만 그건 모델이 보는 쪽이고,
+  // 사람 화면에는 여기서 돌려주는 목록으로 알려 준다.
+  const 접은것들 = [];
+
+  for (const { i, 글 } of 접을것) {
+    const m = ms[i];
+    const 아는것 = 이름표.get(m.tool_call_id) ?? { name: m.tool_name ?? '도구', args: {} };
+    const 곳 = 어디(아는것.args);
+    const 줄수 = 글.split('\n').length;
+    const 전 = estimateTokens(글);
+    ms[i] = {
+      ...m,
+      content: `${접힘표} ${아는것.name}${곳 ? `(${곳})` : ''} — ${줄수}줄. `
+        + '자리를 비우려고 내용을 접었습니다. 필요하면 다시 읽으세요.',
+    };
+    const 아낀것 = 전 - estimateTokens(ms[i].content);
+    아낀토큰 += 아낀것;
+    접은것들.push({ 도구: 아는것.name, 곳, 줄수, 토큰: Math.max(0, 아낀것) });
+  }
+
+  return { 접은것: 접을것.length, 아낀토큰: Math.max(0, 아낀토큰), 접은것들 };
+}
+
 const 요약지시 = `지금까지의 대화를 다음 형식으로 요약하세요. 이어서 일할 사람이 이것만 보고도 계속할 수 있어야 합니다.
 추측하지 말고 실제로 오간 내용만 쓰세요. 한국어로, 각 항목 3줄 이내로 쓰세요.
 

package/src/agent/evidence.js

@@ -0,0 +1,186 @@
+// 증거 — 「다 됐습니다」 대신 검토할 수 있는 것을 내놓는다.
+//
+// ── 왜 만드나 ───────────────────────────────────────────────────────────
+//
+// 2026년 조사로는 개발자의 **96%가 AI 가 쓴 코드를 온전히 믿지 않는데, 매번
+// 확인하는 사람은 48%** 다. 38%는 "사람 코드보다 리뷰가 더 힘들다"고 답한다.
+//
+// 왜 더 힘든가. 사람이 낸 코드는 "왜 이렇게 했나" 를 물으면 답이 온다. 에이전트가
+// 낸 코드는 **"끝났습니다" 한 줄**과 함께 온다. 그 한 줄은 검토할 수가 없다.
+// 무엇을 근거로 끝났다고 하는지가 그 안에 없기 때문이다.
+//
+// 그래서 이 파일이 하는 일은 하나다 — **말을 증거로 바꾼다.**
+//
+//   무엇을 바꿨나   파일과 줄 수
+//   무엇을 돌렸나   명령과 그 결과
+//   무엇이 증명됐나 고친 **뒤에** 돌아서 **성공한** 것이 있는가
+//
+// ── 제일 중요한 칸 ──────────────────────────────────────────────────────
+//
+// 바꾼 것을 늘어놓는 일은 /diff 도 한다. 여기서만 하는 것은 **증명 안 된 것**을
+// 증명 안 됐다고 말하는 것이다.
+//
+// 고쳐 놓고 아무것도 안 돌렸으면 아무것도 증명되지 않았다. 검사가 빨간데
+// 돌리기는 했다고 초록으로 치면 그건 **빨간 검사를 증거로 내미는** 셈이다.
+// 고치기 **전에** 돌린 검사는 고친 것을 증명하지 못한다 — "아까 돌렸으니 됐다" 가
+// 제일 흔한 자기기만이다. 셋 다 여기서 걸러진다.
+//
+// ── 안 하는 것 ──────────────────────────────────────────────────────────
+//
+// 프롬프트에 안 싣는다. 이건 사람이 보는 것이지 모델에게 먹이는 것이 아니다.
+// 실으면 컨텍스트만 먹고, 모델이 제가 만든 증거를 다시 읽는 이상한 고리가 생긴다.
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+/** 이 명령들은 '확인했다' 로 친다. 돌렸다고 다 증거가 되는 것은 아니다. */
+const 확인하는명령 = /(^|[\s|;&])(npm|pnpm|yarn|bun)\s+(test|run\s+(test|check|lint|build|verify|typecheck))|(^|[\s|;&])(pytest|jest|vitest|mocha|go\s+test|cargo\s+test|mvn\s+test|gradle\s+test|dotnet\s+test|tsc|eslint|ruff|mypy)\b/i;
+
+/** 우리 쪽 확인 도구. Bash 를 안 거치고 확인하는 길이다. */
+const 확인하는도구 = new Set(['Verify', 'Test']);
+
+/**
+ * 이번 대화의 증거를 모은다.
+ *
+ * @param {object} session
+ * @param {object} o
+ * @param {object} o.audit      safety/audit.js 의 Audit
+ * @param {number} o.최근       감사기록을 몇 줄까지 볼까
+ * @param {Date}   o.바꾼때     파일을 언제 고쳤다고 볼까 (검사가 고정할 수 있게)
+ */
+export function 증거모으기(session, { audit = null, 최근 = 400, 바꾼때 = null } = {}) {
+  /*
+   * 감사기록은 폴더에 하나뿐이고 계속 덧붙는다. 그대로 읽으면 **지난주에 돌린
+   * 검사**가 오늘 고친 파일의 증거로 붙는다 — 증거를 모으는 도구가 거짓 증거를
+   * 만드는 셈이다. 이번 세션 것만 본다.
+   */
+  const 이번세션 = audit?.session ?? null;
+  const 기록 = (() => {
+    try {
+      const 전부 = audit?.recent?.(최근) ?? [];
+      return 이번세션 ? 전부.filter((r) => r?.session === 이번세션) : 전부;
+    } catch { return []; }
+  })();
+
+  // 돌린 것 — Bash 와 확인 도구만. 파일을 읽은 것까지 증거라고 하면 목록이
+  // 길어지기만 하고, 읽은 것은 아무것도 증명하지 않는다.
+  const 돌린것 = [];
+  for (const r of 기록) {
+    if (r?.kind !== 'tool') continue;
+    const 도구 = String(r.tool ?? '');
+    if (도구 !== 'Bash' && !확인하는도구.has(도구)) continue;
+    돌린것.push({
+      도구,
+      무엇: String(r.target ?? ''),
+      됐나: r.ok !== false,
+      남긴말: r.ok === false ? `실패 — ${String(r.note ?? '').slice(0, 120)}` : String(r.note ?? '').slice(0, 120),
+      때: r.at ?? null,
+      확인인가: 확인하는도구.has(도구) || 확인하는명령.test(String(r.target ?? '')),
+    });
+  }
+
+  const 확인시도 = 돌린것.filter((x) => x.확인인가);
+  const 언제고쳤나 = 바꾼때 ? new Date(바꾼때).getTime() : null;
+
+  const 바꾼것 = [];
+  const 증명안된것 = [];
+  for (const [파일, d] of session?.changes ?? new Map()) {
+    // 고친 **뒤에** 돌린 확인만 본다.
+    const 쓸것 = 확인시도.filter((x) => {
+      if (언제고쳤나 == null || !x.때) return true;   // 시각을 모르면 순서를 안 따진다
+      return new Date(x.때).getTime() >= 언제고쳤나;
+    });
+    /*
+     * **마지막** 확인이 증거다. 성공한 것 중 마지막이 아니다.
+     *
+     * 빌드가 통과하고 그 뒤에 검사가 깨졌는데 앞의 초록을 들고 와서
+     * "확인됐습니다" 하면 그게 거짓 증거다. 사람이 보는 순서로 생각하면
+     * 답이 분명하다 — 마지막에 돌린 것이 빨간데 확인됐을 리가 없다.
+     */
+    const 마지막 = 쓸것.length ? 쓸것[쓸것.length - 1] : null;
+    const 증명 = 마지막?.됐나 ? 마지막.무엇 : null;
+    const 한줄 = { 파일, 더한줄: d.added ?? 0, 뺀줄: d.removed ?? 0, 고친횟수: d.times ?? 0, 증명 };
+    바꾼것.push(한줄);
+    if (!증명) {
+      증명안된것.push({
+        파일,
+        왜: 왜못믿나(돌린것, 마지막, 언제고쳤나),
+      });
+    }
+  }
+
+  return {
+    바꾼것,
+    돌린것,
+    증명안된것,
+    // 화면이 한눈에 쓸 수 있게 미리 세어 둔다.
+    셈: {
+      파일: 바꾼것.length,
+      더한줄: 바꾼것.reduce((a, x) => a + x.더한줄, 0),
+      뺀줄: 바꾼것.reduce((a, x) => a + x.뺀줄, 0),
+      돌린것: 돌린것.length,
+      실패한것: 돌린것.filter((x) => !x.됐나).length,
+      증명안됨: 증명안된것.length,
+    },
+  };
+}
+
+function 왜못믿나(돌린것, 마지막, 언제고쳤나) {
+  if (!돌린것.length) return '고친 뒤에 아무것도 안 돌렸습니다 — 무엇도 확인되지 않았습니다.';
+  const 확인시도 = 돌린것.filter((x) => x.확인인가);
+  if (!확인시도.length) return '명령은 돌렸지만 검사·빌드는 안 돌렸습니다.';
+  if (마지막 && !마지막.됐나) {
+    return `마지막으로 돌린 \`${마지막.무엇}\` 이 실패했습니다 — 그 앞이 통과했어도 지금 상태를 증명하지 못합니다.`;
+  }
+  if (!마지막 && 언제고쳤나 != null) return '검사가 이 파일을 고치기 전에 돌았습니다 — 그 뒤 바뀐 것은 확인되지 않았습니다.';
+  return '확인되지 않았습니다.';
+}
+
+/** 사람이 읽고 남길 수 있는 글. 마크다운. */
+export function 증거글(증거, { 제목 = '작업 증거' } = {}) {
+  const e = 증거 ?? {};
+  const 줄 = [`# ${제목}`, ''];
+
+  줄.push('## 바꾼 것', '');
+  if (!e.바꾼것?.length) 줄.push('바꾼 파일이 없습니다.', '');
+  else {
+    줄.push('| 파일 | 더함 | 뺌 | 확인한 것 |', '|---|---|---|---|');
+    for (const x of e.바꾼것) {
+      줄.push(`| ${x.파일} | +${x.더한줄} | -${x.뺀줄} | ${x.증명 ? `\`${x.증명}\`` : '**없음**'} |`);
+    }
+    줄.push('');
+  }
+
+  줄.push('## 돌린 것', '');
+  if (!e.돌린것?.length) 줄.push('돌린 명령이 없습니다.', '');
+  else {
+    for (const x of e.돌린것) {
+      줄.push(`- ${x.됐나 ? '✓' : '✗'} \`${x.무엇}\`${x.남긴말 ? ` — ${x.남긴말}` : ''}`);
+    }
+    줄.push('');
+  }
+
+  // 이 절이 이 글의 요점이다. 비어 있으면 비어 있다고 분명히 적는다.
+  줄.push('## 증명 안 된 것', '');
+  if (!e.증명안된것?.length) 줄.push('없습니다 — 바꾼 것마다 뒤에 돌린 확인이 있습니다.', '');
+  else {
+    for (const x of e.증명안된것) 줄.push(`- **${x.파일}** — ${x.왜}`);
+    줄.push('');
+  }
+
+  return 줄.join('\n');
+}
+
+/**
+ * 파일로 남긴다. 화면은 스크롤로 사라지고, 검토는 나중에 다른 사람이 한다.
+ *
+ * @returns {string|null} 적은 자리. 못 적었으면 null — 못 적어도 대화는 계속된다.
+ */
+export function 증거적기(root, 증거, 이름 = '증거') {
+  try {
+    const dir = join(root, '.deel', '증거');
+    mkdirSync(dir, { recursive: true });
+    const 자리 = join(dir, `${String(이름).replace(/[^\w가-힣.-]/g, '_')}.md`);
+    writeFileSync(자리, 증거글(증거), 'utf8');
+    return 자리;
+  } catch { return null; }
+}

package/src/agent/evolve.js

@@ -0,0 +1,213 @@
+// 쓸수록 이 PC 에 맞춰 나아진다.
+//
+// ── 왜 만드나 ───────────────────────────────────────────────────────────
+//
+// deel 은 이미 세 군데서 뭔가를 배우고 있었다. 그런데 셋 다 **끄면 사라졌다.**
+//
+//   backend/learn.js  서버가 거절하면 그 말에서 상한을 배운다 → 그 세션에서만
+//   agent/grade.js    모델이 인자를 자주 잘라 먹는지 지켜본다 → 그 세션에서만
+//   session.배운다()   토큰 추정을 실제값에 맞춘다            → 그 세션에서만
+//
+// 그래서 켤 때마다 처음부터 다시 겪는다. 어제 `pnpm` 이 이 PC 에 없다는 걸
+// 알아냈어도 오늘 또 부르고, 또 실패하고, 또 우회한다. 같은 실수를 매일 한다.
+//
+// 여기서는 **겪은 것을 조금씩 쌓아 두고**, 다음에 켤 때 몇 줄로 요약해 넘긴다.
+//
+// ── 학습이 아니다 ───────────────────────────────────────────────────────
+//
+// 모델을 고치는 것이 아니고, 대화를 통째로 쌓아 두는 것도 아니다. 그러면
+// 컨텍스트만 먹는다. 여기 쌓는 것은 **확인된 사실 몇 줄**이다.
+//
+//   · 세어 두기만 한다 — 무엇이 몇 번 됐고 몇 번 안 됐나
+//   · 확신이 설 때만 말한다 — 한 번 겪은 것은 우연일 수 있다
+//   · 상한을 못 박는다 — 프롬프트에 실리는 것은 220토큰까지다
+//
+// 자리를 아끼는 쪽이 오히려 값이 크다. 여기 한 줄이 모델이 헛도는 걸음
+// 서너 개를 없앤다 — 그 걸음 하나가 파일 내용 한 벌씩이다.
+//
+// ── 무엇을 어디에 쌓나 ──────────────────────────────────────────────────
+//
+//   <작업폴더>/.deel/배운것.json   이 프로젝트에서만 맞는 것 (명령·인코딩)
+//   <설정폴더>/배운것.json          이 PC·이 모델에 붙는 것 (버릇·토큰 보정)
+//
+// 나눠 두는 이유는 하나다. "`npm test` 가 된다" 는 이 폴더의 사실이고,
+// "이 모델은 인자를 잘라 먹는다" 는 모델의 사실이다. 섞어 두면 폴더를 옮길
+// 때마다 모델에 대해 알아낸 것을 통째로 잃는다.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { estimateTokens } from './session.js';
+
+export const 최대토큰 = 220;    // 프롬프트에 실을 상한
+const 명령최대 = 40;            // 표가 끝없이 자라지 않게
+const 모델최대 = 10;
+
+const 빈것 = () => ({ 판: 1, 명령: {}, 모델: {} });
+
+function 읽기(파일) {
+  try {
+    if (!existsSync(파일)) return 빈것();
+    const j = JSON.parse(readFileSync(파일, 'utf8'));
+    return { ...빈것(), ...(j && typeof j === 'object' ? j : {}) };
+  } catch { return 빈것(); }
+}
+
+function 쓰기(파일, 값) {
+  try {
+    mkdirSync(dirname(파일), { recursive: true });
+    writeFileSync(파일, JSON.stringify(값, null, 2), 'utf8');
+  } catch { /* 못 적어도 대화는 계속돼야 한다 */ }
+}
+
+/** 오래된 것부터 버려서 표를 상한 안에 둔다. */
+function 줄이기(표, 상한) {
+  const 열쇠 = Object.keys(표);
+  if (열쇠.length <= 상한) return 표;
+  열쇠.sort((a, b) => String(표[a]?.at ?? '').localeCompare(String(표[b]?.at ?? '')));
+  for (const k of 열쇠.slice(0, 열쇠.length - 상한)) delete 표[k];
+  return 표;
+}
+
+export class 배움 {
+  /**
+   * @param {string} root  작업 폴더
+   * @param {string} home  설정 폴더 (~/.deel 또는 DEEL_HOME)
+   * @param {string} 지금  시각. 검사가 고정할 수 있게 밖에서 받는다
+   */
+  constructor(root, home, 지금 = new Date().toISOString()) {
+    this.지금 = 지금;
+    this.폴더파일 = root ? join(root, '.deel', '배운것.json') : null;
+    this.집파일 = home ? join(home, '배운것.json') : null;
+    this.폴더 = this.폴더파일 ? 읽기(this.폴더파일) : 빈것();
+    this.집 = this.집파일 ? 읽기(this.집파일) : 빈것();
+  }
+
+  /**
+   * 명령 하나가 됐는지 안 됐는지.
+   *
+   * 명령줄 전체가 아니라 **앞머리 두 낱말**만 센다. `npm test -- --watch` 와
+   * `npm test` 는 같은 사실이고, 경로·인자까지 세면 표가 금세 쓸모없어진다.
+   *
+   * 다만 **프로그램이 아예 없어서** 실패한 것은 첫 낱말만 센다. `pnpm install`
+   * 이 안 되고 `pnpm add` 도 안 됐다면 그건 두 가지 사실이 아니라 "이 PC 에
+   * pnpm 이 없다" 는 한 가지 사실이다. 두 낱말로 세면 서로 다른 칸에 하나씩
+   * 쌓여서 영영 확신에 못 이른다 — 매번 다시 겪는다.
+   */
+  명령본것(명령, 됐나, 이유 = '') {
+    const 낱말 = String(명령 ?? '').trim().split(/\s+/);
+    const 없는프로그램 = !됐나
+      && /not found|not recognized|ENOENT|찾을 수 없|없는 명령/i.test(String(이유 ?? ''));
+    const 열쇠 = (없는프로그램 ? 낱말.slice(0, 1) : 낱말.slice(0, 2)).join(' ').slice(0, 40);
+    if (!열쇠) return this;
+    const 표 = this.폴더.명령;
+    const r = 표[열쇠] ?? { ok: 0, no: 0, at: this.지금 };
+    if (됐나) r.ok++; else r.no++;
+    r.at = this.지금;
+    표[열쇠] = r;
+    줄이기(표, 명령최대);
+    this.#저장폴더();
+    return this;
+  }
+
+  /** 모델이 보인 버릇 하나. grade.js 의 지켜본것 과 같은 이름을 쓴다. */
+  모델본것(모델, 무엇, n = 1) {
+    const r = this.#모델칸(모델);
+    if (!r) return this;
+    r[무엇] = (r[무엇] ?? 0) + n;
+    r.at = this.지금;
+    this.#저장집();
+    return this;
+  }
+
+  /** 토큰 추정 배수. 다음에 켤 때 이 값으로 시작한다. */
+  보정본것(모델, 배수) {
+    const n = Number(배수);
+    if (!Number.isFinite(n) || n < 0.5 || n > 2) return this;
+    const r = this.#모델칸(모델);
+    if (!r) return this;
+    // 갑자기 튀지 않게 지난 값과 섞는다. 대화마다 조금씩 옮겨 간다.
+    r.보정 = r.보정 ? r.보정 + (n - r.보정) * 0.5 : n;
+    r.at = this.지금;
+    this.#저장집();
+    return this;
+  }
+
+  /** 지난번에 알아낸 토큰 배수. 없으면 null. */
+  아는보정(모델) {
+    const r = this.집.모델?.[String(모델 ?? '')];
+    return r?.보정 && r.보정 >= 0.5 && r.보정 <= 2 ? r.보정 : null;
+  }
+
+  #모델칸(모델) {
+    const 이름 = String(모델 ?? '').trim();
+    if (!이름) return null;
+    const 표 = this.집.모델;
+    표[이름] = 표[이름] ?? { 걸음: 0, at: this.지금 };
+    줄이기(표, 모델최대);
+    return 표[이름];
+  }
+
+  #저장폴더() { if (this.폴더파일) 쓰기(this.폴더파일, this.폴더); }
+  #저장집() { if (this.집파일) 쓰기(this.집파일, this.집); }
+
+  /**
+   * 프롬프트에 실을 몇 줄.
+   *
+   * 확신이 서는 것만 말한다. 두 번 겪지 않은 것은 우연일 수 있고, 우연을
+   * 사실처럼 적으면 모델이 그 위에서 엉뚱한 판단을 한다 — 안 배우느니만 못하다.
+   *
+   * @returns {string|null} 없으면 null (그때는 프롬프트에 아무것도 안 붙는다)
+   */
+  요약(모델 = '', 상한 = 최대토큰) {
+    const 줄 = [];
+
+    // 되는 명령 / 안 되는 명령. 이 폴더의 사실이다.
+    const 되는것 = [];
+    const 안되는것 = [];
+    for (const [열쇠, r] of Object.entries(this.폴더.명령 ?? {})) {
+      if (r.ok >= 2 && r.no === 0) 되는것.push(열쇠);
+      else if (r.no >= 2 && r.ok === 0) 안되는것.push(열쇠);
+    }
+    if (되는것.length) 줄.push(`- 여기서 되는 명령: ${되는것.slice(0, 6).map((x) => `\`${x}\``).join(' · ')}`);
+    if (안되는것.length) 줄.push(`- 이 PC 에서 안 되는 명령(다시 부르지 마라): ${안되는것.slice(0, 6).map((x) => `\`${x}\``).join(' · ')}`);
+
+    // 모델 버릇. 걸음이 쌓여야 말이 된다.
+    const m = this.집.모델?.[String(모델 ?? '')];
+    if (m && (m.걸음 ?? 0) >= 10) {
+      if ((m.잘린인자 ?? 0) / m.걸음 >= 0.15) {
+        줄.push('- 이 모델은 큰 인자를 자주 잘라 먹었다. 파일은 Write 한 번에 다 쓰지 말고 Append 로 나눠 써라.');
+      }
+      if ((m.편집실패 ?? 0) / m.걸음 >= 0.15) {
+        줄.push('- Edit 이 자주 빗나갔다. old_string 은 Read 로 본 그대로, 공백까지 옮겨 담아라.');
+      }
+      if ((m.되풀이 ?? 0) / m.걸음 >= 0.15) {
+        줄.push('- 같은 호출을 되풀이한 적이 잦다. 한 번 실패한 방법은 바꿔서 시도해라.');
+      }
+    }
+
+    if (!줄.length) return null;
+
+    const 머리 = '## 여기서 겪어 본 것 (자동으로 쌓임)';
+    const out = [머리];
+    for (const l of 줄) {
+      if (estimateTokens([...out, l].join('\n')) > 상한) break;
+      out.push(l);
+    }
+    return out.length > 1 ? out.join('\n') : null;
+  }
+
+  /** 사람이 지우라고 한 것. 파일째 비운다. */
+  지우기(어디 = '전부') {
+    if (어디 === '전부' || 어디 === '폴더') { this.폴더 = 빈것(); this.#저장폴더(); }
+    if (어디 === '전부' || 어디 === '모델') { this.집 = 빈것(); this.#저장집(); }
+    return this;
+  }
+
+  /** 화면에 뿌릴 것. */
+  현황(모델 = '') {
+    const 명령 = Object.entries(this.폴더.명령 ?? {})
+      .map(([이름, r]) => ({ 이름, ...r }))
+      .sort((a, b) => (b.ok + b.no) - (a.ok + a.no));
+    const m = this.집.모델?.[String(모델 ?? '')] ?? null;
+    return { 명령, 모델: m, 모델이름: String(모델 ?? '') };
+  }
+}

package/src/agent/grade.js

@@ -1,3 +1,4 @@
+import { 언어 } from '../i18n/index.js';
 /**
  * 모델 급 — 지금 붙어 있는 모델이 얼마나 하는가.
  *
@@ -194,7 +195,26 @@ export function 값(급) {
 export function 급말(급) {
   const v = 값(급);
   if (급 === '큼') return '';
+  /*
+   * 이 글도 모델이 읽는 것이라 화면 말을 따라간다.
+   *
+   * 안 따라가면 영어로 켠 사람의 작은 모델만 한국어 지시를 받는데, 하필
+   * 그 조합이 제일 흔들리기 쉽다 — 작은 모델은 못 읽는 말이 섞이면 그 줄을
+   * 통째로 흘린다. 지시가 있는 척하면서 실제로는 없는 상태가 된다.
+   */
+  const 영 = 언어() === 'en';
   const 줄 = [];
+  if (영) {
+    줄.push('Sized to this model:');
+    줄.push(`- Create at most ${v.한번에쓸파일} files in one Write call. More than that, split it across calls.`);
+    줄.push(`- For a file over ${v.나눠쓰기줄} lines, Write the first part and Append the rest.`);
+    if (급 === '작음') {
+      줄.push('- One thing per step. Do not call several tools at once.');
+      줄.push('- Edit a file on the **very next step** after you Read it. Do not put anything in between.');
+    }
+    줄.push('- Call Verify before you finish. Fix what comes back and call it again.');
+    return 줄.join('\n');
+  }
   줄.push('이 모델에 맞춘 것:');
   줄.push(`- 파일을 한 번에 만들 때는 ${v.한번에쓸파일}개까지만. 더 있으면 나눠서 여러 번 불러라.`);
   줄.push(`- ${v.나눠쓰기줄}줄이 넘는 파일은 Write 로 앞부분만 만들고 Append 로 이어 붙여라.`);