deel-local-cli 1.20.12 → 2.0.0

package/src/backend/quota.js

@@ -42,24 +42,79 @@ const 요청남음 = [
  *
  * 남음과 한도를 **짝으로** 묶어 두고, 남은 것이 가장 적은 짝을 쓴다.
  * 짝으로 안 묶으면 화면이 「출력 0 / 입력 한도 100만」 같은 소리를 한다.
+ *
+ * 셋째 칸은 **그 통이 다시 차는 시계**다. 통마다 시계가 따로라, 바닥난 통의
+ * 시계를 써야 한다 (아래 할당량읽기).
  */
 const 토큰통 = [
-  ['x-ratelimit-remaining-tokens', 'x-ratelimit-limit-tokens'],
-  ['ratelimit-remaining-tokens', 'ratelimit-limit-tokens'],
-  ['anthropic-ratelimit-tokens-remaining', 'anthropic-ratelimit-tokens-limit'],
-  ['anthropic-ratelimit-input-tokens-remaining', 'anthropic-ratelimit-input-tokens-limit'],
-  ['anthropic-ratelimit-output-tokens-remaining', 'anthropic-ratelimit-output-tokens-limit'],
+  ['x-ratelimit-remaining-tokens', 'x-ratelimit-limit-tokens', 'x-ratelimit-reset-tokens'],
+  ['ratelimit-remaining-tokens', 'ratelimit-limit-tokens', 'ratelimit-reset'],
+  ['anthropic-ratelimit-tokens-remaining', 'anthropic-ratelimit-tokens-limit', 'anthropic-ratelimit-tokens-reset'],
+  ['anthropic-ratelimit-input-tokens-remaining', 'anthropic-ratelimit-input-tokens-limit', 'anthropic-ratelimit-input-tokens-reset'],
+  ['anthropic-ratelimit-output-tokens-remaining', 'anthropic-ratelimit-output-tokens-limit', 'anthropic-ratelimit-output-tokens-reset'],
 ];
-const 요청한도 = ['x-ratelimit-limit-requests', 'ratelimit-limit-requests', 'anthropic-ratelimit-requests-limit'];
+/*
+ * 접미사 없는 `x-ratelimit-limit`·`x-ratelimit-reset` 도 같이 읽는다.
+ *
+ * `요청남음` 에는 접미사 없는 `x-ratelimit-remaining` 이 진작 있는데 그 **짝**인 한도와
+ * 시계만 어느 목록에도 없었다. 그 이름으로 주는 게이트웨이(Groq·Together 계열)에서는
+ * 남은 수만 뜨고 한도도 시계도 영영 null 이었다 — 한도를 모르면 10% 검사가 안 돌아
+ * 남은 수 바닥값으로만 떨어지고, 시계를 모르면 화면에 「몇 초 뒤 풀림」 이 안 뜬다.
+ * 아래 하나풀림 의 주석 예시(`x-ratelimit-reset: 1773538800`)가 바로 그 이름이다.
+ */
+const 요청한도 = ['x-ratelimit-limit-requests', 'ratelimit-limit-requests', 'x-ratelimit-limit', 'anthropic-ratelimit-requests-limit'];
+const 요청차는때 = ['x-ratelimit-reset-requests', 'anthropic-ratelimit-requests-reset', 'x-ratelimit-reset', 'ratelimit-reset'];
 /*
  * 풀리는 때. Anthropic 은 초가 아니라 **날짜(RFC 3339)** 로 준다 —
  * `언제풀리나` 가 Date.parse 로 받아 지금과의 차이를 초로 바꾼다.
+ *
+ * ── 「다시 오라」 와 「통이 다시 찬다」 는 다른 말이다 ────────────────────
+ *
+ * 여태 이 둘을 한 목록에 담아 두고 앞에서부터 있는 것 하나를 집었다. 그런데
+ * `Retry-After` 는 **서버가 우리한테 시킨 것**이고, `x-ratelimit-reset-*` 는
+ * 그냥 **통이 언제 다시 차는지 적어 둔 시계**다. 뒤엣것은 막을 때만 오는 것이
+ * 아니라 **잘 된 응답마다** 실려 온다.
+ *
+ * 섞어 두었더니 이런 일이 났다. 429 를 맞았는데 `Retry-After` 는 없고
+ * `x-ratelimit-reset-tokens: 6m0s` 만 있는 자리에서, 미리기다릴까() 가 그 6분을
+ * 서버가 시킨 것으로 읽고 1분(미리기다림상한)을 붙들었다. 화면은 그 1분을
+ * 서버 탓으로 적었는데 서버는 그런 말을 한 적이 없다. 아무 말도 못 들은
+ * 자리의 답은 막힘띄움(5초)인데, reset 머리가 하나라도 있으면 그 갈래에는
+ * 영영 못 들어갔다.
+ *
+ * 그래서 따로 읽는다. **시킨 것만 시킨 것으로 친다.** 시계는 시계로 두고,
+ * 「남은 것이 0」 이라고 서버가 스스로 적어 보냈을 때만 그 시계를 쓴다.
  */
-const 다시언제 = [
-  'retry-after', 'x-ratelimit-reset-requests', 'x-ratelimit-reset-tokens', 'ratelimit-reset',
+const 서버가부른때 = ['retry-after'];
+/*
+ * 통이 **바닥나기 전**에 화면에 적을 시계다. 바닥난 뒤에는 가장빠듯한통 이 그 통의
+ * 시계를 따로 챙기지만(바닥시계), 바닥나기 전 — 경고가 뜨는 바로 그 자리 — 에는 이
+ * 목록에 있는 이름만 읽힌다. 여기에 Anthropic 입력·출력 통의 리셋 이름이 빠져 있어서,
+ * 「토큰 200/100,000」 이라고 적으면서 언제 차는지는 못 적었다. 미리 알려 주자고 만든
+ * 파일인데 미리 볼 때만 시계가 없었던 셈이다 (위 토큰통 의 셋째 칸과 같은 이름들이다).
+ */
+const 통차는때 = [
+  'x-ratelimit-reset-requests', 'x-ratelimit-reset-tokens', 'x-ratelimit-reset', 'ratelimit-reset',
   'anthropic-ratelimit-requests-reset', 'anthropic-ratelimit-tokens-reset',
+  'anthropic-ratelimit-input-tokens-reset', 'anthropic-ratelimit-output-tokens-reset',
 ];
 
+/*
+ * 이름 여럿 중 **늦게 차는 쪽**. 바닥난 통이 없을 때 화면에 적을 시계다.
+ *
+ * `골라` 는 목록에서 처음 있는 것 하나를 집는다. 그런데 진짜 Anthropic 응답은 요청·입력
+ * 토큰·출력 토큰 시계를 **한꺼번에** 실어 보낸다. 그러면 목록 차례상 늘 요청 시계가 집혀,
+ * 화면이 「토큰 200/100,000 · 1초 뒤 풀림」 처럼 **적힌 통과 딴 통의 시계**를 나란히 적었다.
+ * 뒤에 이름을 보태도 앞엣것에 가려 한 번도 안 걸린다.
+ *
+ * 규칙은 바닥시계 와 같게 둔다 — **다 차야 보낼 수 있다.** 이른 쪽을 적으면 「풀렸다」 고
+ * 해 놓고 또 막힌다.
+ */
+function 늦은시계(머리, 이름들) {
+  const 아는것 = 이름들.map((k) => 언제풀리나(골라(머리, [k]))).filter((x) => x !== null);
+  return 아는것.length ? Math.max(...아는것) : null;
+}
+
 function 골라(머리, 이름들) {
   if (!머리) return null;
   const 보기 = (k) => (typeof 머리.get === 'function' ? 머리.get(k) : 머리[k] ?? 머리[k.toLowerCase()]);
@@ -78,8 +133,17 @@ function 골라(머리, 이름들) {
  */
 function 숫자(v) {
   if (v === null) return null;
-  const n = Number(String(v).replace(/[,_\s]/g, ''));
-  return Number.isFinite(n) ? n : null;
+  /*
+   * 같은 머리가 두 번 오면 Headers 가 「5, 5」 로 이어 붙인다(노드 http 의 머리 객체도 같다).
+   * 게이트웨이와 윗단이 같은 머리를 둘 다 실으면 생긴다. 쉼표만 지우고 읽었더니 **55** 가 돼서,
+   * 남은 5 가 넉넉한 55 로 읽혀 경고가 안 떴다 (6회차 Gemini 할당6 QA1).
+   *
+   * 이어 붙인 자리에는 쉼표 **뒤에 빈칸**이 온다. 천 단위 쉼표(`12,500`)에는 빈칸이 없다.
+   * 그래서 「쉼표+빈칸」 으로만 가르고, 가른 것 중 **제일 적은 값**을 쓴다 — 두 층이 서로
+   * 다른 수를 말하면 먼저 막히는 쪽이 곧 막히는 쪽이다.
+   */
+  const 낱 = String(v).split(/,\s+/).map((x) => x.replace(/[,_\s]/g, '')).filter(Boolean).map(Number).filter(Number.isFinite);
+  return 낱.length ? Math.min(...낱) : null;
 }
 
 /*
@@ -89,40 +153,112 @@ function 숫자(v) {
 export function 언제풀리나(v) {
   if (v === null || v === undefined) return null;
   const s = String(v).trim();
+  // 빈 머리말은 못 읽은 것이다 — Number('') 가 0 이라 「지금 바로 풀림」 이 됐다 (2.0.0 6회차 · Gemini 백엔드5역).
+  if (!s) return null;
+  /*
+   * 같은 머리가 두 번 와 이어 붙은 것(`5, 5` · `20ms, 6m0s`). 통째로 읽으면 `Date.parse('5, 5')` 가
+   * **2001년 날짜**를 내서 「이미 지남 = 0초」 가 됐고, 시계 둘은 아예 못 읽었다 (6회차 Gemini 할당6 QA1).
+   * 하나씩 읽어 **늦은 쪽**을 쓴다 — 둘 다 풀려야 보낼 수 있다.
+   */
+  /*
+   * HTTP 날짜의 요일 뒤 쉼표(`Wed, 21 Oct 2015 …`)도 여기서 갈리는데 그래도 된다 — 요일 조각은 못 읽어
+   * 빠지고, 나머지 `21 Oct 2015 07:28:00 GMT` 는 그대로 날짜로 읽힌다(quota.test 6-할당6 이 잰다).
+   */
+  const 조각 = s.split(/,\s+/);
+  if (조각.length > 1) {
+    const 읽은것 = 조각.map(하나풀림).filter((x) => x !== null);
+    return 읽은것.length ? Math.max(...읽은것) : null;
+  }
+  return 하나풀림(s);
+}
+
+function 하나풀림(s) {
   const n = Number(s);
-  if (Number.isFinite(n)) return Math.max(0, Math.round(n));
+  if (Number.isFinite(n)) {
+    /*
+     * 풀리는 **시각**을 에포크로 주는 게이트웨이가 있다(`x-ratelimit-reset: 1773538800`). 그 수를
+     * 기다릴 초로 읽으면 56년 뒤에 풀린다고 적는다. 10억 초(2001년)를 넘는 수는 기다릴 초일 수가
+     * 없으니 시각으로 보고 지금과의 차이를 낸다. 1조를 넘으면 밀리초 시각이다.
+     */
+    if (n >= 1e12) return Math.max(0, Math.round((n - Date.now()) / 1000));
+    if (n >= 1e9) return Math.max(0, Math.round(n - Date.now() / 1000));
+    return Math.max(0, Math.round(n));
+  }
   const t = Date.parse(s);
   if (Number.isFinite(t)) return Math.max(0, Math.round((t - Date.now()) / 1000));
-  // `1m30s` 같은 꼴을 주는 게이트웨이가 있다.
-  const m = /^(?:(\d+)m)?(?:(\d+(?:\.\d+)?)s)?$/.exec(s);
-  if (m && (m[1] || m[2])) return Math.round((Number(m[1] ?? 0) * 60) + Number(m[2] ?? 0));
+  /*
+   * `1m30s` 같은 꼴을 주는 게이트웨이가 있다. OpenAI 는 여기에 **시(h)와 밀리초(ms)** 도
+   * 섞어 준다 — `x-ratelimit-reset-requests: 20ms`, `x-ratelimit-reset-tokens: 1h2m`.
+   * 여기가 m·s 만 읽어서 둘 다 null 이었고, 그러면 「남은 것 0」 이라고 적힌 응답에서도
+   * 언제 풀리는지를 몰라 미리 비키지 못하고 429 를 한 번 맞았다 (사냥5 B5-11).
+   *
+   * 차례는 h · m · s · ms 로 고정한다. `m` 은 뒤에 `s` 가 붙지 않을 때만 분이다 —
+   * 안 그러면 `20ms` 가 「20분 + 모르는 s」 로 읽힌다. 1초가 안 되는 것은 반올림한다
+   * (숫자로 준 `0.4` 와 같은 규칙).
+   */
+  const m = /^(?:(\d+(?:\.\d+)?)h)?(?:(\d+(?:\.\d+)?)m(?!s))?(?:(\d+(?:\.\d+)?)s)?(?:(\d+(?:\.\d+)?)ms)?$/.exec(s);
+  if (m && (m[1] || m[2] || m[3] || m[4])) {
+    return Math.round(Number(m[1] ?? 0) * 3600 + Number(m[2] ?? 0) * 60 + Number(m[3] ?? 0) + Number(m[4] ?? 0) / 1000);
+  }
   return null;
 }
 
-/** 토큰 통 중 **가장 적게 남은** 짝. 없으면 둘 다 null. */
+/*
+ * 토큰 통 중 **가장 빠듯한** 짝, 그리고 바닥난 통마다 제 시계.
+ *
+ * 수만 견주면 입력 5,000/200,000(2.5%) 과 출력 2,000/4,000(50%) 에서 출력 통을 골라
+ * 「절반 남음」 이라 하고 경고도 안 띄웠다. 곧 막히는 쪽은 입력 통이다 (6회차 Gemini
+ * 할당6 QA3). 둘 다 한도를 알면 **비율**로, 하나라도 모르면 수로 견준다.
+ */
 function 가장빠듯한통(머리) {
   let 고른것 = { 토큰: null, 토큰한도: null };
-  for (const [남음이름, 한도이름] of 토큰통) {
+  const 바닥시계 = [];
+  for (const [남음이름, 한도이름, 시계이름] of 토큰통) {
     const 남 = 숫자(골라(머리, [남음이름]));
     if (남 === null) continue;
-    if (고른것.토큰 === null || 남 < 고른것.토큰) {
-      고른것 = { 토큰: 남, 토큰한도: 숫자(골라(머리, [한도이름])) };
-    }
+    const 한도 = 숫자(골라(머리, [한도이름]));
+    if (남 <= 0) 바닥시계.push(언제풀리나(골라(머리, [시계이름])));
+    const 더빠듯 = 한도 > 0 && 고른것.토큰한도 > 0 ? 남 / 한도 < 고른것.토큰 / 고른것.토큰한도 : 남 < 고른것.토큰;
+    if (고른것.토큰 === null || 더빠듯) 고른것 = { 토큰: 남, 토큰한도: 한도 };
   }
-  return 고른것;
+  return { 고른것, 바닥시계 };
 }
 
 /**
  * 응답 머리에서 할당량을 읽는다.
  *
- * @returns {{요청:number|null, 요청한도:number|null, 토큰:number|null, 토큰한도:number|null, 풀림:number|null, 있나:boolean}}
+ * `서버말` 은 **서버가 「이때 다시 오라」 고 시킨 것**(Retry-After)이고,
+ * `풀림` 은 그 말이 없으면 통이 다시 차는 시계까지 넓혀 본 값이다. 화면은
+ * 넓은 쪽을 쓰고(할당량말), 기다릴지 말지는 시킨 쪽만 보고 정한다.
+ *
+ * @returns {{요청:number|null, 요청한도:number|null, 토큰:number|null, 토큰한도:number|null, 서버말:number|null, 풀림:number|null, 있나:boolean}}
  */
 export function 할당량읽기(머리) {
+  const 서버말 = 언제풀리나(골라(머리, 서버가부른때));
+  const 요청 = 숫자(골라(머리, 요청남음));
+  const { 고른것, 바닥시계 } = 가장빠듯한통(머리);
+  if (요청 !== null && 요청 <= 0) 바닥시계.push(언제풀리나(골라(머리, 요청차는때)));
+  /*
+   * ── 바닥난 통의 시계를 쓴다 ────────────────────────────────────────────
+   *
+   * 사람이 본 것: 요청은 4,999 남고 토큰이 0 인데 보내자마자 429 였다. 기다리지도 않았다.
+   *
+   * 실제로 있었던 일: 시계를 목록 차례로 하나 집었고, 맨 앞이 요청 시계(`20ms`)였다.
+   * 토큰 통은 6분 뒤에야 차는데 「곧 풀림(0초)」 으로 읽고 곧장 보냈다. Anthropic 출력 통이
+   * 바닥났을 때도 요청 시계를 집었다 — 출력 시계 이름은 목록에 아예 없었다
+   * (6회차 Gemini 할당6 QA4).
+   *
+   * 이제 지키는 규칙: 바닥난 통이 있으면 **그 통들의 시계 중 늦은 쪽**(다 차야 보낼 수 있다).
+   * 바닥난 통이 제 시계를 안 실어 보냈거나 바닥난 통이 없으면, 전처럼 있는 시계 하나를 쓴다
+   * — 화면에 적을 값이다.
+   */
+  const 아는시계 = 바닥시계.filter((x) => x !== null);
   const 것 = {
-    요청: 숫자(골라(머리, 요청남음)),
+    요청,
     요청한도: 숫자(골라(머리, 요청한도)),
-    ...가장빠듯한통(머리),
-    풀림: 언제풀리나(골라(머리, 다시언제)),
+    ...고른것,
+    서버말,
+    풀림: 서버말 ?? (아는시계.length ? Math.max(...아는시계) : 늦은시계(머리, 통차는때)),
   };
   것.있나 = 것.요청 !== null || 것.토큰 !== null || 것.풀림 !== null;
   return 것;
@@ -140,7 +276,27 @@ export const 토큰바닥 = 20000;
 
 export function 아슬아슬한가(것) {
   if (!것?.있나) return false;
-  if (것.풀림 !== null && 것.풀림 > 0) return true;
+  /*
+   * ── 이 한 줄이 경고를 **늘 켜 놓고** 있었다 ────────────────────────────
+   *
+   * 사람이 본 것: OpenAI 를 쓰는 내내 상태줄에 「⚠ 서버 할당량 …」 이 떠
+   * 있었다. 요청이 5,000 중 4,999 남았을 때도 떴다. 늘 떠 있으니 아무도 안
+   * 읽었고, 정작 진짜로 바닥난 날에도 안 읽혔다 — 바로 위 머리말이 하지
+   * 말자고 적어 둔 그것이다.
+   *
+   * 실제로 있었던 일: 여기서 보던 `풀림` 은 「막혔다」 는 표시가 아니라
+   * **통이 다시 차는 시계**였고(위 통차는때), OpenAI 는 그 머리를 **성공한
+   * 응답마다** 실어 보낸다. 그래서 조건이 매 턴 참이 됐다.
+   *
+   * 왜 아무도 못 봤나: 아래 10% 검사와 바닥값 검사가 **한 번도 안 돌았다.**
+   * 여기서 이미 true 로 나가 버리니, 그 두 검사가 틀렸어도 알 길이 없었다.
+   * 조용한 채로 죽어 있던 코드다.
+   *
+   * 이제 지키는 규칙: **서버가 우리를 밀어냈을 때만**(Retry-After) 그 한 줄로
+   * 띄운다. 시계는 「얼마나 남았나」 를 말해 주지 않는다 — 남은 양은 아래
+   * 두 검사가 센다.
+   */
+  if (것.서버말 !== null && 것.서버말 > 0) return true;
   if (것.요청 !== null) {
     if (것.요청한도) { if (것.요청 / 것.요청한도 <= 0.1) return true; }
     else if (것.요청 <= 요청바닥) return true;
@@ -324,11 +480,51 @@ export function 미리기다릴까(것, 지금 = Date.now()) {
   if (!(것.때 > 0) || 지금 - 것.때 > 낡은값) return null;
 
   const 바닥난것 = (것.요청 !== null && 것.요청 <= 0) || (것.토큰 !== null && 것.토큰 <= 0);
-  // 서버가 언제 오라고 말해 줬으면 그 말이 먼저다. 바닥났다고 했거나 방금 막혔거나.
-  if ((바닥난것 || 것.막힘) && 것.풀림 > 0) {
-    // 그 응답을 받은 뒤로 흐른 만큼은 빼 준다.
-    const 남은초 = 것.풀림 - Math.floor((지금 - 것.때) / 1000);
-    if (남은초 > 0) return Math.min(남은초 * 1000, 미리기다림상한);
+  /*
+   * ── 서버가 시킨 것과 우리가 읽은 시계를 갈라 본다 ──────────────────────
+   *
+   * 사람이 본 것: 429 한 번에 화면이 「서버가 60초 뒤에 오라고 했습니다」 하고
+   * 1분을 붙들었다. 그런데 그 응답에 `Retry-After` 는 없었다. 서버가 말한 적
+   * 없는 1분을 서버 이름으로 적은 것이다.
+   *
+   * 실제로 있었던 일: `풀림` 이 `x-ratelimit-reset-tokens: 6m0s` 에서 온
+   * 값이었다. 6분을 상한에서 잘라 1분이 됐다. 「아무 말도 못 들었을 때는 5초만
+   * 띄운다」 는 아래 갈래는, reset 머리를 주는 서버에서는 **닿을 수가 없었다.**
+   *
+   * 이제 지키는 규칙:
+   *   · **시킨 것**(서버말 = Retry-After) 은 언제나 이긴다. 바닥났다고 했든
+   *     방금 막혔든 그 말을 지킨다.
+   *   · **시계**(풀림) 는 서버가 「남은 것이 0」 이라고 스스로 적어 보냈을
+   *     때만 쓴다. 그때는 짐작이 아니다 — 그 0 이 언제 0 이 아니게 되는지를
+   *     같은 응답이 적어 준 것이다.
+   *   · 429 만 맞고 남은 수도 Retry-After 도 못 받은 자리는 시계를 안 본다.
+   *     거기서 우리가 아는 것은 「방금 막혔다」 하나뿐이고, 그 답은 아래
+   *     막힘띄움이다.
+   */
+  /*
+   * 시킨 것은 **0 초라도, 이미 지났어도** 시킨 것이다. 여태 `서버말 > 0` 만 시킨 것으로 쳐서
+   * `Retry-After: 0` 과 「1초라더니 1.5초가 지남」 이 둘 다 아래 막힘띄움(5초)으로 떨어졌다 —
+   * 서버가 곧장 오라고 한 자리를 우리가 3.5~5초 붙든 것이다 (6회차 Gemini 할당6 QA5·QB1).
+   */
+  const 시킨때 = Number.isFinite(것.서버말) ? 것.서버말 : null;
+  const 볼것 = 시킨때 ?? (바닥난것 && 것.풀림 > 0 ? 것.풀림 : null);
+  if ((바닥난것 || 것.막힘) && 볼것 !== null) {
+    /*
+     * 그 응답을 받은 뒤로 흐른 만큼은 빼 준다 — **밀리초로.** 초로 버려 빼면 1초 시계를
+     * 900ms 뒤에 물어도 1초를 통째로 더 기다렸다 (QB3).
+     */
+    const 남은 = 볼것 * 1000 - (지금 - 것.때);
+    if (남은 > 0) return Math.min(남은, 미리기다림상한);
+    /*
+     * 그 때가 **이미 지났으면 기다릴 것이 없다** — 시킨 것이든 서버가 적어 준 시계든.
+     *
+     * 여기가 `시킨때 !== null` 일 때만 끝냈다. 그래서 「남은 것 0 · 1초 뒤 참」 이라고
+     * 적어 보낸 응답을 1.5초 뒤에 물으면, 서버가 이미 「찼다」 고 말해 준 자리에서
+     * 아래 막힘띄움(5초)으로 떨어져 3.5초를 더 붙들었다. 같은 응답인데 Retry-After 가
+     * 있고 없고에 따라 0초와 3.5초로 갈렸다 — 아래 갈래는 **아무 말도 못 들은** 자리의
+     * 답이지, 들은 말이 지난 자리의 답이 아니다.
+     */
+    return null;
   }
 
   /*

package/src/backend/retry.js

@@ -190,14 +190,54 @@ export function 기다리기(ms, signal = null) {
   });
 }
 
+/*
+ * ── 안 부르는 까닭이 둘인데 화면은 한 가지로 말했다 ──────────────────────
+ *
+ * 사람이 본 것: 사내 게이트웨이에서 429 가 잦아 `retry.막힘최대` 를 8 로
+ * 올려 뒀는데, 화면은 여전히 `5번 불렀지만 계속 막혔습니다 (HTTP 429)` 에서
+ * 멎었다. 여덟 번 참으라고 적어 둔 값이 **아무 일도 안 하는 것처럼** 보였다.
+ *
+ * 실제로 있었던 일: 여덟 번을 채우기 전에 **우리 쪽 시간 울타리**(총상한
+ * 5분)가 먼저 닫혔다. `Retry-After` 가 실려 오면 한 번에 최대 60초까지
+ * 기다리니(기다릴시간 의 상한), 대여섯 번이면 5분이 찬다.
+ *
+ * 왜 몰랐나: 이 함수가 **두 경우에 똑같이 null 을 돌려줬다.** 「다시 부를
+ * 것이 아니다·횟수를 다 썼다」 와 「우리 예산을 다 썼다」 는 사람이 할 일이
+ * 아주 다르다 — 앞은 서버를 봐야 하고, 뒤는 우리 설정을 올리면 되는 일이다.
+ * 부르는 쪽은 그 둘을 가를 길이 없어 서버 탓으로만 적었다.
+ *
+ * 이제 지키는 규칙: 돌려주는 모양은 그대로 두고(부르는 데가 여럿이다),
+ * **까닭을 적어 줄 자리**를 인자로 받는다 — detect.js 의 막은것적기 와 같은
+ * 자세다. 안 주면 여태와 한 글자도 다르지 않게 돈다.
+ */
+/** 왜 안 부르나. 화면 문구가 여기서 갈린다. */
+export const 못부른까닭 = { 안될것: '안될것', 예산: '예산' };
+
+/**
+ * 우리 쪽 기다림 예산을 다 썼다는 말. 서버가 한 말과 **섞이면 안 된다** —
+ * 이 줄에는 사람이 올릴 수 있는 설정 이름이 적혀 있어야 한다.
+ */
+export function 못부른말(적힌것) {
+  if (적힌것?.까닭 !== 못부른까닭.예산) return null;
+  const 초 = Math.round((적힌것.총상한 ?? 0) / 1000);
+  return `우리 쪽 기다림 예산 ${초}초를 다 썼습니다 (retry.총상한)`
+    + ' — 서버가 계속 막은 것이 아니라 여기서 그만둔 것입니다. 더 참게 하려면 그 값을 올리세요.';
+}
+
 /**
  * 실패한 응답 하나를 보고 "기다렸다 다시 부른다" 알림을 만든다. 안 부를 것이면 null.
  * 화면·기록이 이 한 덩이를 그대로 쓴다 — 여기 없는 숫자는 화면에도 없다.
+ *
+ * @param {{까닭?:string}} [적을곳]  안 부를 때 **왜**를 채워 준다 (위 머리말)
  */
-export function 다시부를지(r, attempt, 정책 = 기본정책(), 쌓인 = 0) {
+export function 다시부를지(r, attempt, 정책 = 기본정책(), 쌓인 = 0, 적을곳 = null) {
   const status = r?.status ?? 0;
   const code = r?.code ?? null;
-  if (!다시부를까({ status, code, attempt }, 정책)) return null;
+  const 적기 = (것) => { if (적을곳) Object.assign(적을곳, 것); };
+  if (!다시부를까({ status, code, attempt }, 정책)) {
+    적기({ 까닭: 못부른까닭.안될것, status, code, attempt });
+    return null;
+  }
   const retryAfter = r?.headers?.get?.('retry-after') ?? r?.res?.headers?.get?.('retry-after') ?? null;
   const wait = 기다릴시간({ attempt, retryAfter, status }, 정책);
   /*
@@ -208,7 +248,10 @@ export function 다시부를지(r, attempt, 정책 = 기본정책(), 쌓인 = 0)
    * 둘 다 있어야 한다.
    */
   const 총상한 = 정책.총상한 ?? Infinity;
-  if (Number.isFinite(총상한) && 쌓인 + wait > 총상한) return null;
+  if (Number.isFinite(총상한) && 쌓인 + wait > 총상한) {
+    적기({ 까닭: 못부른까닭.예산, status, code, attempt, 총상한, 쌓인, 다음대기: wait });
+    return null;
+  }
   return {
     type: 'backoff',
     status,

package/src/backend/scan.js

@@ -8,6 +8,7 @@
 import { execFileSync } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import { req, headersFor } from './http.js';
+import { 모델목록모양 } from './detect.js';
 import { allowTemporarily } from '../safety/network.js';
 
 // 포트는 겹칠 수 있다(llama.cpp 와 LocalAI 가 둘 다 8080). 그래서 포트로 단정하지 않고
@@ -117,18 +118,43 @@ async function probeOllama(origin, timeout) {
 // 죽은 포트에서는 첫 요청이 바로 실패하므로 훑는 시간에는 거의 영향이 없다.
 const BASES = ['/v1', '', '/api/v1', '/openai/v1', '/api', '/llm/v1', '/proxy/v1'];
 
+/*
+ * 열쇠를 달라는 **OpenAI 식** 거절인가 (사냥5 B5-08).
+ *
+ * 몸에 `error` 칸이 있거나(OpenAI · LiteLLM · vLLM · llama.cpp 가 다 이 모양이다)
+ * `WWW-Authenticate: Bearer` 로 열쇠를 달라고 할 때만 그렇다고 본다. `Basic realm=…` 에
+ * 글자 「Unauthorized」 는 공유기·NAS 관리 화면의 말투다.
+ */
+function 열쇠달라는거절(r) {
+  const h = r.headers;
+  const 머리 = String((typeof h?.get === 'function' ? h.get('www-authenticate') : h?.['www-authenticate']) ?? '');
+  if (/^\s*bearer\b/i.test(머리)) return true;
+  const j = r.json;
+  if (!j || typeof j !== 'object' || Array.isArray(j)) return false;
+  return typeof j.error === 'string' ? j.error.length > 0 : (!!j.error && typeof j.error === 'object');
+}
+
 async function probeOpenAI(origin, timeout, key) {
   for (const base of BASES.map((b) => `${origin}${b}`)) {
     const r = await req(`${base}/models`, { headers: headersFor(key ? 'bearer' : 'none', key), timeout });
-    if (!r.ok || !r.json) {
-      // 규격은 맞는데 키가 없어 막힌 경우 — 서버가 있다는 사실은 알려 준다.
-      if (r.status === 401 || r.status === 403) {
+    if (!r.ok) {
+      /*
+       * 규격은 맞는데 키가 없어 막힌 경우 — 서버가 있다는 사실은 알려 준다.
+       *
+       * 다만 **401 한 줄만으로는 이 규격이라고 못 한다** (사냥5 B5-08). 공유기·NAS 관리
+       * 화면은 모든 길에 401 을 준다. 그걸 「잠김 — deel scan --key <키>」 로 올리면 남의
+       * 프로그램에 우리 열쇠를 보내라고 권하는 셈이다. 그래서 거절 모양이 OpenAI 식일
+       * 때만 센다. 놓치는 쪽으로 틀린다 — 못 찾은 서버는 주소를 직접 적으면 붙지만,
+       * 보낸 열쇠는 못 돌려받는다.
+       */
+      if ((r.status === 401 || r.status === 403) && 열쇠달라는거절(r)) {
         return { kind: 'openai', runtime: null, base, auth: null, models: [], locked: true, ms: r.ms };
       }
       continue;
     }
-    const list = r.json.data ?? r.json.models ?? [];
-    if (!Array.isArray(list)) continue;
+    // 목록 모양이 아니면 이 규격이 아니다 — 설치(detect.js)와 같은 잣대.
+    const list = 모델목록모양(r.json);
+    if (!list) continue;
     return {
       kind: 'openai',
       runtime: null,
@@ -171,7 +197,10 @@ export async function scanLocal({ host = '127.0.0.1', ports = [], timeout = 1200
   // 직접 세운 프록시는 알려진 자리에 없기 때문이다. 이 PC 안에서만 한다 —
   // 남의 컴퓨터 포트를 훑는 것은 이 도구가 할 일이 아니다.
   const 잘린것 = [];
-  if (listening && (host === '127.0.0.1' || host === 'localhost' || host === '::1')) {
+  // IPv6 주소는 괄호를 씌워야 주소가 된다. 안 씌우면 `http://::1:11434` 가 Invalid URL 로
+  // **훑기 전체를** 던졌다 — `deel scan --host ::1` 한 줄로 (2.0.0 6회차 Gemini 훑기6bf).
+  const 주소host = host.includes(':') && !host.startsWith('[') ? `[${host}]` : host;
+  if (listening && (host === '127.0.0.1' || host === 'localhost' || host === '::1' || host === '[::1]')) {
     const 열린것 = listeningPorts().filter((p) => !list.some((x) => x.port === p));
     const 볼것 = 열린것.slice(0, maxListening);
     if (열린것.length > 볼것.length) 잘린것.push(...열린것.slice(maxListening));
@@ -181,7 +210,7 @@ export async function scanLocal({ host = '127.0.0.1', ports = [], timeout = 1200
   }
 
   const jobs = list.map(async ({ port, hint }) => {
-    const origin = `http://${host}:${port}`;
+    const origin = `http://${주소host}:${port}`;
     // 훑는 동안만 그 자리를 연다. 끝나면 바로 닫아서 자물쇠를 원래대로 둔다.
     const close = allowTemporarily(origin);
     let hit;
@@ -228,8 +257,8 @@ export async function scanLocal({ host = '127.0.0.1', ports = [], timeout = 1200
 export function toProfiles(found, existing = []) {
   const out = [];
   for (const f of found) {
-    for (const m of f.models.length ? f.models : [{ id: null }]) {
-      if (!m.id) continue;
+    for (const m of f.models) {
+      if (!m.id) continue;   // 이름 없는 것은 프로필이 못 된다 (모델 0대인 서버도 여기서 끝)
       const id = `${slugRuntime(f.runtime)}-${String(m.id).replace(/[^a-zA-Z0-9._-]+/g, '-')}`.slice(0, 60).toLowerCase();
       const prev = existing.find((p) => p.baseUrl === f.base && p.model === m.id);
       out.push({
@@ -237,7 +266,15 @@ export function toProfiles(found, existing = []) {
         name: `${f.runtime} · ${m.id}`,
         kind: f.kind,
         baseUrl: f.base,
-        auth: f.auth ?? 'none',
+        /*
+         * 잠금 방식은 **열쇠와 같이 움직인다.**
+         *
+         * 아래에서 `apiKey` 를 되쓰면서 여기만 훑은 값으로 덮고 있었다. 훑기는
+         * 열쇠 없이 두드리므로 열쇠를 받는 서버도 `auth:'none'` 으로 보인다 —
+         * 그래서 열쇠는 그대로 남고 방식만 none 이 되어, 쓰던 프로필이 열쇠를
+         * 안 싣고 나가 조용히 401 로 돌아선다. 되쓰는 자리는 되쓴다.
+         */
+        auth: prev?.auth ?? f.auth ?? 'none',
         model: m.id,
         apiKey: prev?.apiKey ?? '',
         ctx: prev?.ctx ?? null,

package/src/backend/scanui.js

@@ -9,10 +9,26 @@ import { load, save, upsert } from '../config.js';
 // 코딩 에이전트로 쓰려면 도구 호출이 되어야 한다. 진단 전이라 확실히는 모르니,
 // 이름에 드러난 단서로 짐작해서 권한다. 틀릴 수 있다는 것을 문구에 밝힌다.
 const 도구잘함 = /(qwen|llama-?3|llama3|mistral|devstral|hermes|command-?r|firefunction|granite|gpt-?oss|glm|kimi|minimax|seed-?oss)/i;
-const 코딩 = /(cod(e|er|ing)|devstral|starcoder|deepseek|qwen.*cod|granite.*cod)/i;
-const 작음 = /(0\.5b|1\.5b|1b|2b|3b|tiny|mini|small)/i;
+// `deepseek` 도 `qwen`·`granite` 와 같이 `.*cod` 를 요구한다. 통째로 넣어 두었더니
+// `deepseek-r1`(추론)·`deepseek-chat`(대화)에 「코딩용 모델」 이 붙고, 그 3점이
+// 진짜 코딩 모델을 밀어내고 추천 자리를 가져갔다.
+const 코딩 = /(cod(e|er|ing)|devstral|starcoder|deepseek.*cod|qwen.*cod|granite.*cod)/i;
+/*
+ * 크기 토막은 **통째로** 맞아야 한다.
+ *
+ * `3b` 를 글 아무 데서나 찾으면 `codellama:13b`(13B) 가 걸리고 `2b` 는
+ * `qwen2.5-coder:32b`(32B) 가 걸린다 — 이 PC 에서 제일 많이 쓰는 코딩 모델이
+ * 「작은 모델」 로 세어져 점수가 깎이고 「도구 호출이 불안할 수 있습니다」 라는
+ * 거짓 경고가 붙었다. 앞에 숫자·점이 없을 때만 크기로 친다.
+ *
+ * `mini` 도 같은 탈이었다. 글 아무 데서나 찾으니 `minimax-m2`(230B) 와
+ * `gemini` 가 걸렸다 — minimax 는 바로 위 `도구잘함` 이 「도구 호출을 잘하는
+ * 계열」 로 올려 둔 것이라, 한 줄 안에서 추어올리고 깎아내렸다. 앞뒤가 글자가
+ * 아닐 때만 크기 낱말로 친다 (`gpt-4o-mini` · `qwen3-mini` 는 그대로 걸린다).
+ */
+const 작음 = /(?<![\d.])(?:0\.5|1\.5|1|2|3)b(?!\d)|tiny|(?<![a-z])mini(?![a-z])|small/i;
 
-function recommend(found) {
+export function recommend(found) {
   const all = [];
   for (const f of found) for (const m of f.models) all.push({ ...f, model: m.id, note: m.note ?? '' });
   if (!all.length) return null;
@@ -26,7 +42,15 @@ function recommend(found) {
     return s;
   };
   const best = all.map((x) => ({ x, s: 점수(x) })).sort((a, b) => b.s - a.s)[0];
-  if (!best || best.s < 2) return null;
+  if (!best) return null;
+  /*
+   * 이름에 단서가 하나도 없으면 **안 권한다.**
+   *
+   * 비작음(+1)과 ollama(+1)만으로 2점이 차서, 임베딩 전용 모델(nomic-embed-text)
+   * 까지 추천으로 올라왔다. 이유 줄에는 「실제로 되는지는 diagnose 로 확인하세요」
+   * 한 마디만 남는다 — 짐작의 근거가 이름인데 그 이름이 아무 말도 안 하는 판이다.
+   */
+  if (best.s < 2 || (!코딩.test(best.x.model) && !도구잘함.test(best.x.model))) return null;
 
   const 이유 = [];
   if (코딩.test(best.x.model)) 이유.push('코딩용 모델');
@@ -36,6 +60,31 @@ function recommend(found) {
   return { ...best.x, why: 이유.join(' · ') };
 }
 
+/**
+ * 고르기 목록의 이 줄이 **권한 그것**인가.
+ *
+ * 표(`추천`)를 붙이는 잣대와 커서 기본값의 잣대가 갈려 있었다 — 표는 포트까지
+ * 보고 기본값은 모델 이름만 봤다. 같은 모델이 두 서버에 떠 있으면 둘째를 권해
+ * 놓고 커서는 첫째에 앉아, 엔터를 치면 권하지 않은 쪽이 등록된다. 잣대를 하나로 둔다.
+ *
+ * 그 잣대가 `baseUrl.includes('80')` 이었다 — 8080·8000·11434 가 전부 80 추천에
+ * 걸린다. 막으려던 사고를 막았다고 적어 놓고 같은 줄에서 되살린 셈이다.
+ * 포트는 글자로 찾지 말고 포트 자리에서 읽는다.
+ */
+const 주소포트 = (u) => {
+  const m = /:(\d+)(?=[/?#]|$)/.exec(String(u ?? ''));
+  return m ? Number(m[1]) : null;
+};
+
+export function 추천인가(p, 추천) {
+  return !!추천 && p?.model === 추천.model && 주소포트(p?.baseUrl) === Number(추천.port);
+}
+
+/** 고르개의 기본 자리. 권한 것이 없으면 첫째. */
+export function 추천자리(profiles, 추천) {
+  return Math.max(0, (profiles ?? []).findIndex((p) => 추천인가(p, 추천)));
+}
+
 export async function runScan(flags = {}) {
   const host = flags.host ? String(flags.host) : '127.0.0.1';
   const ports = String(flags.ports ?? '')
@@ -66,7 +115,8 @@ export async function runScan(flags = {}) {
   // ── 찾은 것 표로 ─────────────────────────────────────────────────────
   const wRun = Math.max(10, ...found.map((f) => width(f.runtime)));
   for (const f of found) {
-    const 자리 = `${f.host}:${f.port}`;
+    // IPv6 는 괄호를 씌운다 — `::1:11434` 는 어디까지가 주소인지 안 보인다.
+    const 자리 = `${String(f.host).includes(':') && !String(f.host).startsWith('[') ? `[${f.host}]` : f.host}:${f.port}`;
     const 규격 = 규격이름(f.kind);
     const 표시 = f.guessed ? c.gray(' (추정)') : '';
     say(`  ${c.hcyan('◆')} ${c.bold(pad(f.runtime, wRun))}${표시}  ${c.gray(pad(자리, 22))}${c.gray(pad(규격, 14))}${c.gray(f.ms + 'ms')}`);
@@ -114,10 +164,10 @@ export async function runScan(flags = {}) {
   if (flags.pick && profiles.length > 1) {
     const items = profiles.map((p) => ({
       label: `${pad(clip(p.name, 44), 46)}${c.gray(p.note ?? '')}`,
-      note: 추천 && p.model === 추천.model && p.baseUrl.includes(String(추천.port)) ? '추천' : '',
+      note: 추천인가(p, 추천) ? '추천' : '',
     }));
     const i = await pick('어느 것을 쓰시겠습니까', items, {
-      def: Math.max(0, profiles.findIndex((p) => 추천 && p.model === 추천.model)),
+      def: 추천자리(profiles, 추천),
     });
     profiles = [profiles[i]];
     cfg.active = null;   // 고른 것을 지금 쓰는 것으로