deel-local-cli 1.17.8 → 1.17.9

package/README.ko.md

@@ -20,7 +20,7 @@
 
 [![Node.js CI](https://img.shields.io/github/actions/workflow/status/jysvai/deel-local-cli/test.yml?branch=main&logo=github&logoColor=white&label=Node.js%20CI)](https://github.com/jysvai/deel-local-cli/actions/workflows/test.yml)
 [![CodeQL](https://img.shields.io/github/actions/workflow/status/jysvai/deel-local-cli/codeql.yml?branch=main&logo=github&logoColor=white&label=CodeQL)](https://github.com/jysvai/deel-local-cli/actions/workflows/codeql.yml)
-[![tests](https://img.shields.io/badge/tests-8%2C095%20passing-1a7f37?logo=checkmarx&logoColor=white)](docs/ko/develop.md)
+[![tests](https://img.shields.io/badge/tests-8%2C140%20passing-1a7f37?logo=checkmarx&logoColor=white)](docs/ko/develop.md)
 
 [![dependencies](https://img.shields.io/badge/dependencies-0-1a7f37)](https://www.npmjs.com/package/deel-local-cli?activeTab=dependencies)
 [![ESM](https://img.shields.io/badge/ESM-Node%2020%2B-5FA04E?logo=javascript&logoColor=white)](package.json)
@@ -301,7 +301,7 @@ deel --offline
 무엇이 어디로 갈 수 있는지는 켤 때 화면 맨 위에 늘 적혀 있습니다.
 
 ```
- deel 1.17.8  ⌂ 이 안
+ deel 1.17.9  ⌂ 이 안
  보냄    이 컴퓨터 안 127.0.0.1:11434  ← 여기 말고는 어디로도 안 갑니다
 ```
 
@@ -1218,7 +1218,7 @@ deel stats                    # 이 폴더에서 실제로 무엇을 했나 (.de
 ## 개발
 
 ```bash
-npm test          전체 검증 (8,095항목 — 몇몇은 터미널에 따라 갈립니다)
+npm test          전체 검증 (8,140항목 — 몇몇은 터미널에 따라 갈립니다)
 npm run coverage  검사가 소스의 어디를 밟았는지
 npm run verify    반입·통신 검증만
 npm run bench     편집 성공률 측정
@@ -1287,6 +1287,7 @@ zip 은 진짜 `unzip` 으로, tar 는 진짜 `tar` 가 만든 것을 읽혀 교
 
 | 판 | 무엇이 바뀌었나 |
 |---|---|
+| [1.17.9](docs/ko/releases/1.17.md#1179) | 한도에 걸렸는데 1초 뒤에 또 두드리고 있었습니다 |
 | [1.17.8](docs/ko/releases/1.17.md#1178) | 긴 지시문을 통째로 붙여 넣으면 시킨 것과 반대로 갔습니다 — 그리고 망이 한 번 끊기면 턴이 사라졌습니다 |
 | [1.17.7](docs/ko/releases/1.17.md#1177) | 나란히 세워 재 봤고, 진 항목을 고쳤습니다 |
 | [1.17.6](docs/ko/releases/1.17.md#1176) | 살아 있다는 신호만 오고 내용이 안 오면, 여태 영원히 기다렸습니다 |

package/README.md

@@ -20,7 +20,7 @@ Vendor APIs connect too — **only when you say so**
 
 [![Node.js CI](https://img.shields.io/github/actions/workflow/status/jysvai/deel-local-cli/test.yml?branch=main&logo=github&logoColor=white&label=Node.js%20CI)](https://github.com/jysvai/deel-local-cli/actions/workflows/test.yml)
 [![CodeQL](https://img.shields.io/github/actions/workflow/status/jysvai/deel-local-cli/codeql.yml?branch=main&logo=github&logoColor=white&label=CodeQL)](https://github.com/jysvai/deel-local-cli/actions/workflows/codeql.yml)
-[![tests](https://img.shields.io/badge/tests-8%2C095%20passing-1a7f37?logo=checkmarx&logoColor=white)](docs/en/develop.md)
+[![tests](https://img.shields.io/badge/tests-8%2C140%20passing-1a7f37?logo=checkmarx&logoColor=white)](docs/en/develop.md)
 
 [![dependencies](https://img.shields.io/badge/dependencies-0-1a7f37)](https://www.npmjs.com/package/deel-local-cli?activeTab=dependencies)
 [![ESM](https://img.shields.io/badge/ESM-Node%2020%2B-5FA04E?logo=javascript&logoColor=white)](package.json)
@@ -374,7 +374,7 @@ deel --offline
 The destination is printed at the top of every session:
 
 ```
- deel 1.17.8  ⌂ inside
+ deel 1.17.9  ⌂ inside
  Sends to this machine 127.0.0.1:11434  ← nowhere else
 ```
 
@@ -1293,7 +1293,7 @@ Stored in `~/.deel/config.json`. A `.deel/config.json` in the project folder tak
 ## Development
 
 ```bash
-npm test          Full suite (8,095 checks; a few are TTY-dependent)
+npm test          Full suite (8,140 checks; a few are TTY-dependent)
 npm run coverage  Which lines the tests actually execute
 npm run verify    Import + network checks only
 npm run bench     Edit success rate
@@ -1348,6 +1348,7 @@ so one run tells you everything.
 
 | Version | What changed |
 |---|---|
+| [1.17.9](docs/en/releases/1.17.md#1179) | Rate-limited, and knocking again one second later |
 | [1.17.8](docs/en/releases/1.17.md#1178) | A long brief got the opposite of what it asked for — and one network blip threw the turn away |
 | [1.17.7](docs/en/releases/1.17.md#1177) | We measured it side by side, and fixed the row we lost |
 | [1.17.6](docs/en/releases/1.17.md#1176) | Only keep-alive and no content used to mean waiting forever |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deel-local-cli",
-  "version": "1.17.8",
+  "version": "1.17.9",
   "description": "A coding-agent CLI that runs on local models and private gateways. Zero dependencies, Node 20+.",
   "type": "module",
   "license": "MIT",

package/src/acp/serve.js

@@ -43,7 +43,7 @@ import { History } from '../safety/undo.js';
 import { Audit, 열쇠묻기 } from '../safety/audit.js';
 import { activeProfile, load, resolveKey, homeDir, save as saveCfg } from '../config.js';
 import { 말 as 옮긴말 } from '../i18n/index.js';
-import { 알림채움 } from '../backend/retry.js';
+import { 알림채움, 알림말 } from '../backend/retry.js';
 import { 전선붙이기, 세션이름짓기 } from '../backend/wire.js';
 import { discover } from '../skills/discover.js';
 import { allowEndpoint, setOffline } from '../safety/network.js';
@@ -631,7 +631,7 @@ export async function acp(opts = {}) {
           // 서버가 잠깐 막아 기다리는 중. 아직 흘러간 글이 없으니 답을 새로 시작하지는 않는다.
           case 'backoff':
             말하기(`\n\n_(${ev.미리
-              ? 옮긴말('loop.quotaAhead', { 초: 알림채움(ev).초 })
+              ? 옮긴말(알림말(ev), { 초: 알림채움(ev).초 })
               : 옮긴말('loop.backoff', 알림채움(ev))})_\n\n`);
             break;
 

package/src/backend/adapter.js

@@ -6,7 +6,7 @@ import {
   req, headersFor, serverMessage, Aborted, 잠잠기본, 연결기본, 초로,
   무소식기본, 무소식알림기본, 소식없음오류,
 } from './http.js';
-import { 할당량기억, 미리기다릴까, 마지막할당량, 할당량자리 } from './quota.js';
+import { 할당량기억, 미리기다릴까, 왜띄우나, 마지막할당량, 할당량자리 } from './quota.js';
 import { 열쇠 as 열쇠받아오기, 쓸수있나 } from '../safety/authcmd.js';
 import { 말 } from '../i18n/index.js';
 import { 다시부를지, 기다리기, 정책고르기 } from './retry.js';
@@ -1011,9 +1011,10 @@ function 몸덤프(body) {
  */
 async function 미리비키기(opts, conn) {
   // **이 창구** 것만 본다. 옆 창구가 바닥났다고 이쪽이 기다리면 안 된다.
-  const ms = 미리기다릴까(마지막할당량(할당량자리(conn)));
+  const 것 = 마지막할당량(할당량자리(conn));
+  const ms = 미리기다릴까(것);
   if (!ms) return 0;
-  opts.onBackoff?.({ type: 'backoff', status: 429, code: null, wait: ms, attempt: 0, max: 0, 미리: true });
+  opts.onBackoff?.({ type: 'backoff', status: 429, code: null, wait: ms, attempt: 0, max: 0, 미리: true, 왜: 왜띄우나(것) });
   await 기다리기(ms, opts.signal ?? null);
   return ms;
 }
@@ -1091,7 +1092,8 @@ export async function chat(conn, opts) {
     });
     // 서버가 남았다고 말해 준 할당량을 적어 둔다 (backend/quota.js).
     // 429 를 맞고 나서야 아는 것과, 맞기 전에 아는 것은 사람이 할 일이 다르다.
-    할당량기억(r.headers, 할당량자리(conn));
+    // 막힌 것이면 그 사실도 적는다 — 다음 부름이 이걸 보고 띄운다 (backend/quota.js).
+    할당량기억(r.headers, 할당량자리(conn), { 막힘: r.status === 429 });
     // 다듬느라 이름을 고쳤으면 여기서 되돌린다. 밖에서는 그런 일이 있었는지
     // 모른 채로 원래 이름을 받는다.
     if (r.ok) {
@@ -1175,9 +1177,10 @@ export async function* chatStream(conn, opts) {
   let 열쇠다시받음 = false;
   let 쌓인대기 = 0;
   {
-    const 미리 = 미리기다릴까(마지막할당량(할당량자리(conn)));
+    const 잰것 = 마지막할당량(할당량자리(conn));
+    const 미리 = 미리기다릴까(잰것);
     if (미리) {
-      yield { type: 'backoff', status: 429, code: null, wait: 미리, attempt: 0, max: 0, 미리: true };
+      yield { type: 'backoff', status: 429, code: null, wait: 미리, attempt: 0, max: 0, 미리: true, 왜: 왜띄우나(잰것) };
       await 기다리기(미리, opts.signal ?? null);
       쌓인대기 += 미리;
     }
@@ -1199,7 +1202,7 @@ export async function* chatStream(conn, opts) {
       stream: true,
       signal: opts.signal ?? null,
     });
-    할당량기억(r.headers ?? r.res?.headers, 할당량자리(conn));
+    할당량기억(r.headers ?? r.res?.headers, 할당량자리(conn), { 막힘: r.status === 429 });
     if (r.ok && r.res?.body) break;
     const 거절 = await 거절읽기(r);
     // 위 chat() 과 같은 규칙. 몸을 먼저 읽고(거절읽기) 나서 다시 부른다 —

package/src/backend/http.js

@@ -25,6 +25,7 @@ import { Readable } from 'node:stream';
 import { checkUrl, NetBlocked } from '../safety/network.js';
 import { 프록시고르기 } from './proxy.js';
 import { 인증서찾기 } from './clientcert.js';
+import { 말 as 옮긴말 } from '../i18n/index.js';
 
 export const AUTH_STYLES = [
   { id: 'bearer', label: 'Authorization: Bearer', apply: (h, k) => { h['Authorization'] = `Bearer ${k}`; } },
@@ -768,6 +769,41 @@ export function 프록시힌트(말) {
   return `게이트웨이 앞단 프록시가 '${도구}' 를 돌리다 실패했습니다 — 모델이 아니라 프록시 쪽 문제입니다.`;
 }
 
+/**
+ * 429 본문을 보고 **무슨 한도인지** 알아본다.
+ *
+ * ── 왜 이게 필요한가 ────────────────────────────────────────────────────
+ *
+ * 화면에 「서버가 잠시 막았습니다 (HTTP 429)」 만 뜨면, 사람이 할 수 있는 것이
+ * 기다리는 것밖에 없다. 그런데 429 는 **한 가지가 아니다.** 어떤 것은 1분 뒤에
+ * 저절로 풀리고, 어떤 것은 관리자가 할당량을 올려 주기 전까지 안 풀린다. 그
+ * 둘에 같은 말을 하면 사람은 30분을 기다리다 포기한다.
+ *
+ * 실제로 이런 것이 왔다.
+ *
+ *   Too many requests sent to ApplyGuardrail: On-demand ApplyGuardrail
+ *   sensitive information policy text units per second limit exceeded.
+ *
+ * 이건 모델 토큰 한도가 아니다. **가드레일이 훑는 글의 양**이고, 단위가 초당
+ * text unit(1 TU 는 1,000자쯤)이다. 그래서 대화가 자랄수록 매 요청이 커지고,
+ * 어느 순간부터 **매번** 걸린다 — 「잘하다가 갑자기」 가 이 모양이다.
+ *
+ * 그리고 프리픽스 캐시가 여기서는 하나도 안 듣는다. 캐시는 모델 쪽 이야기고,
+ * 가드레일은 캐시와 무관하게 매번 전체 글을 훑는다. 이걸 모르면 「캐시가 걸리는데
+ * 왜 한도에 걸리지」 에서 막힌다.
+ *
+ * 원문은 지우지 않고 뒤에 남긴다 — 사내 담당자에게 그대로 보여 줘야 할 때가
+ * 있다. 프록시힌트 와 같은 자세다.
+ */
+export function 막힘힌트(글) {
+  const s = String(글 ?? '');
+  // 가드레일: 초당 **글의 양**. 기다린다고 안 풀리고, 프롬프트를 줄이거나 한도를 올려야 한다.
+  if (/guardrail/i.test(s) && /text\s*units?/i.test(s)) return 옮긴말('net.limit.guardrail');
+  // 분당 한도: 창이 새로 열린다. 여기서는 기다리는 것이 맞는 답이다.
+  if (/per\s*minute|\bTPM\b|\bRPM\b/i.test(s)) return 옮긴말('net.limit.perMinute');
+  return null;
+}
+
 // 서버가 준 오류 본문에서 사람이 읽을 문장만 뽑는다.
 export function serverMessage(r) {
   if (r.error) return r.error;
@@ -780,6 +816,6 @@ export function serverMessage(r) {
   else return `HTTP ${r.status}`;
   // 알아본 것이 있으면 원문 대신 그것을 앞에 세운다. 원문은 뒤에 한 줄로 남긴다 —
   // 사내 담당자에게 그대로 보여 줘야 할 때가 있다.
-  const 힌트 = 프록시힌트(말);
+  const 힌트 = 프록시힌트(말) ?? (Number(r.status) === 429 ? 막힘힌트(말) : null);
   return 힌트 ? `${힌트}\n원문: ${말.slice(0, 160)}` : 말;
 }

package/src/backend/quota.js

@@ -201,9 +201,27 @@ export function 할당량자리(conn) {
   return `${host}|${String(conn.model ?? '').trim()}${꼴 ? `#${꼴}` : ''}`;
 }
 
-export function 할당량기억(머리, 어디 = '') {
+/**
+ * 응답 머리에서 할당량을 읽어 적어 둔다.
+ *
+ * `막힘` 은 **그 응답이 429 였나**다. 머리에 남은 수가 안 실려 와도 이 한
+ * 글자는 안다 — 그리고 그것만으로도 다음 요청을 띄울 까닭이 된다
+ * (아래 미리기다릴까).
+ *
+ * @param {boolean} [옵션.막힘] 이 응답이 429 였나
+ */
+export function 할당량기억(머리, 어디 = '', { 막힘 = false } = {}) {
   const 것 = 할당량읽기(머리);
-  if (것.있나) {
+  것.막힘 = !!막힘;
+  /*
+   * 429 는 머리가 비어 있어도 적어 둔다.
+   *
+   * 게이트웨이 상당수가 막을 때 남은 수도 `Retry-After` 도 안 준다. 그래도
+   * **방금 막혔다는 사실**은 우리가 안다. 그 하나로 다음 요청을 조금 띄울 수
+   * 있고, 그게 이 루프에서 제일 크게 듣는다 — 200걸음짜리 턴에서 41번째가
+   * 바로 다시 두드리면 한도는 영영 안 풀린다.
+   */
+  if (것.있나 || 막힘) {
     const 적을것 = { ...것, 때: Date.now() };
     마지막 = 적을것;
     if (어디) {
@@ -212,6 +230,15 @@ export function 할당량기억(머리, 어디 = '') {
       // 오래 안 쓴 자리부터 버린다. 창구를 옮겨 다녀도 표가 안 자란다.
       while (자리들.size > 자리최대) 자리들.delete(자리들.keys().next().value);
     }
+  } else if (어디) {
+    /*
+     * 머리가 없는 **성공** 응답. 적을 것은 없지만, 앞서 적어 둔 「막혔다」 는
+     * 지워야 한다. 안 지우면 한 번 막힌 뒤로 낡을 때까지(낡은값) 멀쩡한
+     * 요청마다 띄운다 — 고친 것이 아니라 새 고장이다.
+     */
+    const 옛 = 자리들.get(어디);
+    if (옛?.막힘) 자리들.set(어디, { ...옛, 막힘: false });
+    if (마지막?.막힘) 마지막 = { ...마지막, 막힘: false };
   }
   return 것;
 }
@@ -253,6 +280,23 @@ export function 할당량잊기(어디 = '') {
 export const 낡은값 = 60000;      // 이보다 오래된 할당량으로는 안 정한다
 export const 미리기다림상한 = 60000;
 
+/*
+ * 방금 막혔으면 다음 요청을 이만큼은 띄운다.
+ *
+ * 서버가 「언제 오라」 고 말해 줬으면 그 말을 쓴다(풀림). 이건 **아무 말도 안
+ * 해 줬을 때**의 바닥이다. 게이트웨이 상당수가 막을 때 남은 수도 `Retry-After`
+ * 도 안 준다 — 그때 우리가 아는 것은 「방금 막혔다」 하나뿐이다.
+ *
+ * 이건 서버의 창을 짐작하는 것이 아니다. **우리 박자를 늦추는 것**이다. 그
+ * 둘은 다르다 — 앞엣것은 없는 것을 지어내는 짓이고, 뒤엣것은 우리가 얼마나
+ * 빨리 두드릴지 우리가 정하는 것이다.
+ *
+ * 5초로 둔다. 실제로 본 한도가 **초당**이라(Bedrock 의 ApplyGuardrail text
+ * units per second) 몇 초만 띄워도 듣는다. 그러면서 한 번 막혔다고 사람이
+ * 체감할 만큼 느려지지도 않는다.
+ */
+export const 막힘띄움 = 5000;
+
 /*
  * 어느 창구 것인지는 **부르는 쪽이 정해서 준다.** 기본값을 두지 않는다.
  *
@@ -261,14 +305,40 @@ export const 미리기다림상한 = 60000;
  * 방금 고친 그 고장이다. 기본값을 없애면 다음에 빠뜨렸을 때 조용히 옛
  * 동작으로 돌아가는 대신 눈에 보이게 어긋난다.
  */
+/**
+ * 왜 띄우나 — `'바닥'`(남은 것이 0 이라고 서버가 말해 줌) 또는 `'막힘'`(방금 429).
+ *
+ * 화면 문구가 여기서 갈린다. 「할당량이 바닥났다」 는 **서버가 그렇게 말해 줬을
+ * 때만** 할 수 있는 말이다. 429 만 맞고 남은 수는 못 받은 자리에서 그 말을 하면
+ * 화면이 모르는 것을 아는 척하는 것이다 — 이 프로그램이 안 하기로 한 바로 그것.
+ */
+export function 왜띄우나(것) {
+  if (!것) return null;
+  const 바닥난것 = (것.요청 !== null && 것.요청 <= 0) || (것.토큰 !== null && 것.토큰 <= 0);
+  if (바닥난것) return '바닥';
+  return 것.막힘 ? '막힘' : null;
+}
+
 export function 미리기다릴까(것, 지금 = Date.now()) {
-  if (!것?.있나) return null;
+  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, 미리기다림상한);
+  // 서버가 언제 오라고 말해 줬으면 그 말이 먼저다. 바닥났다고 했거나 방금 막혔거나.
+  if ((바닥난것 || 것.막힘) && 것.풀림 > 0) {
+    // 그 응답을 받은 뒤로 흐른 만큼은 빼 준다.
+    const 남은초 = 것.풀림 - Math.floor((지금 - 것.때) / 1000);
+    if (남은초 > 0) return Math.min(남은초 * 1000, 미리기다림상한);
+  }
+
+  /*
+   * 아무 말도 없이 막기만 한 자리. 그래도 방금 막혔다는 것은 안다 —
+   * 그만큼은 띄운다 (막힘띄움). 바닥났다고만 하고 풀림 시각이 없는 것은
+   * 여기 안 들어온다. 언제 풀릴지 모르는 것과 방금 맞은 것은 다르다.
+   */
+  if (것.막힘) {
+    const 남은 = 막힘띄움 - (지금 - 것.때);
+    if (남은 > 0) return Math.min(남은, 미리기다림상한);
+  }
+  return null;
 }

package/src/backend/retry.js

@@ -47,9 +47,40 @@ import { Aborted } from './http.js';
  * 여기서 멎는다 — 얼마나 기다릴지 모르는 채로 붙드는 일이 없어야 한다.
  */
 export function 기본정책() {
-  return { 최대: 3, 막힘최대: null, base: [1000, 2000, 4000], 흔들림: 0.3, 상한: 60000, 총상한: 300000 };
+  return {
+    최대: 3, 막힘최대: null, base: [1000, 2000, 4000],
+    막힘base: [5000, 15000, 30000],
+    흔들림: 0.3, 상한: 60000, 총상한: 300000,
+  };
 }
 
+/*
+ * ── 429 는 사다리가 따로여야 한다 ───────────────────────────────────────
+ *
+ * 502·503 은 「서버가 딸꾹질했다」 다. 1초 뒤에 다시 보내면 대개 된다.
+ * 429 는 **「네 몫을 다 썼다」** 다. 1초 뒤에 보내면 거의 확실히 또 막히고,
+ * 게이트웨이 상당수는 **막아서 돌려보낸 요청도 한도에 센다** — 빨리 두드릴수록
+ * 구덩이가 깊어진다. 같은 사다리를 쓰면 안 되는 까닭이 이것이다.
+ *
+ * 실제로 본 것(사내 LiteLLM → Bedrock):
+ *
+ *   litellm.RateLimitError: BedrockException - Too many requests sent to
+ *   ApplyGuardrail: On-demand ApplyGuardrail sensitive information policy
+ *   text units per second limit exceeded.
+ *   ... LiteLLM Retried: 2 times, LiteLLM Max Retries: 2
+ *
+ * 두 가지가 보인다.
+ *
+ *   · 한도가 **초당**이다. 분당이 아니라 초당이라, 프롬프트가 크면 한 번의
+ *     요청만으로도 그 초의 몫을 다 쓴다.
+ *   · **게이트웨이가 이미 두 번 다시 불렀다.** 우리가 그 답을 보기 전에 벌써
+ *     세 번 나간 것이다. 거기에 1초·2초·4초를 얹으면 7초 안에 여섯 번이다.
+ *
+ * 그래서 5초 · 15초 · 30초로 시작한다. 흔한 한도 창이 1분이라, 세 번째면
+ * 50초를 기다린 셈이 되어 창 하나를 거의 넘긴다. 서버가 `Retry-After` 로
+ * 말해 주면 **그 말이 언제나 이긴다** — 아래 기다릴시간 의 첫 줄이다.
+ */
+
 // 잠깐 막힌 것으로 보는 상태 코드. 529 는 Anthropic 계열 게이트웨이의 '과부하' 다.
 const 다시부를상태 = new Set([408, 429, 500, 502, 503, 504, 529]);
 // 머리말도 못 받고 끊긴 것. undici 는 상대가 닫으면 UND_ERR_SOCKET 으로 온다.
@@ -113,13 +144,17 @@ export function 못붙은것인가(code) {
  * 몇 ms 기다릴까. 서버가 말해 준 것이 있으면 그것, 없으면 사다리.
  * @param {{attempt?: number, retryAfter?: string|number|null}} 자리
  */
-export function 기다릴시간({ attempt = 1, retryAfter = null } = {}, 정책 = 기본정책()) {
+export function 기다릴시간({ attempt = 1, retryAfter = null, status = 0 } = {}, 정책 = 기본정책()) {
   const 서버말 = retryAfter읽기(retryAfter);
   if (서버말 !== null) return Math.min(서버말, 정책.상한);
+  // 429 는 제 사다리를 쓴다. 안 정해 뒀으면 기본 사다리로 떨어진다 — 예전
+  // 설정을 그대로 쓰는 사람에게 갑자기 다른 박자가 생기지는 않는다.
+  const 막힘인가 = Number(status) === 429;
+  const 고른것 = 막힘인가 ? (정책.막힘base ?? 정책.base) : 정책.base;
   // 사다리가 비었으면(설정이 이상하면) 기본 사다리로 — NaN 초를 기다릴 수는 없다.
-  const 사다리 = Array.isArray(정책.base) && 정책.base.some(Number.isFinite)
-    ? 정책.base.filter(Number.isFinite)
-    : 기본정책().base;
+  const 사다리 = Array.isArray(고른것) && 고른것.some(Number.isFinite)
+    ? 고른것.filter(Number.isFinite)
+    : (막힘인가 ? 기본정책().막힘base : 기본정책().base);
   const 칸 = 사다리[Math.min(attempt, 사다리.length) - 1] ?? 사다리[사다리.length - 1];
   return Math.min(정책.상한, Math.round(칸 * (1 + Math.random() * 정책.흔들림)));
 }
@@ -164,7 +199,7 @@ export function 다시부를지(r, attempt, 정책 = 기본정책(), 쌓인 = 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 wait = 기다릴시간({ attempt, retryAfter, status }, 정책);
   /*
    * 한 요청에서 기다린 것을 다 더해 울타리를 친다.
    *
@@ -189,6 +224,26 @@ export function 다시부를지(r, attempt, 정책 = 기본정책(), 쌓인 = 0)
  * 알림 한 덩이를 화면 말(i18n 의 loop.backoff)에 끼울 자리로 바꾼다.
  * 세 화면(repl · deel run · acp)이 같은 것을 본다 — 한 군데만 고치면 셋이 어긋난다.
  */
+/**
+ * 이 알림에 쓸 화면 말 열쇠.
+ *
+ * 세 가지가 다른 말이라 세 열쇠다.
+ *
+ *   loop.backoff     서버가 밀어냈다 — 기다렸다 **다시** 부른다 (n/max 가 있다)
+ *   loop.quotaAhead  남은 것이 0 이라고 **서버가 말해 줬다** — 보내기 전에 비킨다
+ *   loop.limitAhead  방금 429 를 맞았다. 남은 수는 모른다 — 우리 박자를 늦춘다
+ *
+ * 뒤의 둘을 한 말로 합치면 화면이 거짓말을 한다. 「할당량이 바닥났다」 는 서버가
+ * 그렇게 말해 줬을 때만 할 수 있는 말이다.
+ *
+ * 다섯 자리(repl · deel run · acp · consult 둘)가 이걸 같이 쓴다. 각자 갈라 놓으면
+ * 언젠가 하나가 빠지고, 빠진 자리는 `(0/0)` 을 찍는다 — 실제로 그랬다.
+ */
+export function 알림말(ev) {
+  if (!ev?.미리) return 'loop.backoff';
+  return ev.왜 === '막힘' ? 'loop.limitAhead' : 'loop.quotaAhead';
+}
+
 export function 알림채움(ev) {
   const 초 = (ev?.wait ?? 0) / 1000;
   return {

package/src/commands.js

@@ -32,7 +32,7 @@ import { allowTemporarily } from './safety/network.js';
 import { chat, 규격이름, 더할머리 } from './backend/adapter.js';
 import { 잠잠기본, 무소식기본 } from './backend/http.js';
 import { 인증서설정, 인증서말 } from './backend/clientcert.js';
-import { 알림채움 } from './backend/retry.js';
+import { 알림채움, 알림말 } from './backend/retry.js';
 import { 프록시고르기, 프록시설정 } from './backend/proxy.js';
 import { 정한셸 } from './tools/shell.js';
 import { TOOLS, 영어설명 } from './tools/index.js';
@@ -277,7 +277,9 @@ export async function handle(line, session, ctx) {
           temperature: 0.3,
           // 서버가 잠깐 막으면 돌림표 뒤에 숨기지 않고 말한다 — 왜 오래 걸리는지 보여야 한다.
           onBackoff: (알림) => {
-            돌림.stop(`  ${c.yellow('↻')} ${c.gray(말('loop.backoff', 알림채움(알림)))}`);
+            돌림.stop((알림.미리
+              ? `  ${c.yellow('⏸')} ${c.gray(말(알림말(알림), { 초: 알림채움(알림).초 }))}`
+              : `  ${c.yellow('↻')} ${c.gray(말('loop.backoff', 알림채움(알림)))}`));
             돌림 = spin(말('consult.asking', { 모델: 새conn.model }));
           },
         });
@@ -644,7 +646,9 @@ export async function handle(line, session, ctx) {
       let s = spin('앞선 대화를 요약해 접는 중…');
       const r = await compact(session, {
         onBackoff: (알림) => {
-          s.stop(`  ${c.yellow('↻')} ${c.gray(말('loop.backoff', 알림채움(알림)))}`);
+          s.stop((알림.미리
+              ? `  ${c.yellow('⏸')} ${c.gray(말(알림말(알림), { 초: 알림채움(알림).초 }))}`
+              : `  ${c.yellow('↻')} ${c.gray(말('loop.backoff', 알림채움(알림)))}`));
           s = spin('앞선 대화를 요약해 접는 중…');
         },
       });
@@ -2289,7 +2293,9 @@ async function 커밋명령(session, ctx, arg = '') {
     전부,
     제목: 준제목,
     onBackoff: (알림) => {
-      돌림.stop(`  ${c.yellow('↻')} ${c.gray(말('loop.backoff', 알림채움(알림)))}`);
+      돌림.stop((알림.미리
+              ? `  ${c.yellow('⏸')} ${c.gray(말(알림말(알림), { 초: 알림채움(알림).초 }))}`
+              : `  ${c.yellow('↻')} ${c.gray(말('loop.backoff', 알림채움(알림)))}`));
       돌림 = spin(도는말);
     },
   });

package/src/i18n/en.js

@@ -558,6 +558,9 @@ export const en = {
   'think.wireNoOff': 'this endpoint never told us its off value — the field is omitted, so the server default applies',
   'loop.wire': 'The server does not take that field — retrying with it adjusted ({무엇})',
   'loop.quotaAhead': 'Quota is empty — waiting {초}s before sending',
+  'loop.limitAhead': 'Just rate-limited — spacing this out by {초}s',
+  'net.limit.guardrail': 'This is a guardrail limit on the gateway, not a model token limit. It counts text scanned per second (text units, roughly 1,000 characters each), so as the conversation grows every request gets bigger and past some point it fails every time. Prompt caching does not help here — the guardrail scans the full text every time regardless. Raising the model per-minute request/token limits (RPM/TPM) does nothing to it: different API, different quota. /compact shrinks the conversation for immediate relief; the real fix is for whoever runs the gateway to raise the guardrail quota or stop applying it to input.',
+  'net.limit.perMinute': 'This is a per-minute limit — it clears itself once the window rolls over. Waiting is the right answer here.',
   'cost.quota': 'Server quota',
   'cost.quotaAge': 'as of {초}s ago',
 

package/src/i18n/ja.js

@@ -515,6 +515,9 @@ export const ja = {
   'think.wireNoOff': 'この窓口は切る値を教えてくれませんでした — 項目を送らないので、サーバー既定値で動きます',
   'loop.wire': 'サーバーが受け取らない項目があるため、直して呼び直します ({무엇})',
   'loop.quotaAhead': '残量が尽きたので {초} 秒待ってから送ります',
+  'loop.limitAhead': '直前に制限に当たったので {초} 秒あけてから送ります',
+  'net.limit.guardrail': 'ゲートウェイに付いたガードレールの上限です — モデルのトークン上限ではありません。数えているのは毎秒走査する文字量(text unit・1 TU はおよそ 1,000 文字)なので、会話が伸びるほど一回の要求が大きくなり、ある時点から毎回引っかかります。プレフィックスキャッシュはここでは効きません — ガードレールはキャッシュと無関係に毎回全文を走査します。モデルの毎分の要求・トークン上限(RPM・TPM)を上げても動きません。別の API の別の割当です。/compact で会話を縮めると当座はしのげます。根本はゲートウェイ担当者がガードレールの割当を上げるか、入力には掛けないようにすることです。',
+  'net.limit.perMinute': '毎分の上限です — 窓が変われば自然に解けます。ここでは待つのが正解です。',
   'cost.quota': 'サーバー残量',
   'cost.quotaAge': '{초}秒前の応答基準',
 

package/src/i18n/ko.js

@@ -605,6 +605,9 @@ export const ko = {
   'think.wireNoOff': '이 창구는 끄는 말을 안 알려 줬습니다 — 칸을 안 싣고, 서버 기본값으로 돕니다',
   'loop.wire': '서버가 안 받는 칸이 있어 맞춰 다시 부릅니다 ({무엇})',
   'loop.quotaAhead': '할당량이 바닥나서 {초}초 기다렸다 보냅니다',
+  'loop.limitAhead': '방금 한도에 걸려서 {초}초 띄웠다 보냅니다',
+  'net.limit.guardrail': '게이트웨이에 붙은 가드레일 한도입니다 — 모델 토큰 한도가 아닙니다. 재는 것이 초당 훑는 글의 양(text unit, 1 TU 가 1,000자쯤)이라, 대화가 자랄수록 매 요청이 커져 어느 순간부터 계속 걸립니다. 프리픽스 캐시는 여기서 안 듣습니다 — 가드레일은 캐시와 무관하게 매번 전체 글을 훑습니다. 모델의 분당 요청·토큰 한도(RPM·TPM)를 올려도 이건 안 움직입니다: 다른 API 의 다른 할당량입니다. /compact 로 대화를 줄이면 당장 낫고, 근본은 게이트웨이 담당자가 가드레일 할당량을 올리거나 입력에는 안 걸도록 바꾸는 것입니다.',
+  'net.limit.perMinute': '분당 한도입니다 — 창이 새로 열리면 저절로 풀립니다. 여기서는 기다리는 것이 맞습니다.',
   'cost.quota': '서버 할당량',
   'cost.quotaAge': '{초}초 전 응답 기준',
 

package/src/i18n/zh.js

@@ -515,6 +515,9 @@ export const zh = {
   'think.wireNoOff': '该端点未告知关闭值 — 不发送该字段，因此按服务器默认值运行',
   'loop.wire': '服务端不接受该字段，已调整后重试 ({무엇})',
   'loop.quotaAhead': '额度用尽，等待 {초} 秒后再发送',
+  'loop.limitAhead': '刚被限流，间隔 {초} 秒后再发送',
+  'net.limit.guardrail': '这是网关上护栏的限额，不是模型的令牌限额。它按每秒扫描的文本量计数(text unit，1 TU 约 1,000 个字符)，所以对话越长每次请求越大，过了某个点就会每次都被拦。前缀缓存在这里没有用 — 护栏与缓存无关，每次都会扫描全文。提高模型的每分钟请求/令牌限额(RPM/TPM)不会有任何作用：那是另一个 API 的另一份配额。用 /compact 缩短对话可以先缓解；根本办法是让网关维护者提高护栏配额，或不要对输入应用它。',
+  'net.limit.perMinute': '这是每分钟限额 — 窗口滚动后会自行解除，这里等待就是正确做法。',
   'cost.quota': '服务器额度',
   'cost.quotaAge': '基于{초}秒前的响应',
 

package/src/oneshot.js

@@ -26,7 +26,7 @@ import { History } from './safety/undo.js';
 import { Audit, 열쇠묻기 } from './safety/audit.js';
 import { activeProfile, load, resolveKey, 잠금소식, 열쇠탈소식, 프로젝트설정소식 } from './config.js';
 import { 말 as 옮긴말 } from './i18n/index.js';
-import { 알림채움 } from './backend/retry.js';
+import { 알림채움, 알림말 } from './backend/retry.js';
 import { 전선붙이기, 세션이름짓기 } from './backend/wire.js';
 import { newId } from './agent/store.js';
 import { discover, loadCommand } from './skills/discover.js';
@@ -605,7 +605,7 @@ export async function runOnce(opts = {}) {
           // 맞고 물러난 것과 맞기 전에 비킨 것은 다른 일이다. 같은 말로 적으면
           // 있지도 않은 429 가 배치 기록에 남는다.
           곁(ev.미리
-            ? `  ${c.yellow('⏸')} ${c.gray(옮긴말('loop.quotaAhead', { 초: 알림채움(ev).초 }))}`
+            ? `  ${c.yellow('⏸')} ${c.gray(옮긴말(알림말(ev), { 초: 알림채움(ev).초 }))}`
             : `  ${c.yellow('↻')} ${c.gray(옮긴말('loop.backoff', 알림채움(ev)))}`);
           break;
 

package/src/repl.js

@@ -12,7 +12,7 @@ import { headerLines } from './ui/status.js';
 import { 종, 창제목, 제목되돌리기, 알릴까, 제목글 } from './ui/notify.js';
 import { 보이기 as 인트로, 기본곁말 } from './ui/intro.js';
 import { 언어잡기, 말 as 옮긴말, 세말 } from './i18n/index.js';
-import { 알림채움 } from './backend/retry.js';
+import { 알림채움, 알림말 } from './backend/retry.js';
 import { 전선붙이기, 세션이름짓기 } from './backend/wire.js';
 import { 화면고르기 } from './ui/screen.js';
 import { STAGES } from './agent/effort.js';
@@ -1877,7 +1877,7 @@ export async function chatLoop(opts = {}) {
           case 'backoff':
             clearThinking();
             say(ev.미리
-              ? `  ${c.yellow('⏸')} ${c.gray(옮긴말('loop.quotaAhead', { 초: 알림채움(ev).초 }))}`
+              ? `  ${c.yellow('⏸')} ${c.gray(옮긴말(알림말(ev), { 초: 알림채움(ev).초 }))}`
               : `  ${c.yellow('↻')} ${c.gray(옮긴말('loop.backoff', 알림채움(ev)))}`);
             break;