deel-local-cli 1.10.0 → 1.13.0

package/src/backend/quota.js

@@ -1,157 +1,274 @@
-// 게이트웨이가 남았다고 알려 주는 할당량.
-//
-// ── 왜 필요한가 ────────────────────────────────────────────────────────
-//
-// 사내 게이트웨이는 사람마다 할당량을 건다. 그런데 지금까지 그걸 아는 방법은
-// **429 를 맞는 것뿐**이었다. 일하는 도중에 갑자기 막히고, 화면에는
-// "잠깐 막혔습니다" 가 뜨고, 사람은 언제 풀리는지 모른 채 기다린다.
-//
-// 그런데 서버는 매 응답에 남은 양을 실어 보내고 있었다. 우리가 안 읽었을
-// 뿐이다. 읽어서 보여 주면 사람은 막히기 전에 안다 — 큰 작업을 시작할지,
-// 오늘은 여기까지 할지 스스로 정할 수 있다.
-//
-// ── 이름이 제각각이다 ──────────────────────────────────────────────────
-//
-// 표준이 없다. OpenAI 계열은 `x-ratelimit-remaining-requests`, Azure 는
-// `x-ratelimit-remaining-tokens` 를 쓰기도 하고 아예 안 주기도 한다.
-// 그래서 **아는 이름만 읽고, 없으면 없다고 한다.** 없는 것을 0 으로 치면
-// 화면에 "0 남음" 이 떠서, 멀쩡한데 다 썼다고 믿게 된다.
-//
-// Anthropic 은 `anthropic-` 을 앞에 달고, 남은 것을 **뒤에** 적는다
-// (`anthropic-ratelimit-requests-remaining`). 그 이름을 몰라서, Claude 직통과
-// Bedrock 게이트웨이에서는 이 줄이 **언제나 비어 있었다** — 서버는 매 응답에
-// 남은 양을 실어 보내고 있었는데 우리만 못 읽었다. 그래서 그 두 자리에서는
-// 아직도 429 를 맞아야만 알 수 있었다. 이 파일이 없애려던 바로 그 상황이다.
-
-// 읽을 이름들. 앞에서부터 처음 있는 것 하나를 쓴다.
-const 요청남음 = [
-  'x-ratelimit-remaining-requests', 'ratelimit-remaining-requests', 'x-ratelimit-remaining',
-  'anthropic-ratelimit-requests-remaining',
-];
-const 토큰남음 = [
-  'x-ratelimit-remaining-tokens', 'ratelimit-remaining-tokens',
-  'anthropic-ratelimit-tokens-remaining',
-  // 입력·출력을 따로 세는 판도 있다. 둘 중 먼저 바닥나는 쪽이 곧 막히는 쪽이다.
-  'anthropic-ratelimit-input-tokens-remaining', 'anthropic-ratelimit-output-tokens-remaining',
-];
-const 요청한도 = ['x-ratelimit-limit-requests', 'ratelimit-limit-requests', 'anthropic-ratelimit-requests-limit'];
-const 토큰한도 = [
-  'x-ratelimit-limit-tokens', 'ratelimit-limit-tokens', 'anthropic-ratelimit-tokens-limit',
-  'anthropic-ratelimit-input-tokens-limit', 'anthropic-ratelimit-output-tokens-limit',
-];
-/*
- * 풀리는 때. Anthropic 은 초가 아니라 **날짜(RFC 3339)** 로 준다 —
- * `언제풀리나` 가 Date.parse 로 받아 지금과의 차이를 초로 바꾼다.
- */
-const 다시언제 = [
-  'retry-after', 'x-ratelimit-reset-requests', 'x-ratelimit-reset-tokens', 'ratelimit-reset',
-  'anthropic-ratelimit-requests-reset', 'anthropic-ratelimit-tokens-reset',
-];
-
-function 골라(머리, 이름들) {
-  if (!머리) return null;
-  const 보기 = (k) => (typeof 머리.get === 'function' ? 머리.get(k) : 머리[k] ?? 머리[k.toLowerCase()]);
-  for (const k of 이름들) {
-    const v = 보기(k);
-    if (v !== undefined && v !== null && String(v).trim() !== '') return String(v).trim();
-  }
-  return null;
-}
-
-/*
- * 숫자로 읽는다. 못 읽으면 null — 0 이 아니다.
- *
- * 이 구분이 여기서 제일 중요하다. 못 읽은 것을 0 으로 치면 화면에
- * "남은 요청 0" 이 뜨고, 사람은 멀쩡한 할당량을 다 썼다고 믿는다.
- */
-function 숫자(v) {
-  if (v === null) return null;
-  const n = Number(String(v).replace(/[,_\s]/g, ''));
-  return Number.isFinite(n) ? n : null;
-}
-
-/*
- * `retry-after` 는 초일 수도 날짜일 수도 있다 (RFC 9110).
- * 날짜면 지금과의 차이를 초로 바꾼다. 못 읽으면 null.
- */
-export function 언제풀리나(v) {
-  if (v === null || v === undefined) return null;
-  const s = String(v).trim();
-  const n = Number(s);
-  if (Number.isFinite(n)) 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));
-  return null;
-}
-
-/**
- * 응답 머리에서 할당량을 읽는다.
- *
- * @returns {{요청:number|null, 요청한도:number|null, 토큰:number|null, 토큰한도:number|null, 풀림:number|null, 있나:boolean}}
- */
-export function 할당량읽기(머리) {
-  const 것 = {
-    요청: 숫자(골라(머리, 요청남음)),
-    요청한도: 숫자(골라(머리, 요청한도)),
-    토큰: 숫자(골라(머리, 토큰남음)),
-    토큰한도: 숫자(골라(머리, 토큰한도)),
-    풀림: 언제풀리나(골라(머리, 다시언제)),
-  };
-  것.있나 = 것.요청 !== null || 것.토큰 !== null || 것.풀림 !== null;
-  return 것;
-}
-
-/*
- * 얼마나 남았을 때 화면에 띄울까.
- *
- * 한도를 알면 비율로 본다(10% 아래). 한도를 안 알려주는 서버가 많아서,
- * 그때는 남은 수 자체로 본다 — 요청 20회 아래, 토큰 20,000 아래.
- * 넉넉할 때 자꾸 띄우면 사람이 그 줄을 안 읽게 된다.
- */
-export const 요청바닥 = 20;
-export const 토큰바닥 = 20000;
-
-export function 아슬아슬한가(것) {
-  if (!것?.있나) return false;
-  if (것.풀림 !== null && 것.풀림 > 0) return true;
-  if (것.요청 !== null) {
-    if (것.요청한도) { if (것.요청 / 것.요청한도 <= 0.1) return true; }
-    else if (것.요청 <= 요청바닥) return true;
-  }
-  if (것.토큰 !== null) {
-    if (것.토큰한도) { if (것.토큰 / 것.토큰한도 <= 0.1) return true; }
-    else if (것.토큰 <= 토큰바닥) return true;
-  }
-  return false;
-}
-
-/** 화면 한 줄. 아는 것만 적는다 — 모르는 자리는 아예 안 적는다. */
-export function 할당량말(것) {
-  if (!것?.있나) return '';
-  const 조각 = [];
-  if (것.요청 !== null) 조각.push(`요청 ${것.요청.toLocaleString()}${것.요청한도 ? `/${것.요청한도.toLocaleString()}` : ''}`);
-  if (것.토큰 !== null) 조각.push(`토큰 ${것.토큰.toLocaleString()}${것.토큰한도 ? `/${것.토큰한도.toLocaleString()}` : ''}`);
-  if (것.풀림 !== null) 조각.push(`${것.풀림}초 뒤 풀림`);
-  return 조각.join(' · ');
-}
-
-/*
- * 마지막으로 본 할당량. 응답마다 덮어쓴다.
- *
- * 세션에 안 두고 모듈에 두는 까닭: 이걸 읽는 자리가 여럿인데(상태줄, /cost,
- * 시작 화면) 그 자리들이 세션을 다 들고 있지는 않다. 그리고 값 자체가
- * '지금 서버가 말한 것' 이라 한 벌이면 충분하다.
- */
-let 마지막 = null;
-
-export function 할당량기억(머리) {
-  const 것 = 할당량읽기(머리);
-  if (것.있나) 마지막 = { ...것, 때: Date.now() };
-  return 것;
-}
-
-export function 마지막할당량() { return 마지막; }
-export function 할당량잊기() { 마지막 = null; return null; }
+// 게이트웨이가 남았다고 알려 주는 할당량.
+//
+// ── 왜 필요한가 ────────────────────────────────────────────────────────
+//
+// 사내 게이트웨이는 사람마다 할당량을 건다. 그런데 지금까지 그걸 아는 방법은
+// **429 를 맞는 것뿐**이었다. 일하는 도중에 갑자기 막히고, 화면에는
+// "잠깐 막혔습니다" 가 뜨고, 사람은 언제 풀리는지 모른 채 기다린다.
+//
+// 그런데 서버는 매 응답에 남은 양을 실어 보내고 있었다. 우리가 안 읽었을
+// 뿐이다. 읽어서 보여 주면 사람은 막히기 전에 안다 — 큰 작업을 시작할지,
+// 오늘은 여기까지 할지 스스로 정할 수 있다.
+//
+// ── 이름이 제각각이다 ──────────────────────────────────────────────────
+//
+// 표준이 없다. OpenAI 계열은 `x-ratelimit-remaining-requests`, Azure 는
+// `x-ratelimit-remaining-tokens` 를 쓰기도 하고 아예 안 주기도 한다.
+// 그래서 **아는 이름만 읽고, 없으면 없다고 한다.** 없는 것을 0 으로 치면
+// 화면에 "0 남음" 이 떠서, 멀쩡한데 다 썼다고 믿게 된다.
+//
+// Anthropic 은 `anthropic-` 을 앞에 달고, 남은 것을 **뒤에** 적는다
+// (`anthropic-ratelimit-requests-remaining`). 그 이름을 몰라서, Claude 직통과
+// Bedrock 게이트웨이에서는 이 줄이 **언제나 비어 있었다** — 서버는 매 응답에
+// 남은 양을 실어 보내고 있었는데 우리만 못 읽었다. 그래서 그 두 자리에서는
+// 아직도 429 를 맞아야만 알 수 있었다. 이 파일이 없애려던 바로 그 상황이다.
+
+// 읽을 이름들. 앞에서부터 처음 있는 것 하나를 쓴다.
+const 요청남음 = [
+  'x-ratelimit-remaining-requests', 'ratelimit-remaining-requests', 'x-ratelimit-remaining',
+  'anthropic-ratelimit-requests-remaining',
+];
+/*
+ * 토큰 통은 **여러 개일 수 있다.**
+ *
+ * Anthropic 은 입력과 출력을 따로 센다. 둘은 서로 다른 통이고, 둘 중
+ * **먼저 바닥나는 쪽**이 곧 막히는 쪽이다.
+ *
+ * 여태 이걸 한 줄짜리 이름 목록으로 두고 골라() 로 「처음 있는 것」 을
+ * 집었다. 목록 차례상 입력이 앞이라, 입력 100,000 · 출력 0 인 응답에서
+ * 남은 양을 **100,000 으로 적었다.** 그러면 미리기다릴까() 가 「아직
+ * 넉넉하다」 고 보고 곧장 다음 요청을 보내 429 를 맞는다. 주석에는
+ * 「먼저 바닥나는 쪽」 이라고 적혀 있었는데 코드는 그 반대를 했다.
+ *
+ * 남음과 한도를 **짝으로** 묶어 두고, 남은 것이 가장 적은 짝을 쓴다.
+ * 짝으로 안 묶으면 화면이 「출력 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'],
+];
+const 요청한도 = ['x-ratelimit-limit-requests', 'ratelimit-limit-requests', 'anthropic-ratelimit-requests-limit'];
+/*
+ * 풀리는 때. Anthropic 은 초가 아니라 **날짜(RFC 3339)** 로 준다 —
+ * `언제풀리나` 가 Date.parse 로 받아 지금과의 차이를 초로 바꾼다.
+ */
+const 다시언제 = [
+  'retry-after', 'x-ratelimit-reset-requests', 'x-ratelimit-reset-tokens', 'ratelimit-reset',
+  'anthropic-ratelimit-requests-reset', 'anthropic-ratelimit-tokens-reset',
+];
+
+function 골라(머리, 이름들) {
+  if (!머리) return null;
+  const 보기 = (k) => (typeof 머리.get === 'function' ? 머리.get(k) : 머리[k] ?? 머리[k.toLowerCase()]);
+  for (const k of 이름들) {
+    const v = 보기(k);
+    if (v !== undefined && v !== null && String(v).trim() !== '') return String(v).trim();
+  }
+  return null;
+}
+
+/*
+ * 숫자로 읽는다. 못 읽으면 null — 0 이 아니다.
+ *
+ * 이 구분이 여기서 제일 중요하다. 못 읽은 것을 0 으로 치면 화면에
+ * "남은 요청 0" 이 뜨고, 사람은 멀쩡한 할당량을 다 썼다고 믿는다.
+ */
+function 숫자(v) {
+  if (v === null) return null;
+  const n = Number(String(v).replace(/[,_\s]/g, ''));
+  return Number.isFinite(n) ? n : null;
+}
+
+/*
+ * `retry-after` 는 초일 수도 날짜일 수도 있다 (RFC 9110).
+ * 날짜면 지금과의 차이를 초로 바꾼다. 못 읽으면 null.
+ */
+export function 언제풀리나(v) {
+  if (v === null || v === undefined) return null;
+  const s = String(v).trim();
+  const n = Number(s);
+  if (Number.isFinite(n)) 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));
+  return null;
+}
+
+/** 토큰 통 중 **가장 적게 남은** 짝. 없으면 둘 다 null. */
+function 가장빠듯한통(머리) {
+  let 고른것 = { 토큰: null, 토큰한도: null };
+  for (const [남음이름, 한도이름] of 토큰통) {
+    const 남 = 숫자(골라(머리, [남음이름]));
+    if (남 === null) continue;
+    if (고른것.토큰 === null || 남 < 고른것.토큰) {
+      고른것 = { 토큰: 남, 토큰한도: 숫자(골라(머리, [한도이름])) };
+    }
+  }
+  return 고른것;
+}
+
+/**
+ * 응답 머리에서 할당량을 읽는다.
+ *
+ * @returns {{요청:number|null, 요청한도:number|null, 토큰:number|null, 토큰한도:number|null, 풀림:number|null, 있나:boolean}}
+ */
+export function 할당량읽기(머리) {
+  const 것 = {
+    요청: 숫자(골라(머리, 요청남음)),
+    요청한도: 숫자(골라(머리, 요청한도)),
+    ...가장빠듯한통(머리),
+    풀림: 언제풀리나(골라(머리, 다시언제)),
+  };
+  것.있나 = 것.요청 !== null || 것.토큰 !== null || 것.풀림 !== null;
+  return 것;
+}
+
+/*
+ * 얼마나 남았을 때 화면에 띄울까.
+ *
+ * 한도를 알면 비율로 본다(10% 아래). 한도를 안 알려주는 서버가 많아서,
+ * 그때는 남은 수 자체로 본다 — 요청 20회 아래, 토큰 20,000 아래.
+ * 넉넉할 때 자꾸 띄우면 사람이 그 줄을 안 읽게 된다.
+ */
+export const 요청바닥 = 20;
+export const 토큰바닥 = 20000;
+
+export function 아슬아슬한가(것) {
+  if (!것?.있나) return false;
+  if (것.풀림 !== null && 것.풀림 > 0) return true;
+  if (것.요청 !== null) {
+    if (것.요청한도) { if (것.요청 / 것.요청한도 <= 0.1) return true; }
+    else if (것.요청 <= 요청바닥) return true;
+  }
+  if (것.토큰 !== null) {
+    if (것.토큰한도) { if (것.토큰 / 것.토큰한도 <= 0.1) return true; }
+    else if (것.토큰 <= 토큰바닥) return true;
+  }
+  return false;
+}
+
+/** 화면 한 줄. 아는 것만 적는다 — 모르는 자리는 아예 안 적는다. */
+export function 할당량말(것) {
+  if (!것?.있나) return '';
+  const 조각 = [];
+  if (것.요청 !== null) 조각.push(`요청 ${것.요청.toLocaleString()}${것.요청한도 ? `/${것.요청한도.toLocaleString()}` : ''}`);
+  if (것.토큰 !== null) 조각.push(`토큰 ${것.토큰.toLocaleString()}${것.토큰한도 ? `/${것.토큰한도.toLocaleString()}` : ''}`);
+  if (것.풀림 !== null) 조각.push(`${것.풀림}초 뒤 풀림`);
+  return 조각.join(' · ');
+}
+
+/*
+ * 마지막으로 본 할당량. 응답마다 덮어쓴다.
+ *
+ * 세션에 안 두고 모듈에 두는 까닭: 이걸 읽는 자리가 여럿인데(상태줄, /cost,
+ * 시작 화면) 그 자리들이 세션을 다 들고 있지는 않다. 그리고 값 자체가
+ * '지금 서버가 말한 것' 이라 한 벌이면 충분하다.
+ */
+let 마지막 = null;
+
+/*
+ * ── 창구마다 따로 센다 ──────────────────────────────────────────────────
+ *
+ * 값이 한 벌이면 **누구 것인지**가 없다. 그런데 이 프로그램은 한 번에 여러
+ * 창구를 부른다 — 본 모델, 하위 작업이 고른 모델(agent/loop.js), `/model` 로
+ * 물어보는 자리, 요약을 짓는 자리. 사내 게이트웨이가 「남은 것 0, 55초 뒤」
+ * 라고 답하면, 그 다음에 **전혀 다른 주소**로 나가는 요청까지 55초를 기다렸다.
+ * 옆에 켜 둔 로컬 모델이 남의 할당량 때문에 멎는 것이다.
+ *
+ * 그래서 창구별로 담아 두고, 보내기 전에 비킬 때는 **그 창구 것만** 본다.
+ * 화면(상태줄·/cost)은 여전히 마지막 것을 쓴다 — 사람이 보는 것은 지금 쓰는
+ * 창구 하나라, 그 자리에는 한 벌로 충분하다.
+ */
+const 자리들 = new Map();
+const 자리최대 = 24;
+
+/** 이 연결을 가리키는 이름. 주소의 호스트와 모델까지만 쓴다 — 열쇠는 안 넣는다. */
+export function 할당량자리(conn) {
+  if (!conn) return '';
+  let host = '';
+  try { host = new URL(String(conn.base ?? '')).host; } catch { host = ''; }
+  /*
+   * 규격까지 넣는다. 전선 카드 열쇠와 같은 까닭이다(agent/evolve.js) —
+   * mantle 은 `/openai/v1` 과 `/anthropic/v1` 이 **같은 호스트에 같은 모델
+   * 이름**으로 서 있어서, 규격을 빼면 한쪽이 바닥났다고 다른 쪽까지 기다린다.
+   */
+  const 꼴 = String(conn.kind ?? '').trim();
+  return `${host}|${String(conn.model ?? '').trim()}${꼴 ? `#${꼴}` : ''}`;
+}
+
+export function 할당량기억(머리, 어디 = '') {
+  const 것 = 할당량읽기(머리);
+  if (것.있나) {
+    const 적을것 = { ...것, 때: Date.now() };
+    마지막 = 적을것;
+    if (어디) {
+      자리들.delete(어디);
+      자리들.set(어디, 적을것);
+      // 오래 안 쓴 자리부터 버린다. 창구를 옮겨 다녀도 표가 안 자란다.
+      while (자리들.size > 자리최대) 자리들.delete(자리들.keys().next().value);
+    }
+  }
+  return 것;
+}
+
+/** 마지막으로 본 할당량. 자리를 주면 **그 창구 것**, 안 주면 가장 최근 것. */
+export function 마지막할당량(어디 = '') {
+  if (어디) return 자리들.get(어디) ?? null;
+  return 마지막;
+}
+
+export function 할당량잊기(어디 = '') {
+  if (어디) { 자리들.delete(어디); return null; }
+  마지막 = null;
+  자리들.clear();
+  return null;
+}
+
+/*
+ * ── 맞기 전에 비킨다 ────────────────────────────────────────────────────
+ *
+ * 서버는 매 응답에 「남은 것이 없다, 언제 풀린다」 를 실어 보낸다. 그런데
+ * 여태 그 값은 **화면에만** 썼다. 그래서 남은 것이 0 인 줄 알면서도 그대로
+ * 다음 요청을 보내고, 429 를 맞고, 다시 부르기 사다리를 태우고, 세 번째에
+ * 턴이 죽었다. 사람이 본 것은 「호출 한도 초과」 한 줄이다.
+ *
+ * 맞기 전에 아는 것과 맞고 나서 아는 것은 사람이 할 일이 다르다. 알고 있으면
+ * 그냥 기다렸다 보내면 된다 — 기다리는 것은 실패가 아니다.
+ *
+ * 조심한 것:
+ *   · **모르면 안 기다린다.** 헤더를 안 주는 서버가 많고, 모르는 것을 0 으로
+ *     치면 멀쩡한 연결이 영영 기다린다.
+ *   · 풀림 시각이 없으면 안 기다린다. 얼마나 기다릴지 모르는 채로 붙들면
+ *     화면이 멈춘 것과 구별이 안 된다.
+ *   · 오래된 값으로는 안 정한다. 방금 응답이 아니면 그 사이 풀렸을 수 있다.
+ *   · 상한을 둔다. 그보다 길면 사람이 정할 일이다 — 사실대로 말하고 보낸다.
+ *
+ * @returns {number|null} 기다릴 밀리초. 안 기다려도 되면 null
+ */
+export const 낡은값 = 60000;      // 이보다 오래된 할당량으로는 안 정한다
+export const 미리기다림상한 = 60000;
+
+/*
+ * 어느 창구 것인지는 **부르는 쪽이 정해서 준다.** 기본값을 두지 않는다.
+ *
+ * 전에는 `것 = 마지막` 이었다. 그 기본값이 곧 「아무 창구나 마지막에 답한
+ * 것」 이라, 빠뜨리고 부르면 옆 창구의 바닥난 할당량으로 이쪽이 기다린다 —
+ * 방금 고친 그 고장이다. 기본값을 없애면 다음에 빠뜨렸을 때 조용히 옛
+ * 동작으로 돌아가는 대신 눈에 보이게 어긋난다.
+ */
+export function 미리기다릴까(것, 지금 = Date.now()) {
+  if (!것?.있나) return null;
+  if (!(것.때 > 0) || 지금 - 것.때 > 낡은값) return null;
+  const 바닥난것 = (것.요청 !== null && 것.요청 <= 0) || (것.토큰 !== null && 것.토큰 <= 0);
+  if (!바닥난것) return null;
+  if (!(것.풀림 > 0)) return null;
+  // 그 응답을 받은 뒤로 흐른 만큼은 빼 준다.
+  const 남은초 = 것.풀림 - Math.floor((지금 - 것.때) / 1000);
+  if (!(남은초 > 0)) return null;
+  return Math.min(남은초 * 1000, 미리기다림상한);
+}

