deel-local-cli 1.1.0 → 1.2.0

package/src/agent/compact.js

@@ -15,6 +15,93 @@ 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;
+
+  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}${곳 ? `(${곳})` : ''} — ${줄수}줄. `
+        + '자리를 비우려고 내용을 접었습니다. 필요하면 다시 읽으세요.',
+    };
+    아낀토큰 += 전 - estimateTokens(ms[i].content);
+  }
+
+  return { 접은것: 접을것.length, 아낀토큰: Math.max(0, 아낀토큰) };
+}
+
 const 요약지시 = `지금까지의 대화를 다음 형식으로 요약하세요. 이어서 일할 사람이 이것만 보고도 계속할 수 있어야 합니다.
 추측하지 말고 실제로 오간 내용만 쓰세요. 한국어로, 각 항목 3줄 이내로 쓰세요.
 

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/loop.js

@@ -6,7 +6,7 @@ import { isMutating } from '../safety/guard.js';
 import { effortFor, tokensFor, fullCap, wasCut, shiftLevel } from './effort.js';
 import { 살린쓰기 } from './salvage.js';
 import { 배울것, 길이문제인가 } from '../backend/learn.js';
-import { compact, shouldCompact } from './compact.js';
+import { compact, shouldCompact, shouldFold, foldToolResults } from './compact.js';
 import { 걸음수, 하위걸음수, 요약길이 } from './budget.js';
 import { Session } from './session.js';
 import { 최대깊이, 하위모드, 하위요약 } from '../tools/task.js';
@@ -240,6 +240,7 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
      * 세기만 한다 — 판단은 grade.js 가 하고, 프롬프트는 다음 걸음부터 달라진다.
      */
     session.본것?.걸음셈();
+    ctx.배움?.모델본것(conn.model, '걸음');
     // 단계마다 필요한 생각의 양이 다르다. effort.js 가 그 배분을 갖고 있다.
     const stage = steps === 1 ? 'plan' : lastToolFailed ? 'fix' : 'work';
     const level = effortFor(think, effort, stage);
