deel-local-cli 2.1.2 → 2.1.4

package/src/safety/undo.js

@@ -327,6 +327,31 @@ export class History {
     return rec;
   }
 
+  /**
+   * 명령이 **이미 바꾼** 파일의 앞 모습을 적는다 (2.1.3 · safety/gitsnap.js).
+   *
+   * 앞 모습은 부르는 쪽이 준다 — git 이 들고 있던 것이나 명령 전에 떠 둔 사본. `앞` 이 Buffer 면 그 내용,
+   * null 이면 「원래 없던 자리」(되돌리면 지운다). 바이너리는 snapshot 과 같이 못 뜬 것으로 적고 크기를 남긴다.
+   * 이번 턴에 이미 뜬 자리면 안 적는다 — 그 기록이 턴 처음 모습이다.
+   */
+  뒤늦은기록(absPath, 앞, label) {
+    if (this.떴나(absPath)) return null;   // 이번 턴 처음 모습이 이미 있다
+    if (앞 === null) return this.없던자리기록(absPath, label);
+    const 뜬것 = 뜨기(Buffer.from(앞));
+    const rec = { turn: this.turn, at: new Date().toISOString(), path: absPath, before: 뜬것.before, label };
+    const 상대 = this.#상대(absPath);
+    if (상대 !== null) rec.rel = 상대;
+    if (뜬것.enc) rec.enc = 뜬것.enc;
+    if (뜬것.skipped) { rec.skipped = 뜬것.skipped; rec.크기 = 앞.length; }
+    this.#덧붙이기(rec);
+    this.#잠그기();
+    this.#이번턴.set(absPath, rec);
+    const 낮춘 = absPath.toLowerCase();
+    this.#낮춘이름.set(낮춘, [...(this.#낮춘이름.get(낮춘) ?? []), absPath]);
+    this.#maybePrune();
+    return rec;
+  }
+
   /*
    * ── 떠 놓고 **못 쓴** 기록을 거둔다 ───────────────────────────────────
    *
@@ -841,7 +866,11 @@ function 같은물건(p, q) {
 }
 
 function safeRead(p) {
-  const buf = readFileSync(p);
+  return 뜨기(readFileSync(p));
+}
+
+/** 바이트를 이력에 적을 모양으로 (safeRead 와 gitsnap 의 앞 모습이 같이 쓴다). */
+function 뜨기(buf) {
   // 바이너리는 내용을 담지 않는다. '없던 파일' 과는 다른 값으로 알린다 —
   // 이 둘을 같은 null 로 뭉쳐 놨던 것이 /undo 가 파일을 지우던 원인이다.
   if (looksBinary(buf)) return { before: null, skipped: '바이너리' };

package/src/safety/which.js

@@ -0,0 +1,37 @@
+// 실행 파일을 PATH 에서 **우리가** 찾는다 — 셸이나 운영체제가 찾게 두지 않는다.
+//
+// tools/verify.js 에서 떼어 냈다 (2.1.3). 되돌리기의 git 뜨기(safety/gitsnap.js)도 같은 자로 git 을 찾는다 —
+// 두 벌이면 언젠가 한 벌만 고친다. 여기는 fs 와 path 만 부른다(되돌리기는 설정이 깨져도 돌아야 하는 자리다).
+
+import { statSync } from 'node:fs';
+import { resolve, join, delimiter, isAbsolute, relative } from 'node:path';
+
+/**
+ * 이름으로 실행 파일을 PATH 에서 찾는다.
+ *
+ * 지금 폴더를 뜻하는 칸(빈 칸·`.`·상대 경로)과 작업 폴더 안의 칸은 건너뛴다. 그 자리의
+ * 파일은 저장소가 심을 수 있다. 윈도우에서는 `.exe` 만 본다 — `.cmd`·`.bat` 은 결국
+ * cmd.exe 를 부르는 것이라 셸을 안 거친다는 뜻이 없어진다.
+ *
+ * @returns {string|null} 절대 경로. 못 찾으면 null — 그러면 「도구가 없다」 로 말한다.
+ */
+export function 경로에서찾기(이름들, { env = process.env, 뿌리 = null } = {}) {
+  const 윈 = process.platform === 'win32';
+  // 윈도우 환경 이름은 대소문자를 안 가린다(Path · PATH). 거른 환경 객체는 평범한 객체라 직접 찾는다.
+  const 칸 = Object.keys(env ?? {}).find((k) => (윈 ? k.toUpperCase() === 'PATH' : k === 'PATH'));
+  const 목록 = String((칸 && env[칸]) ?? '').split(delimiter);
+  const 뿌리abs = 뿌리 ? resolve(뿌리) : null;
+  for (const 이름 of 이름들) {
+    for (const 날것 of 목록) {
+      const 폴더 = 날것.trim().replace(/^"(.*)"$/, '$1');
+      if (!폴더 || !isAbsolute(폴더)) continue;
+      if (뿌리abs) {
+        const rel = relative(뿌리abs, resolve(폴더));
+        if (rel === '' || (!rel.startsWith('..') && !isAbsolute(rel))) continue;
+      }
+      const 후보 = join(폴더, 윈 ? `${이름}.exe` : 이름);
+      try { if (statSync(후보).isFile()) return 후보; } catch { /* 여기엔 없다 */ }
+    }
+  }
+  return null;
+}

package/src/setup.js

@@ -14,6 +14,7 @@ import { allowEndpoint } from './safety/network.js';
 import { 인증서설정, 인증서등록 } from './backend/clientcert.js';
 import { 바깥인가, 봉인됐나 } from './safety/runmode.js';
 import { 제공자들, 제공자고르기, 어디것일까, 주소후보, 막힌까닭, 열쇠다듬기 } from './providers/index.js';
+import { 링크로그인, 원격인가 } from './login.js';
 import { writeFileSync } from 'node:fs';
 
 // 머리 한 줄은 ui/banner.js 에 있다 — 진입점이 이 파일(40개를 끌고 온다) 없이 쓰게 (2.1.2).
@@ -126,14 +127,38 @@ async function connect(url, key, { 조용히 = false, 제공자: 어디 = null }
   return found;
 }
 
+// 한 화면에 보이는 모델 수. 넘으면 이름으로 좁히고, 목록 끝에 「직접 입력」 을 둔다.
+const 모델한화면 = 40;
+
 async function chooseModel(found) {
   if (!found.models.length) {
     say('');
     say(`  ${mark.warn} ${c.yellow('모델 목록을 못 받았습니다.')} ${c.gray('이름을 직접 넣어 주세요.')}`);
     return (await ask('모델 이름')).trim();
   }
-  const items = found.models.slice(0, 40).map((m) => ({ label: m.id, note: m.note ?? '' }));
+  /*
+   * ── 목록이 길면 이름으로 좁힌다 (2.1.4) ─────────────────────────────────
+   *
+   * 앞 40개만 보여 주고 끝이었다. 사내 게이트웨이는 그걸로 됐는데 OpenRouter 는 모델이 수백 개라,
+   * 쓰려는 모델이 41번째 뒤에 있으면 **고를 길이 없었다.** 이름 일부로 좁히고, 그래도 없으면
+   * 목록 끝의 「직접 입력」 으로 빠진다 — 목록은 낡고, 빠져나갈 구멍은 늘 둔다(리전 고르기와 같다).
+   */
+  let 후보 = found.models;
+  const 길다 = 후보.length > 모델한화면;
+  if (길다) {
+    say('');
+    say(`  ${c.gray(`모델이 ${후보.length}개입니다. 이름 일부로 좁힙니다 (예: claude · gpt · llama). 비우면 앞 ${모델한화면}개.`)}`);
+    const 찾을말 = (await ask('찾을 이름')).trim().toLowerCase();
+    if (찾을말) {
+      const 걸린것 = 후보.filter((m) => String(m.id).toLowerCase().includes(찾을말));
+      if (걸린것.length) 후보 = 걸린것;
+      else say(`  ${mark.warn} ${c.yellow(`「${찾을말}」 이 든 모델 이름이 없습니다 — 맞는 모델이 없습니다.`)} ${c.gray(`앞 ${모델한화면}개를 보여 드립니다.`)}`);
+    }
+  }
+  const items = 후보.slice(0, 모델한화면).map((m) => ({ label: m.id, note: m.note ?? '' }));
+  if (길다) items.push({ label: '직접 입력', note: '목록에 없는 이름', 직접: true });
   const i = await pick('사용할 모델', items);
+  if (items[i].직접) return (await ask('모델 이름')).trim();
   return items[i].label;
 }
 
@@ -181,12 +206,20 @@ export async function runProbe(conn, { out = null, 봉인 = false } = {}) {
  * 「직접 넣기」 를 목록 위쪽에 둔다. 목록이 지원 명단처럼 보이면, 거기 없는
  * 회사는 안 되는 줄 알고 돌아선다 (providers/index.js 머리말).
  *
+ * 넷째 갈래 — **브라우저로 로그인** (2.1.4). 빈칸 0개다. 열쇠를 안 넣고 계정으로 받아 온다
+ * (src/login.js). 번호는 셋째에 둔다: 1·2 는 손에 익은 번호라 안 옮긴다.
+ *
+ * @param o.봉인  offline 이 켜져 있나 — 로그인은 여기서 바깥으로 나가므로 여기서 거른다
+ * @param o.원격  브라우저를 이 PC 에서 못 여나 (`--no-browser` · SSH)
  * @returns {{제공자, 주소들: string[], 열쇠: string, 이름: string} | null}
  */
-async function 붙일곳고르기() {
+async function 붙일곳고르기({ 봉인 = false, 원격 = false } = {}) {
+  // 링크로 로그인하는 첫 제공자. 데이터에 그 칸이 있는 곳이면 누구든 같은 흐름을 탄다.
+  const 로그인곳 = 제공자들.find((p) => p.링크로그인);
   const 목록 = [
     { id: '열쇠먼저', label: '열쇠만 있습니다 — 어디 것인지 알아봐 주세요', note: '빈칸 1개' },
     { id: 'custom', label: '주소를 직접 넣기', note: '사내 게이트웨이 · 목록에 없는 곳' },
+    ...(로그인곳 ? [{ id: '링크로그인', label: `브라우저로 로그인 — ${로그인곳.이름}`, note: '빈칸 0개 · 열쇠를 안 넣습니다' }] : []),
     ...제공자들.filter((p) => p.id !== 'custom').map((p) => ({
       id: p.id,
       label: p.이름,
@@ -217,6 +250,8 @@ async function 붙일곳고르기() {
       const 나머지 = 제공자들.map((p) => ({ label: p.이름, note: p.한줄 }));
       제공자 = 제공자들[await pick('어디 열쇠인가요?', 나머지, { def: 0 })];
     }
+  } else if (고른.id === '링크로그인') {
+    제공자 = 로그인곳;
   } else {
     제공자 = 제공자고르기(고른.id);
   }
@@ -281,9 +316,23 @@ async function 붙일곳고르기() {
   }
 
   // ── 열쇠 ─────────────────────────────────────────────────────────────
-  if (!열쇠) {
+  //
+  // 로그인이 되는 곳은 열쇠를 비워 두면 로그인으로 간다 — 벤더 목록에서 골랐어도 같다.
+  if (!열쇠 && 고른.id !== '링크로그인') {
     if (제공자.열쇠받는곳) say(`  ${c.gray('열쇠 받는 곳')} ${c.cyan(제공자.열쇠받는곳)}`);
-    열쇠 = 열쇠다듬기(await ask('API 키', { mask: true }));
+    열쇠 = 열쇠다듬기(await ask('API 키' + (제공자.링크로그인 ? ' (비우면 브라우저로 로그인)' : ''), { mask: true }));
+  }
+  if (!열쇠 && 제공자.링크로그인) {
+    const 받은것 = await 링크로그인(제공자, { 봉인, 원격 });
+    if (!받은것.ok) {
+      say('');
+      say(`  ${mark.no} ${c.yellow(받은것.까닭)}`);
+      say('');
+      return null;
+    }
+    열쇠 = 받은것.열쇠;
+    // 받은 열쇠는 화면에 안 적는다. 어디에 어떻게 잠갔는지는 저장한 뒤에 말한다.
+    say(`  ${mark.ok} ${c.green('로그인했습니다 — 열쇠를 받았습니다.')} ${c.gray('화면에 안 적고, 저장할 때 잠가 둡니다.')}`);
   }
 
   const 기본이름 = 제공자.id === 'custom' ? '사내게이트웨이' : 제공자.이름;
@@ -343,7 +392,14 @@ async function 설정받기(flags = {}) {
   // 주소를 손으로 치게 만드는 것은 우리 잘못이다.
   say(`  ${c.gray('이 PC 에 로컬 모델이 떠 있다면')} ${c.cyan('deel scan --save')} ${c.gray('가 빈칸 없이 찾아 줍니다.')}`);
 
-  const 고른것 = await 붙일곳고르기();
+  /*
+   * 봉인 판정은 **붙일 곳을 고르기 전에** 한다 (2.1.4). 브라우저로 로그인하는 갈래는 고르는
+   * 자리 안에서 바깥으로 나가기 때문이다 — 뒤에서 재면 이미 나간 뒤다. 판정은 깃발과 처음 읽은
+   * 설정만 보므로 앞으로 옮겨도 값이 같다.
+   */
+  const 봉인 = 봉인됐나({ 깃발: flags?.offline, prof: null, cfg: 첫설정 });
+
+  const 고른것 = await 붙일곳고르기({ 봉인, 원격: flags?.['no-browser'] === true || 원격인가() });
   if (!고른것) return 1;
   const { 제공자: 붙일곳, 주소들, 열쇠: key, 이름: name } = 고른것;
 
@@ -363,7 +419,7 @@ async function 설정받기(flags = {}) {
   // 적어 둔 봉인만 걸리고, 사람이 그 자리에서 친 `deel setup --offline` 은 안 걸렸다.
   // 깃발을 믿고 사내 게이트웨이 주소를 넣은 사람은 방금 적은 열쇠까지 실어 보낸 셈이 된다.
   // (diagnose 는 같은 판에서 `깃발: flags.offline` 을 넘긴다 — 두 문이 갈려 있었다.)
-  const 봉인 = 봉인됐나({ 깃발: flags?.offline, prof: null, cfg: 첫설정 });
+  // 판정 자체는 위에서 했다 — 로그인 갈래가 고르는 자리에서 나가기 때문이다.
   const 두드릴것 = 봉인
     ? 주소들.filter((u) => !바깥인가(/^https?:\/\//i.test(u) ? u : `http://${u}`))
     : 주소들;

package/src/slash.js

@@ -0,0 +1,103 @@
+/**
+ * 슬래시 명령을 이름으로 찾는 규칙 — 대화 화면(commands.js)과 `deel run`(oneshot.js)이 같이 쓴다.
+ *
+ * 여기가 commands.js 안에 있었다. 그래서 `deel run` 은 이 셋을 쓰려고 대화 화면의 명령 전부
+ * (화면 · 설정 · 플러그인 · 스캔 …)를 읽었다. 규칙은 한 벌로 두되, 가벼운 자리로 뺀다 (2.1.3).
+ * commands.js 는 여기서 받아 그대로 내보낸다 — 부르던 자리는 안 바뀐다.
+ */
+/** `ext:ReviewCode` 의 꼬리 — 언제나 낮춰서 돌려준다. 찾기와 「비슷한 것」 이 같은 잣대를 쓰게 한다. */
+const 꼬리이름 = (이름) => String(이름 ?? '').split(':').pop().toLowerCase();
+
+/*
+ * ── 이 PC 에서 찾은 슬래시 명령을 이름으로 찾는다 ───────────────────────
+ *
+ * 대화 화면(commands.js 의 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, 몇);
+}
+
+/*
+ * 프롬프트 인자를 가른다. 빈칸으로 가르되 따옴표("…" · '…')로 묶은 것은 한 인자다 — 파일 이름에 빈칸이
+ * 든다. 마지막 인자는 남은 글을 **그대로** 받는다 — 여러 줄 코드를 넘기면 줄바꿈 · 들여쓰기가 살아야 한다.
+ * 남은 것이 통째로 한 따옴표 묶음이면 따옴표만 벗긴다.
+ */
+function 인자가르기(글, 몇) {
+  const s = String(글 ?? '');
+  const 값들 = [];
+  let i = 0;
+  for (let k = 0; k < 몇; k++) {
+    while (i < s.length && /\s/.test(s[i])) i++;
+    if (i >= s.length) break;
+    if (k === 몇 - 1) {
+      const 남은 = s.slice(i).trimEnd();
+      const 묶음 = /^(["'])((?:(?!\1)[\s\S])*)\1$/.exec(남은);
+      값들.push(묶음 ? 묶음[2] : 남은);
+      break;
+    }
+    const 끝 = s[i] === '"' || s[i] === "'" ? s.indexOf(s[i], i + 1) : -1;
+    if (끝 > i) { 값들.push(s.slice(i + 1, 끝)); i = 끝 + 1; continue; }
+    const 시작 = i;
+    while (i < s.length && !/\s/.test(s[i])) i++;
+    값들.push(s.slice(시작, i));
+  }
+  return 값들;
+}
+
+/**
+ * `/mcp__<서버>__<이름> 인자…` — MCP 서버가 낸 프롬프트를 받아 글로 편다 (2.1.3 · backend/mcp.js 의 프롬프트받기).
+ *
+ * 대화 화면과 `deel run` 이 같은 것을 쓴다 — 슬래시명령찾기 를 한 벌로 둔 것과 같은 까닭이다.
+ * 인자는 빈칸으로 갈라 적힌 차례대로 채우고, 마지막 인자가 나머지를 다 받는다(한 문장을 통째로 넘기게 ·
+ * 인자가르기).
+ *
+ * @returns null — 그런 프롬프트가 없다(부르는 쪽은 여느 슬래시 명령을 찾는다)
+ *          { 탈 } — 있는데 못 폈다 · { text, 서버이름, 이름 } — 모델에게 보낼 글
+ */
+export async function MCP프롬프트펴기(서버들, 부른이름, 인자글 = '', { signal = null } = {}) {
+  const { 이름풀기 } = await import('./backend/mcp.js');
+  const 갈린것 = 이름풀기(부른이름);
+  if (!갈린것) return null;
+  const 서버 = (서버들 ?? []).find((s) => s?.이름 === 갈린것.서버);
+  const 프롬프트 = (서버?.프롬프트 ?? []).find((p) => p?.name === 갈린것.도구);
+  if (!프롬프트) return null;
+  const 인자이름들 = (프롬프트.arguments ?? []).map((a) => a.name);
+  const 값들 = 인자가르기(인자글, 인자이름들.length);
+  const 인자 = {};
+  인자이름들.forEach((n, i) => { if (값들[i]) 인자[n] = 값들[i]; });
+  // hasOwn — 인자 이름이 constructor · toString 이면 `in` 은 Object 원형에서 찾아 「있다」 고 한다.
+  const 빠진것 = (프롬프트.arguments ?? []).filter((a) => a.required && !Object.hasOwn(인자, a.name)).map((a) => a.name);
+  if (빠진것.length) {
+    return { 탈: `인자가 모자랍니다 — /${부른이름} ${인자이름들.map((n) => `<${n}>`).join(' ')} (빠진 것: ${빠진것.join(' · ')})` };
+  }
+  if (!서버.쓸수있나()) return { 탈: `${서버.이름} 서버가 죽었습니다: ${서버.죽음 ?? '이유 모름'}` };
+  try {
+    const text = await 서버.프롬프트받기(프롬프트.name, 인자, { signal });
+    if (!text.trim()) return { 탈: `${서버.이름} 서버가 빈 프롬프트를 줬습니다` };
+    return { text, 서버이름: 서버.이름, 이름: 프롬프트.name };
+  } catch (e) {
+    return { 탈: `프롬프트를 못 받았습니다 — ${String(e?.message ?? e)}` };
+  }
+}

package/src/tools/importgraph.js

@@ -0,0 +1,107 @@
+/**
+ * 파일끼리 누가 누구를 불러 쓰나 — Outline 이 **많이 불리는 파일부터** 싣게 센다 (2.1.3).
+ *
+ * ── 왜 이게 필요한가 ───────────────────────────────────────────────────
+ *
+ * Outline 은 폴더의 뼈대를 최근에 손댄 순서로 싣고 창에 맞춰 뒤를 자른다. 그래서 오래 안 건드린 핵심 모듈 —
+ * 파일 수십 개가 불러 쓰는 것 — 이 큰 저장소에서 제일 먼저 잘렸다. 모델은 그 모듈이 있는 줄 모르고, 이미
+ * 있는 것을 새로 만든다.
+ *
+ * ── 무엇을 세나 ────────────────────────────────────────────────────────
+ *
+ *   js · ts   `import … from './x'` · `import './x'` · `import('./x')` · `require('./x')` · `export … from './x'`
+ *             — 점으로 시작하는 것만. 꾸러미 이름(`react`)은 이 폴더의 파일이 아니다.
+ *             확장자를 빼고 적은 것 · 폴더(index) · `.js` 로 적고 `.ts` 인 것까지 짚는다.
+ *   py        `from a.b import c` · `from .b import c` · `import a.b` — 모듈 파일과 `__init__.py`.
+ *
+ * 한 파일이 같은 곳을 여러 번 불러도 한 번이다. 정규식이라 문자열 속 `require('x')` 를 셀 수도 있다 —
+ * Outline 머리말과 같은 까닭으로 괜찮다. 여기 셈은 **무엇을 먼저 보여 줄지**에만 쓰인다.
+ * 읽는 양에 상한을 둔다. 넘으면 넘은 파일은 안 세고(불린 수 0), 그 사실은 부르는 쪽이 적는다.
+ */
+import { readFileSync, statSync } from 'node:fs';
+import { dirname, extname, join, resolve } from 'node:path';
+
+export const 셀파일상한 = 3000;
+const 한개상한 = 256 * 1024;
+
+const js확장 = ['.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx', '.mts', '.cts'];
+const js꼴 = new Set(js확장);
+const js무늬 = /(?:\bfrom\s*|\bimport\s*\(\s*|\brequire\s*\(\s*|^\s*import\s+)(['"])(\.{1,2}\/[^'"\n]*|\.{1,2})\1/gm;
+const py무늬from = /^\s*from\s+(\.*)([\w.]*)\s+import\s+\(?([^\n#)]*)/gm;
+const py무늬import = /^\s*import\s+([\w.]+(?:\s+as\s+\w+)?(?:\s*,\s*[\w.]+(?:\s+as\s+\w+)?)*)/gm;
+
+/**
+ * @param {string} 뿌리  작업 폴더 (파이썬 절대 가져오기의 기준)
+ * @param {string[]} 파일들  절대 경로. 이 안에서만 짚고 센다.
+ * @returns {Map<string, number>} 절대 경로 → 그 파일을 불러 쓰는 **다른 파일** 수. 넘친 것이 있으면 `.넘침` 에 수.
+ */
+export function 들여옴세기(뿌리, 파일들, { 상한 = 셀파일상한 } = {}) {
+  const 셈 = new Map();
+  // 윈도우 · 맥은 대소문자를 안 가린다 — 적힌 글자와 디스크 글자가 달라도 같은 파일로 짚는다.
+  const 안가림 = process.platform === 'win32' || process.platform === 'darwin';
+  const 열쇠 = (p) => (안가림 ? p.toLowerCase() : p);
+  const 있는것 = new Map();
+  for (const p of 파일들) 있는것.set(열쇠(resolve(p)), resolve(p));
+  const 짚기 = (후보들) => { for (const c of 후보들) { const 찾음 = 있는것.get(열쇠(c)); if (찾음) return 찾음; } return null; };
+
+  const js짚기 = (파일, 적힌) => {
+    const t = resolve(dirname(파일), 적힌);
+    const 후보 = [t, ...js확장.map((e) => t + e), ...js확장.map((e) => join(t, `index${e}`))];
+    // ts 는 `./x.js` 로 적고 `x.ts` 를 둔다 (NodeNext).
+    const e = extname(t);
+    if (e === '.js' || e === '.mjs' || e === '.cjs') {
+      const 몸 = t.slice(0, -e.length);
+      후보.push(`${몸}.ts`, `${몸}.tsx`, `${몸}${e === '.mjs' ? '.mts' : e === '.cjs' ? '.cts' : '.ts'}`);
+    }
+    return 짚기(후보);
+  };
+  const py모듈 = (기준, 이름) => {
+    const 몸 = join(기준, ...이름.split('.').filter(Boolean));
+    return 짚기([`${몸}.py`, `${몸}.pyi`, join(몸, '__init__.py')]);
+  };
+
+  let 본수 = 0;
+  let 넘침 = 0;
+  for (const 파일 of 파일들) {
+    const e = extname(파일).toLowerCase();
+    const js = js꼴.has(e);
+    const py = e === '.py' || e === '.pyi';
+    if (!js && !py) continue;
+    if (본수 >= 상한) { 넘침++; continue; }
+    본수++;
+    let 글;
+    try {
+      if (statSync(파일).size > 한개상한) continue;
+      글 = readFileSync(파일, 'utf8');
+    } catch { continue; }
+    const 나 = resolve(파일);
+    const 부른것 = new Set();
+    if (js) {
+      for (const m of 글.matchAll(js무늬)) { const t = js짚기(나, m[2]); if (t) 부른것.add(t); }
+    } else {
+      for (const m of 글.matchAll(py무늬from)) {
+        const 점 = m[1].length;
+        const 모듈 = m[2];
+        let 기준 = resolve(뿌리);
+        if (점) { 기준 = dirname(나); for (let i = 1; i < 점; i++) 기준 = dirname(기준); }
+        if (모듈) { const t = py모듈(기준, 모듈); if (t) 부른것.add(t); }
+        // `from pkg import util` 의 util 이 하위 모듈일 수 있다.
+        for (const 이름 of m[3].split(',').map((x) => x.trim().split(/\s+/)[0]).filter((x) => /^\w+$/.test(x))) {
+          const t = py모듈(기준, 모듈 ? `${모듈}.${이름}` : 이름);
+          if (t) 부른것.add(t);
+        }
+      }
+      for (const m of 글.matchAll(py무늬import)) {
+        for (const 조각 of m[1].split(',')) {
+          const 이름 = 조각.trim().split(/\s+/)[0];
+          const t = py모듈(resolve(뿌리), 이름);
+          if (t) 부른것.add(t);
+        }
+      }
+    }
+    부른것.delete(나);
+    for (const t of 부른것) 셈.set(t, (셈.get(t) ?? 0) + 1);
+  }
+  셈.넘침 = 넘침;
+  return 셈;
+}

package/src/tools/index.js

@@ -18,13 +18,14 @@ import { TODO_TOOL } from './todo.js';
 import { TASK_TOOL } from './task.js';
 import { 고를말 } from '../agent/agents.js';
 import { OUTLINE_TOOL } from './outline.js';
-import { VERIFY_TOOL } from './verify.js';
+import { VERIFY_TOOL, 한파일문법 } from './verify.js';
 import { DEF_TOOL, REFS_TOOL } from './lsp.js';
 import { 편집후진단, 붙이기 as 진단붙이기, 데우기 } from '../lsp/diag.js';
 import { 프로젝트갈래 } from '../lsp/servers.js';
 import { allow as allowedIn } from '../agent/modes.js';
 import { 도구정의, 이름풀기 } from '../backend/mcp.js';
 import { 셸환경 } from '../safety/shellenv.js';
+import { 깃앞보기, 깃뒤적기 } from '../safety/gitsnap.js';
 import { isExcelPath, readExcel, toText as excelText, summarize as excelSummary } from './excel.js';
 import { isDocPath, readDoc, toText as docText, summarize as docSummary, looksOldHwp, 옛hwp안내, 문서는못고침 } from './docs.js';
 import { hwpx만들기, 만든말 } from './hwpxwrite.js';
@@ -725,6 +726,12 @@ function 나중에생긴것적기(떠본것, ctx) {
   for (const abs of 떠본것?.없던채뜬것 ?? []) {
     try { if (existsSync(abs) && !statSync(abs).isDirectory()) 떠본것.뜬것.push(ctx.scope.show(abs)); } catch { /* 넘어간다 */ }
   }
+  // 낱말로 못 짚은 것 — git 으로 견줘 안 것 (2.1.3 · safety/gitsnap.js). 이번 턴에 이미 뜬 것은 거기서 거른다.
+  if (떠본것?.깃앞) {
+    const 깃것 = 깃뒤적기(떠본것.깃앞, { history: ctx.history });
+    for (const abs of 깃것.뜬것) 떠본것.뜬것.push(ctx.scope.show(abs));
+    for (const x of 깃것.못뜬것) 떠본것.못뜬것.push(`${ctx.scope.show(x.abs)} (${x.왜})`);
+  }
 }
 
 /** 지금 파일이 몇 줄인가. 붙인 뒤 '얼마나 찼는지' 를 사실로 말해 주려고 센다. */
@@ -3109,6 +3116,12 @@ export const TOOLS = {
        * 그래도 손으로 옮기고 지우는 흔한 자리는 이걸로 덮인다.
        */
       const 떠본것 = 바꾸기전스냅샷(cmd, ctx);
+      /*
+       * git 저장소면 명령 앞 모습도 떠 둔다 (2.1.3 · safety/gitsnap.js). 낱말로는 못 짚는 자리 — 와일드카드 ·
+       * 스크립트 · 포매터가 바꾼 파일 — 를 명령 뒤에 견줘 되돌리기에 올린다. 뒤에서 도는 명령은 언제 끝날지
+       * 몰라 견줄 자리가 없으니 안 뜬다.
+       */
+      if (args.background !== true && ctx.history?.뒤늦은기록) 떠본것.깃앞 = 깃앞보기(ctx.scope.root);
       const 뜬것 = 떠본것.뜬것;
       /*
        * 못 뜬 것과 상한에 걸린 것은 **결과에 실어 보낸다.**
@@ -4118,6 +4131,16 @@ async function 고친뒤진단(name, r, ctx) {
     데우기(뿌리, 볼것[0]);
 
     const 것들 = await Promise.all(볼것.map((abs) => 편집후진단(뿌리, abs)));
+    /*
+     * 언어 서버가 말을 못 줬으면(없거나 · 아직 데우는 중) 문법만이라도 본다 (2.1.3 · verify.js 의 한파일문법).
+     * 서버가 답했으면 안 본다 — 오류 0개도 답이다. 두 번 보면 같은 탈을 두 줄로 적는다.
+     */
+    if (것들.some((d) => d === null)) {
+      const env = 셸환경(process.env, { 남길것: ctx.셸남길것 ?? [] }).env;
+      await Promise.all(볼것.map(async (abs, i) => {
+        if (것들[i] === null) 것들[i] = await 한파일문법(abs, { 뿌리, env });
+      }));
+    }
     let 답 = r;
     for (let i = 0; i < 볼것.length; i++) {
       답 = 진단붙이기(답, 것들[i], ctx.scope.show(볼것[i]));

package/src/tools/outline.js

@@ -35,6 +35,7 @@ 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 './importgraph.js';
 import { 말, 세말 } from '../i18n/index.js';
 
 /* 결과 한 줄을 잇는다 — 빈 조각은 버린다(tools/index.js 의 이어 와 같은 것). */
@@ -289,10 +290,26 @@ export const OUTLINE_TOOL = {
 
     if (!파일들.length) return { content: '볼 파일이 없습니다.', summary: 세말('count', 0) };
 
-    // 최근에 손댄 것부터. 지금 하는 일과 가까울 가능성이 높다.
+    const 파일상한 = 찾을개수(ctx.모델컨텍스트);
+    /*
+     * ── 싣는 차례 (2.1.3) ────────────────────────────────────────────────
+     *
+     * 여태는 최근에 손댄 것부터였다. 그러면 오래 안 건드린 **핵심 모듈** — 파일 수십 개가 불러 쓰는 것 —
+     * 이 큰 저장소에서 제일 먼저 잘렸다(tools/importgraph.js 머리말). 이제 둘을 섞는다.
+     *
+     *   1. 지금 손대는 파일 — 30분 안에 바뀐 것, 몇 자리만. 지금 하는 일과 제일 가깝다.
+     *      다만 폴더의 절반 넘게가 30분 안이면 막 받아 온(clone) 저장소라 시각이 뜻이 없다 — 이 자리를 안 둔다.
+     *   2. 나머지는 많이 불리는 것부터, 같으면 최근 것부터.
+     */
+    const 셈 = 하나인가 ? new Map() : 들여옴세기(ctx.scope.root, 파일들.map((f) => f.path));
+    const 불림 = (f) => 셈.get(f.path) ?? 0;
     파일들.sort((a, b) => (b.mtime ?? 0) - (a.mtime ?? 0));
+    const 제일늦은 = 파일들[0]?.mtime ?? 0;
+    const 지금것 = 파일들.filter((f) => (f.mtime ?? 0) >= 제일늦은 - 30 * 60 * 1000);
+    const 앞자리 = 지금것.length * 2 > 파일들.length ? [] : 지금것.slice(0, Math.max(2, Math.floor(파일상한 / 8)));
+    const 앞 = new Set(앞자리);
+    파일들 = [...앞자리, ...파일들.filter((f) => !앞.has(f)).sort((a, b) => 불림(b) - 불림(a) || (b.mtime ?? 0) - (a.mtime ?? 0))];
 
-    const 파일상한 = 찾을개수(ctx.모델컨텍스트);
     const 줄상한 = 뼈대줄수(ctx.모델컨텍스트);
     const 볼것 = 파일들.slice(0, 파일상한);
 
@@ -328,7 +345,8 @@ export const OUTLINE_TOOL = {
       }
 
       뼈대있는파일++;
-      줄들.push(`${보인이름}  (${줄수}줄)`);
+      // 몇 곳에서 불러 쓰나 — 모델이 「여기가 중심이구나」 를 이름만 보고 안다 (2.1.3).
+      줄들.push(`${보인이름}  (${줄수}줄${불림(f) ? ` · ${불림(f)}곳에서 불러 씀` : ''})`);
       쓴줄++;
       // 파일 하나가 목록을 통째로 먹지 않게 한다. 500개짜리 파일 하나가
       // 나머지 마흔 개를 밀어내면 '구조를 본다' 는 뜻이 없어진다.