package/src/backend/retry.js

@@ -29,9 +29,20 @@
 //   쓰는 사람 여럿이 같은 박자로 다시 두드리면 그게 또 429 를 만든다.
 import { Aborted } from './http.js';
 
-/** 기본 정책. 검사는 base 를 짧게 바꿔 준다 — 모양은 같고 시간만 다르다. */
+/**
+ * 기본 정책. 검사는 base 를 짧게 바꿔 준다 — 모양은 같고 시간만 다르다.
+ *
+ * `막힘최대` 는 **429 에만** 쓰는 횟수다. 기본은 `최대` 와 같게 둔다 —
+ * 사람이 안 시켰는데 프로그램이 오래 붙들고 있으면 화면이 멈춘 것과
+ * 구별이 안 되기 때문이다. 사내 게이트웨이처럼 할당량이 자주 차는 자리는
+ * 설정에서 올린다 (`retry.막힘최대`). 그 대신 **맞기 전에 비키는 것**은
+ * 기본으로 켜져 있다 (backend/quota.js 의 미리기다릴까).
+ *
+ * `총상한` 은 한 요청에서 기다린 시간을 다 더한 울타리다. 사다리가 길어져도
+ * 여기서 멎는다 — 얼마나 기다릴지 모르는 채로 붙드는 일이 없어야 한다.
+ */
 export function 기본정책() {
-  return { 최대: 3, base: [1000, 2000, 4000], 흔들림: 0.3, 상한: 60000 };
+  return { 최대: 3, 막힘최대: null, base: [1000, 2000, 4000], 흔들림: 0.3, 상한: 60000, 총상한: 300000 };
 }
 
 // 잠깐 막힌 것으로 보는 상태 코드. 529 는 Anthropic 계열 게이트웨이의 '과부하' 다.