@@ -332,6 +333,7 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
       }
       if (빈답인가(msg)) {
         session.본것?.본것('빈답');
+        ctx.배움?.모델본것(conn.model, '빈답');
         yield {
           type: 'error',
           text: '서버가 빈 답을 보냈습니다.\n'
@@ -403,6 +405,16 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
     session.usage.out += msg.usage?.out ?? 0;
     session.usage.calls++;
 
+    /*
+     * 방금 보낸 것이 실제로 몇 토큰이었는지 서버가 알려 줬다. 우리 추정과
+     * 견줘서 배운다 — 여기가 유일하게 정답을 아는 자리다.
+     *
+     * 답을 push 하기 **전**이어야 한다. 지금 이력이 곧 방금 보낸 프롬프트다.
+     */
+    const 새보정 = session.배운다?.(msg.usage?.in);
+    // 배운 배수를 디스크에도 남긴다. 다음에 켤 때 이 값으로 시작한다.
+    if (새보정) ctx.배움?.보정본것(conn.model, 새보정);
+
     session.push(assistantMessage(conn.kind, msg));
 
     if (!msg.toolCalls?.length) {
@@ -438,6 +450,7 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
         // 모델은 고칠 게 없다고 보고 똑같이 다시 시도한다. 그래서 끝없이 돈다.
         if (call.argsBroken) {
           session.본것?.본것('잘린인자');
+          ctx.배움?.모델본것(conn.model, '잘린인자');
           // ── 버리기 전에, 건질 수 있는지 먼저 본다 ──────────────────────
           //
           // 잘린 JSON 안에는 이미 받아 놓은 내용이 들어 있다. 경로도 대개 온전하다.
@@ -704,6 +717,18 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
         if (call.name === 'Edit' && result.error) session.본것?.본것('편집실패');
         else if (!result.error) session.본것?.본것('도구성공');
 
+        /*
+         * 겪은 것을 디스크에도 쌓는다 (agent/evolve.js).
+         *
+         * 위의 지켜본것은 이 대화가 끝나면 사라진다. 그래서 어제 알아낸 것을
+         * 오늘 또 알아내야 했다 — `pnpm` 이 이 PC 에 없다는 걸 매일 다시 겪는다.
+         * 명령의 성패는 이 폴더의 사실이므로 폴더 쪽에 남긴다.
+         */
+        if (call.name === 'Bash' && call.args?.command) {
+          ctx.배움?.명령본것(call.args.command, !result.error, result.error ?? '');
+        }
+        if (call.name === 'Edit' && result.error) ctx.배움?.모델본것(conn.model, '편집실패');
+
         if (result.error) {
           lastToolFailed = true;
           // 같은 도구가 같은 이유로 계속 실패하면 헛돌고 있는 것이다.
@@ -755,6 +780,18 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0 }
       return;
     }
 
+    /*
+     * 요약해서 접기 **전에** 도구 결과부터 접는다.
+     *
+     * 자리를 먹는 것은 대개 사람 말이 아니라 옛날에 읽어 둔 파일이다. 그쪽을
+     * 먼저 비우면 요약 압축을 한참 미룰 수 있고, 미루는 동안 대화는 한 글자도
+     * 안 잃는다. 그래도 차면 아래에서 통째로 요약한다.
+     */
+    if (shouldFold(session)) {
+      const f = foldToolResults(session);
+      if (f.접은것) yield { type: 'folded', ...f };
+    }
+
     // 컨텍스트가 차오르면 오래된 대화를 '요약해서' 접는다. 그냥 자르면 하던 일을 잊는다.
     if (shouldCompact(session)) {
       yield { type: 'compacting' };

package/src/agent/modes.js

@@ -233,6 +233,8 @@ export const MODES = {
       "  6. 확인 방법 — 무엇을 돌려 보면 됐는지 알 수 있는가",
       "",
       "단계는 TodoWrite 로도 적어라. 승인 뒤 그대로 이어서 하게 된다.",
+      "  단계 수는 정해져 있지 않다 — 일의 크기에 맞춰라. 세 개로 맞추지 마라.",
+      "  작은 일이면 두세 개로 끝내고, 큰 일이면 열 개가 넘어도 그대로 다 적어라.",
       "모르는 것이 있으면 지어내지 말고 \"이건 확인이 필요하다\" 고 적어라.",
       "",
       "마지막에 \"이대로 진행할까요?\" 로 끝내라. 승인을 받으면 /code 로 바꿔 실행한다.",

package/src/agent/route.js

@@ -110,15 +110,66 @@ const 문턱 = {
   ask: 5,
 };
 
+/*
+ * ── 겹친 요청 ───────────────────────────────────────────────────────────
+ *
+ * "계획해주고 만들어줘" 처럼 **계획과 실행이 한 말에 같이** 든 것.
+ *
+ * 이건 위의 점수표로는 못 고른다. '만들어' 가 code 3점 문턱을 그냥 넘어서
+ * 곧장 코드 모드로 가 버리고, 사람이 보자고 한 계획은 안 나온다.
+ * 실제로 겪었다 — "정리해서 만들어줘" 가 계획 한 줄 없이 파일부터 만들었다.
+ *
+ * 반대로 plan 으로 보내면 계획만 내고 멈춘다. 그것도 시킨 일의 절반이다.
+ * 그래서 따로 알아본다. 계획을 내고 → 승인을 받고 → 그대로 실행까지 잇는다.
+ *
+ * 좁게 잡는다. 사용자는 자율 실행을 원했고, 승인 창은 그 결정을 갉아먹는
+ * 쪽이다. '고쳐줘' 한마디에 창이 뜨면 그게 더 나쁘다.
+ * 그래서 **계획말 + 잇는말** 이 앞에 있고 그 **뒤에** 실행말이 와야만 겹침이다.
+ */
+const 계획말 = '계획|플랜|설계|구상|기획|정리|검토|조사|파악|살펴|알아보|분석|로드맵|방향|순서|밑그림|초안';
+// '정리하고' 처럼 잇는 꼴이어야 한다. 그냥 '정리' 하나로는 겹침이 아니다 —
+// "코드 정리해줘" 는 계획이 아니라 그 자체가 할 일이다.
+const 잇는말 = '해\\s*주고|해\\s*놓고|하고\\s*나서|하고서|한\\s*다음|한\\s*뒤|한\\s*후|하고|해서|잡고|짜고|세우고|낸\\s*뒤|낸\\s*다음';
+const 실행말 = /만들어|만들자|만들어라|구현|작성|추가(해|하)|생성|써\s*(줘|주세요)|짜\s*(줘|주세요)|고쳐|세팅|설치|배포/;
+const 계획먼저 = new RegExp(`(${계획말})\\s*(?:을|를)?\\s*(?:${잇는말})`);
+// 영어도 같이 본다 — "plan and then build it" 처럼 붙여 넣는 일이 있다.
+const 영어겹침 = /\b(plan|design|outline|draft)\b[\s\S]{0,60}?\b(?:and|then|,)\s*(?:then\s*)?\b(build|implement|create|write|make|code)\b/i;
+
+/**
+ * 계획과 실행이 한 말에 같이 들었나.
+ *
+ * @returns {{겹침: boolean, why: string}} 겹침이 아니면 why 는 빈 글.
+ */
+export function 겹친요청(text) {
+  const s = String(text ?? '');
+  const 영어 = s.match(영어겹침);
+  if (영어) return { 겹침: true, why: `'${영어[1]}' 과 '${영어[2]}'` };
+
+  const 앞 = s.match(계획먼저);
+  if (!앞) return { 겹침: false, why: '' };
+  // 실행말이 계획말 **뒤에** 와야 한다. "만들고 나서 정리해줘" 는 겹침이 아니다 —
+  // 그건 만드는 일이 먼저고, 계획을 미리 볼 것이 없다.
+  const 뒤 = s.slice(앞.index + 앞[0].length).match(실행말);
+  if (!뒤) return { 겹침: false, why: '' };
+  return { 겹침: true, why: `'${앞[0].trim()}' 뒤에 '${뒤[0].trim()}'` };
+}
+
 /**
  * 이 한마디가 무슨 일인지 고른다.
  *
  * @param {string} text 사용자가 친 말
- * @returns {{ mode: string|null, score: number, why: string, 점수들: object }}
+ * @returns {{ mode: string|null, score: number, why: string, 겹침: boolean, 점수들: object }}
  *          mode 가 null 이면 '모르겠다' 는 뜻이다 — 종합 모드에 그대로 둔다.
+ *          겹침이 true 면 계획을 내고 승인을 받아 실행까지 이어야 한다는 뜻이다.
  */
 export function route(text) {
   const s = String(text ?? '');
+
+  // 겹친 요청은 점수표보다 먼저 본다. 점수표에 맡기면 '만들어' 가 이겨서
+  // 계획을 건너뛴다 — 그게 바로 이 길을 만든 이유다.
+  const 겹 = 겹친요청(s);
+  if (겹.겹침) return { mode: 'plan', score: 0, why: 겹.why, 겹침: true, 점수들: {} };
+
   const 점수들 = {};
   const 근거 = {};
 
@@ -138,19 +189,20 @@ export function route(text) {
   const 순위 = Object.entries(점수들).sort((a, b) => b[1] - a[1]);
   const [으뜸, 점수] = 순위[0] ?? [null, 0];
   if (!으뜸 || 점수 < (문턱[으뜸] ?? 4)) {
-    return { mode: null, score: 점수, why: '무슨 일인지 뚜렷하지 않음', 점수들 };
+    return { mode: null, score: 점수, why: '무슨 일인지 뚜렷하지 않음', 겹침: false, 점수들 };
   }
 
   // 1·2등이 붙으면 고르지 않는다. 반반인 것을 억지로 정하면 절반은 틀린다.
   const 둘째 = 순위[1]?.[1] ?? 0;
   if (점수 - 둘째 < 2 && 둘째 >= (문턱[순위[1][0]] ?? 4)) {
-    return { mode: null, score: 점수, why: `${으뜸} 과 ${순위[1][0]} 가 비슷함`, 점수들 };
+    return { mode: null, score: 점수, why: `${으뜸} 과 ${순위[1][0]} 가 비슷함`, 겹침: false, 점수들 };
   }
 
   return {
     mode: 으뜸,
     score: 점수,
     why: 근거[으뜸].slice(0, 2).map((x) => `'${x}'`).join(', '),
+    겹침: false,
     점수들,
   };
 }