@@ -44,7 +55,10 @@ const 다시부를코드 = new Set(['ECONNRESET', 'EPIPE', 'UND_ERR_SOCKET', 'EC
  * @param {{status?: number, code?: string|null, attempt?: number}} 실패  attempt 는 방금 실패한 것이 몇 번째였나 (1부터)
  */
 export function 다시부를까({ status = 0, code = null, attempt = 1 } = {}, 정책 = 기본정책()) {
-  if (attempt > 정책.최대) return false;
+  // 429 는 「틀렸다」 가 아니라 「지금은 안 된다」 다. 참을 횟수를 따로 둘 수 있게
+  // 한다 — 안 정했으면 여태와 똑같이 최대 를 쓴다.
+  const 한도 = Number(status) === 429 ? (정책.막힘최대 ?? 정책.최대) : 정책.최대;
+  if (attempt > 한도) return false;
   if (status) return 다시부를상태.has(Number(status));
   return !!code && 다시부를코드.has(String(code));
 }
@@ -99,18 +113,28 @@ export function 기다리기(ms, signal = null) {
  * 실패한 응답 하나를 보고 "기다렸다 다시 부른다" 알림을 만든다. 안 부를 것이면 null.
  * 화면·기록이 이 한 덩이를 그대로 쓴다 — 여기 없는 숫자는 화면에도 없다.
  */
-export function 다시부를지(r, attempt, 정책 = 기본정책()) {
+export function 다시부를지(r, attempt, 정책 = 기본정책(), 쌓인 = 0) {
   const status = r?.status ?? 0;
   const code = r?.code ?? null;
   if (!다시부를까({ status, code, attempt }, 정책)) return null;
   const retryAfter = r?.headers?.get?.('retry-after') ?? r?.res?.headers?.get?.('retry-after') ?? null;
+  const wait = 기다릴시간({ attempt, retryAfter }, 정책);
+  /*
+   * 한 요청에서 기다린 것을 다 더해 울타리를 친다.
+   *
+   * 참을 횟수를 올려 둔 자리(사내 게이트웨이)에서 사다리가 길어지면, 사람은
+   * 왜 멈춰 있는지 모르는 채로 몇 분을 본다. 횟수와 시간은 다른 울타리라
+   * 둘 다 있어야 한다.
+   */
+  const 총상한 = 정책.총상한 ?? Infinity;
+  if (Number.isFinite(총상한) && 쌓인 + wait > 총상한) return null;
   return {
     type: 'backoff',
     status,
     code,
-    wait: 기다릴시간({ attempt, retryAfter }, 정책),
+    wait,
     attempt,
-    max: 정책.최대,
+    max: Number(status) === 429 ? (정책.막힘최대 ?? 정책.최대) : 정책.최대,
     retryAfter: retryAfter ?? null,
   };
 }

package/src/backend/tokens.js

@@ -0,0 +1,59 @@
+/*
+ * 토큰을 대략 센다.
+ *
+ * ── 왜 여기 있나 ────────────────────────────────────────────────────────
+ *
+ * 이 함수는 agent/session.js 안에 있었다. 그런데 재는 자가 필요한 자리가
+ * 거기 하나가 아니다 — backend/cachemark.js 도 「이 대화가 캐시에 잡힐 만한
+ * 크기인가」 를 재야 하는데, cachemark 는 아무것도 안 들여오는 잎 모듈이라
+ * session.js 를 부르면 순환이 된다(session 이 cachemark 의 조각표를 쓴다).
+ *
+ * 그래서 cachemark 는 제 나름대로 **글자 수를 토큰의 두 배로** 쳤다. 영어와
+ * 코드에서만 맞는 셈이라, 실제로는 2,300토큰인 대화를 4,096토큰 문턱을 넘었다고
+ * 답했다. 안 잡힐 표식을 붙여 놓고 화면에는 「캐시 표식」 이라고 적혔다.
+ *
+ * 재는 자가 둘이면 언젠가 둘이 어긋난다. 그래서 자를 **잎으로 내려서** 한
+ * 벌만 둔다. session.js 는 이것을 그대로 다시 내보내므로 부르던 자리는 그대로다.
+ *
+ * ── 얼마나 맞나 ────────────────────────────────────────────────────────
+ *
+ * 정확한 토크나이저는 안 쓴다 — 의존성 0개가 이 프로그램의 약속이고, 창구마다
+ * 토크나이저가 다르므로 하나를 골라 박아도 다른 창구에서는 또 틀린다.
+ * 대신 서버가 실제 값을 알려 주면 그 값으로 배수를 배운다(session.js 의 배운다).
+ * 여기는 **배우기 전의 첫 짐작**이다.
+ *
+ *   한글(자모 포함)·일본어·한자   글자당 1토큰
+ *   그 밖(영문·코드)              3.6글자당 1토큰
+ */
+/*
+ * ── 한글은 완성형만 한글이 아니다 ───────────────────────────────────────
+ *
+ * 여기가 완성형 음절(가–힣)만 셌다. 그래서 아래 것들이 **영문 취급**을 받아
+ * 3.6분의 1로 세어졌다:
+ *
+ *   ㅋㅋㅋ ㅎㅎ ㅠㅠ ㅡㅡ      호환 자모 (U+3130–318F) — 대화에 제일 흔하다
+ *   ᄀ ᅡ ᆨ                     첫가끝 자모 (U+1100–11FF) — 맥에서 만든 파일
+ *                              이름과 그 파일 내용이 이 꼴(NFD)로 온다
+ *
+ * 덜 센 값은 화면 숫자로 안 끝난다. 남은 자리를 넉넉히 보고 → 접기를 늦게
+ * 켜고 → 실제로는 넘친 채로 요청을 보낸다. 한국어를 쓰는 사람이 가장 자주
+ * 치는 글자가 하필 이 칸이었다.
+ */
+const 자모인가 = (cp) => (
+  (cp >= 0x1100 && cp <= 0x11ff)      // 첫가끝 (NFD)
+  || (cp >= 0x3130 && cp <= 0x318f)   // 호환 자모 (ㅋ ㅎ ㅠ …)
+  || (cp >= 0xa960 && cp <= 0xa97f)   // 확장 A
+  || (cp >= 0xd7b0 && cp <= 0xd7ff)   // 확장 B
+);
+
+export function estimateTokens(text) {
+  const s = String(text ?? '');
+  let cjk = 0;
+  for (const ch of s) {
+    const cp = ch.codePointAt(0);
+    if ((cp >= 0xac00 && cp <= 0xd7a3) || (cp >= 0x3040 && cp <= 0x30ff) || (cp >= 0x4e00 && cp <= 0x9fff)
+      || 자모인가(cp)) cjk++;
+  }
+  const rest = s.length - cjk;
+  return Math.ceil(cjk + rest / 3.6);
+}