deel-local-cli 1.17.3 → 1.17.5

package/src/agent//354/213/240/353/242/260/353/217/204.js

@@ -0,0 +1,191 @@
+/**
+ * 겪은 것을 **얼마나 믿을까.**
+ *
+ * ── 왜 따로 있나 ────────────────────────────────────────────────────────
+ *
+ * evolve.js 는 「무엇을 겪었나」 를 센다. 이 파일은 그 셈을 보고 「그것을 사실로
+ * 말해도 되나」 를 정한다. 두 가지는 자꾸 섞이는데, 섞어 두면 셈을 고칠 때마다
+ * 믿음의 문턱이 같이 흔들린다. 그리고 문턱이 흔들리는 것은 **화면에 안 나타난다.**
+ *
+ * ── 무엇이 문제였나 ─────────────────────────────────────────────────────
+ *
+ * 자기가 쓴 기록을 자기가 다시 읽는 프로그램은 두 가지로 썩는다.
+ *
+ *   1. **작은 표본을 확신으로 읽는다.** 두 번 실패한 것을 「이 PC 에서 안 되는
+ *      명령」 이라고 프롬프트에 적어 보냈다. 두 번은 우연일 수 있다.
+ *
+ *   2. **틀린 부정이 스스로를 봉인한다.** 「다시 부르지 마라」 가 프롬프트에
+ *      들어가면 모델이 안 부르고, 안 부르니 성공 셈이 영영 안 늘고, 그래서
+ *      그 줄이 영영 안 사라진다. 지난달에 없던 프로그램을 오늘 깔아도
+ *      deel 은 없다고 우긴다. 고쳐질 길이 **구조적으로** 막혀 있었다.
+ *
+ * 둘 다 새로운 문제가 아니다. 남들이 이미 넘은 자리라 그 방식을 그대로 쓴다.
+ *
+ * ── 빌려 온 방식 ────────────────────────────────────────────────────────
+ *
+ *   **윌슨 점수 아래끝 (Wilson score lower bound)**
+ *   별점 정렬에서 「5점 하나짜리」 가 「4.8점 천 개짜리」 를 이기던 문제를 푼
+ *   방식이다. 비율을 그대로 믿지 않고, 표본이 적으면 그만큼 **깎아서** 본다.
+ *   두 번 성공은 두 번어치만 믿는다. 근거: Evan Miller,
+ *   "How Not To Sort By Average Rating" (evanmiller.org).
+ *
+ *   **시간 할인 (discounted counts · Discounted-UCB)**
+ *   세상이 안 멈춰 있는 자리에서 옛 관측을 조금씩 잊는 방식이다. 관측마다
+ *   `γ^(지난 날수)` 를 곱해 두면, 다시 안 겪은 사실은 저절로 힘이 빠진다.
+ *   근거: Garivier & Moulines, "On Upper-Confidence Bound Policies for
+ *   Switching Bandit Problems" (Discounted-UCB · Sliding-Window UCB).
+ *
+ * **이 둘을 겹치면 2번이 저절로 풀린다.** 「안 된다」 는 다시 안 겪으면 힘이
+ * 빠지고, 힘이 빠지면 말하기를 멈추고, 그러면 모델이 다시 해 보고, 그 결과가
+ * 새 관측이 된다. 봉인을 따로 깨는 장치를 넣을 필요가 없다 — 잊는 것이 곧
+ * 다시 해 보는 것이다.
+ *
+ * ── 여기 없는 것 ────────────────────────────────────────────────────────
+ *
+ * 파일에서 읽은 것이 **애초에 우리가 적은 모양이 맞나**는 여기서 안 본다
+ * (agent/성한기록.js). 통계와 문지기는 다른 일이고, 섞어 두면 통계 문턱을
+ * 만질 때마다 문지기도 같이 흔들린다.
+ *
+ * ── 안 하는 것 ──────────────────────────────────────────────────────────
+ *
+ * **지우지 않는다.** 못 믿겠다는 것과 없던 일이라는 것은 다르다. 지워 버리면
+ * 다시 겪을 때 처음부터 두 번을 채워야 하고, 그 사이에 또 우회로를 탄다.
+ * 여기가 정하는 것은 「말할까」 하나뿐이고, 셈은 evolve.js 가 그대로 들고 있다.
+ */
+
+/*
+ * 믿음의 폭. z=1 은 약 68% 구간이다.
+ *
+ * 95%(z≈1.96)로 조이면 열 번을 겪어야 겨우 말할 수 있게 되는데, 사람이 한
+ * 폴더에서 같은 명령을 열 번 돌리기 전에 대화가 끝난다. 그러면 이 기능이
+ * 켜져 있으나 마나가 된다 — 안 배우느니만 못한 것이 아니라, 그냥 안 배운다.
+ *
+ * z=1 은 「두 번 겪으면 말하고, 한 번은 말하지 않는다」 에 딱 맞는다. 여태
+ * 쓰던 규칙(`ok>=2 && no===0`)이 우연히 서 있던 자리이기도 하다. 다른 점은,
+ * 이제 그 자리가 **어디서 온 숫자인지** 적혀 있다는 것이다.
+ */
+export const z = 1;
+
+/** 이 위로 올라가야 「된다」 고 말한다 (성공률 아래끝). */
+export const 좋음문턱 = 0.6;
+/** 이 아래로 내려가야 「안 된다」 고 말한다 (성공률 위끝). */
+export const 나쁨문턱 = 0.4;
+
+/*
+ * ── 반감기가 둘인 까닭 ──────────────────────────────────────────────────
+ *
+ * 다시 안 겪은 관측이 절반으로 줄기까지의 날수인데, **「된다」 와 「안 된다」 에
+ * 다른 값을 준다.** 언뜻 자의적으로 보이지만 근거가 있다.
+ *
+ * 틀린 긍정("이 명령이 된다")은 한 번 해 보면 그 자리에서 들통난다. 값은
+ * 실패한 명령 한 번이고, 그 실패가 곧 새 관측이 되어 스스로를 고친다.
+ *
+ * 틀린 부정("안 된다")은 **해 보는 일 자체를 막는다.** 프롬프트가 부르지
+ * 말라고 하니 모델이 안 부르고, 안 부르니 관측이 안 생기고, 그래서 영영 안
+ * 고쳐진다. 들통날 기회를 자기가 없앤다.
+ *
+ * 그래서 부정은 더 빨리 잊는다. 반감기 사흘이면 **두 번 겪은 「안 된다」 는
+ * 하루쯤 뒤에** 입을 다문다. 그러면 모델이 다시 해 보고, 정말 안 되면 그날
+ * 다시 쌓인다 — 다섯 번 겪은 것은 닷새쯤 간다. 하루에 한 번 헛부름은
+ * 「한 달 내내 틀린 말을 프롬프트에 싣는 것」 보다 훨씬 싸다.
+ *
+ * 긍정은 세 주로 둔다. 이레로 뒀더니 **금요일에 확인한 명령이 월요일 아침에
+ * 백지가 됐다** — 그건 잊는 것이 아니라 안 배우는 것이다. 세 주면 두 번 겪은
+ * 사실이 아흐레쯤 가고, 다섯 번 겪은 사실은 한 달을 넘긴다.
+ */
+export const 반감기된다 = 21;
+export const 반감기안된다 = 3;
+
+/** 하루에 곱해지는 값. 반감기에서 나온다 — 두 곳에 따로 적으면 언젠가 갈린다. */
+export const 하루할인된다 = Math.pow(0.5, 1 / 반감기된다);
+export const 하루할인안된다 = Math.pow(0.5, 1 / 반감기안된다);
+
+/**
+ * 며칠 지났나. 못 재면 무한대다.
+ *
+ * **모르는 것을 「오늘」 로 치지 않는다.** 옛 판에서 넘어왔거나 손으로 고쳐진
+ * 기록에는 날짜가 없을 수 있는데, 그것을 오늘 겪은 것으로 치면 나이를 알 수
+ * 없는 주장이 통째로 되살아난다 — 이 파일이 막으려는 바로 그 오염이다.
+ *
+ * 미래에 적힌 것은 0일로 친다. 시계가 틀어진 PC 에서 음수 날수가 나오면
+ * 할인이 1보다 커져서 **겪지도 않은 것이 더 세진다.**
+ */
+export function 며칠됐나(지금, 그때) {
+  const a = Date.parse(String(지금 ?? ''));
+  const b = Date.parse(String(그때 ?? ''));
+  if (!Number.isFinite(a) || !Number.isFinite(b)) return Infinity;
+  return Math.max(0, (a - b) / 86400000);
+}
+
+/**
+ * 지난 셈을 오늘 기준으로 삭힌다 (Discounted-UCB 의 할인).
+ *
+ * 관측 하나하나에 날짜를 달아 두지 않아도 된다. 마지막으로 손댄 날부터
+ * 오늘까지의 할인을 통째로 한 번 곱하면 같은 값이 된다 — 그래서 기록은
+ * `{ok, no, at}` 세 칸 그대로다.
+ *
+ * 아주 작아진 값은 0 으로 떨군다. 안 그러면 10^-9 짜리 부스러기가 표에 남아
+ * 자리만 차지하고, 그 부스러기가 `줄이기` 에서 진짜 기록을 밀어낸다.
+ */
+export const 부스러기 = 0.01;
+
+export function 삭힘({ ok = 0, no = 0 } = {}, 날수 = 0) {
+  if (!Number.isFinite(날수)) return { ok: 0, no: 0 };
+  const a = (Number(ok) || 0) * Math.pow(하루할인된다, 날수);
+  const b = (Number(no) || 0) * Math.pow(하루할인안된다, 날수);
+  return { ok: a < 부스러기 ? 0 : a, no: b < 부스러기 ? 0 : b };
+}
+
+/*
+ * ── 윌슨 점수 구간 ──────────────────────────────────────────────────────
+ *
+ * 성공 s 번, 전체 n 번일 때 진짜 성공률이 어느 사이에 있는가. 평균을 그대로
+ * 쓰지 않는 까닭은 n 이 작을 때 평균이 거짓말을 하기 때문이다 — 1승 0패의
+ * 평균은 100% 지만, 그 100% 는 아무것도 안 말해 준다.
+ *
+ * ── 소수 n 을 넣는 것에 대해 (알고 넘어가는 어긋남) ─────────────────────
+ *
+ * 윌슨 점수는 **정수 시행**을 전제로 한 근사다. 우리가 넣는 n 은 삭힌 값이라
+ * 소수이고, 그건 엄밀히는 맞지 않는다. 가중된 관측의 유효 표본 수는
+ * `(Σw)² / Σw²` 인데 그 값은 언제나 `Σw` 보다 작으므로, `Σw` 를 그대로 쓰면
+ * **분산을 덜 잡는다** — 즉 우리는 실제보다 조금 더 확신하는 쪽으로 틀린다.
+ *
+ * 제대로 하려면 관측마다 무게를 들고 있다가 베타 사후분포의 분위수를 봐야
+ * 하는데, 그러려면 기록이 `{ok, no, at}` 세 칸으로 안 끝난다. 그 값을 치를
+ * 만큼의 정밀도가 아니다 — 여기서 나오는 답은 「말한다 / 안 한다」 둘뿐이다.
+ *
+ * 대신 **어긋나는 방향을 알고 문턱을 그만큼 넉넉히 잡았다.** 두 번 겪어야
+ * 말하기 시작하는데, 덜 잡힌 분산은 그 둘을 하나 반쯤으로 보이게 하는
+ * 정도다. 지어낸 정밀도로 한 번 더 계산하느니, 어긋남을 적어 두는 편이 낫다.
+ */
+function 구간(s, n) {
+  if (!(n > 0)) return { 아래: 0, 위: 1 };
+  const p = Math.min(1, Math.max(0, s / n));
+  const z2 = z * z;
+  const 나눔 = 1 + z2 / n;
+  const 가운데 = (p + z2 / (2 * n)) / 나눔;
+  const 폭 = (z / 나눔) * Math.sqrt((p * (1 - p)) / n + z2 / (4 * n * n));
+  return { 아래: Math.max(0, 가운데 - 폭), 위: Math.min(1, 가운데 + 폭) };
+}
+
+/** 성공률의 아래끝. 표본이 적으면 그만큼 깎인다. */
+export function 윌슨아래(s, n) { return 구간(s, n).아래; }
+/** 성공률의 위끝. 「안 된다」 를 말해도 되는지는 이쪽으로 잰다. */
+export function 윌슨위(s, n) { return 구간(s, n).위; }
+
+/**
+ * 이 기록을 보고 무엇을 말할 수 있나.
+ *
+ * @returns {'된다'|'안된다'|'모름'}
+ *
+ * 「모름」 이 제일 흔한 답이고, 그래야 맞다. 우리가 프롬프트에 한 줄을 더하는
+ * 것은 모델의 판단을 그쪽으로 미는 일이라, 확실하지 않으면 안 미는 편이 낫다.
+ */
+export function 뭐라할까(기록, 지금) {
+  const { ok, no } = 삭힘(기록, 며칠됐나(지금, 기록?.at));
+  const n = ok + no;
+  if (!(n > 0)) return '모름';
+  if (윌슨아래(ok, n) >= 좋음문턱) return '된다';
+  if (윌슨위(ok, n) <= 나쁨문턱) return '안된다';
+  return '모름';
+}

package/src/backend/adapter.js

@@ -1016,6 +1016,58 @@ async function 미리비키기(opts, conn) {
 }
 
 // 한 번에 받기.
+/*
+ * ── 이 요청이 **어느 자리로 갔나** ──────────────────────────────────────
+ *
+ * 게이트웨이 뒤에는 대개 같은 모델이 여러 자리에 올라가 있다(리전 여럿,
+ * 열쇠 여럿). 그런데 **프리픽스 캐시는 자리마다 따로다.** 그래서 어제까지
+ * 92% 로 읽히던 대화가, 다음 요청이 다른 자리로 가는 순간 0% 가 된다 —
+ * 우리가 보낸 것은 한 글자도 안 달라졌는데.
+ *
+ * 실제로 그 줄을 봤다. 같은 122.4K 프리픽스가 3분 41초 만에 다시 나갔고,
+ * 그 한 번이 그날 제일 비싼 요청이었다. 화면에는 아무 말도 안 났다.
+ *
+ * 그래서 **서버가 말해 줄 때만** 적어 둔다. LiteLLM 은 어느 자리가 받았는지
+ * 를 응답 머리로 알려 준다(`x-litellm-model-id`) — 이 값이 턴 사이에 바뀌면
+ * 캐시가 끊겼다는 뜻이고, 그건 짐작이 아니라 잰 것이다.
+ *
+ * 없으면 아무 말도 안 한다. 모르는 머리는 그냥 없는 것이고, 없는 것을 두고
+ * 「자리가 안 바뀌었다」 고 말하지도 않는다.
+ *
+ * **값은 화면에 안 찍는다.** 이 값은 사내 배포 이름이거나 리전 주소일 수
+ * 있다. 우리가 쓸 것은 「바뀌었나」 하나뿐이라, 바뀌었다는 사실만 올린다.
+ */
+/*
+ * ── 왜 이름이 하나뿐인가 ────────────────────────────────────────────────
+ *
+ * 세션 이름을 **내보낼** 때는 아는 이름을 다 단다(위 세션머리). 머리는 모르면
+ * 무시되니 이름이 늘어도 잃을 것이 없어서다. 여기는 반대다 — **받아서 읽는**
+ * 자리라, 이름 하나를 잘못 고르면 없는 일을 있다고 말하게 된다.
+ *
+ * 그래서 「어느 자리가 받았나」 를 뜻한다고 **문서에 적힌** 이름만 읽는다.
+ * 그럴듯한 일반형들을 같이 읽어 봤다가 도로 뺐다:
+ *
+ *   x-deployment-id       일반 웹·컨테이너 인프라(배포 해시)가 같은 이름을
+ *                         쓴다. 모델과 아무 상관 없이 배포할 때마다 바뀌므로,
+ *                         멀쩡한 캐시를 두고 「자리가 바뀌었다」 를 찍는다.
+ *   x-ms-deployment-name  Azure 의 **논리** 배포 이름이라 물리 자리가 바뀌어도
+ *                         그대로다. 읽어 봐야 알아내는 것이 없고, 있는데 없다고
+ *                         말하는 쪽이라 더 나쁘다.
+ *
+ * 모르면 아무 말도 안 하는 편이 낫다. 안 뜨는 경고는 사람이 다른 데를 보게
+ * 하지 않지만, 틀린 경고는 진짜 경고까지 안 읽게 만든다.
+ */
+const 자리머리들 = ['x-litellm-model-id'];
+
+export function 간자리(머리) {
+  if (!머리?.get) return null;
+  for (const 이름 of 자리머리들) {
+    const v = 머리.get(이름);
+    if (v) return String(v).trim() || null;
+  }
+  return null;
+}
+
 export async function chat(conn, opts) {
   // 이 회사가 받는 모양으로 도구를 다듬는다 (backend/toolfit.js).
   // 모르는 주소면 아무것도 안 바뀐다 — 지금까지와 똑같이 돈다.
@@ -1038,7 +1090,11 @@ export async function chat(conn, opts) {
     할당량기억(r.headers, 할당량자리(conn));
     // 다듬느라 이름을 고쳤으면 여기서 되돌린다. 밖에서는 그런 일이 있었는지
     // 모른 채로 원래 이름을 받는다.
-    if (r.ok) return 이름되돌리기(extractMessage(conn.kind, r.json), 맞춘것.되돌림);
+    if (r.ok) {
+      const 것 = 이름되돌리기(extractMessage(conn.kind, r.json), 맞춘것.되돌림);
+      const 자리 = 간자리(r.headers);
+      return 자리 ? { ...것, 간자리: 자리 } : 것;
+    }
     // 열쇠가 늙어서 막힌 것이면 새로 받고 한 번만 다시. 시도 수는 안 올린다 —
     // 서버가 막은 것이 아니라 우리 열쇠가 낡았던 것이라 물러설 까닭이 없다.
     if (열쇠다시받을까(conn, r.status, 열쇠다시받음)) {
@@ -1267,6 +1323,9 @@ export async function* chatStream(conn, opts) {
    */
   if (!acc.content && acc.거절글?.trim()) acc.content = acc.거절글.trim();
   delete acc.거절글;
+  // 흘려 받는 자리에서도 **어느 자리가 받았는지**를 같이 올린다 (위 간자리).
+  const 자리 = 간자리(r.headers ?? r.res?.headers);
+  if (자리) acc.간자리 = 자리;
   yield { type: 'done', message: 이름되돌리기(acc, 맞춘것.되돌림) };
 }
 

package/src/commands.js

@@ -2524,7 +2524,22 @@ function 배움명령(session, ctx, arg = '') {
     say(`  ${c.bold('이 폴더에서 돌려 본 명령')}`);
     for (const r of 명령.slice(0, 12)) {
       const 표 = r.no === 0 ? c.green('✓') : r.ok === 0 ? c.red('✗') : c.yellow('~');
-      say(`    ${표} ${pad(r.이름, 24)} ${c.gray(`됨 ${r.ok} · 안 됨 ${r.no}`)}`);
+      /*
+       * 언제 겪었는지와 **지금 실리는지**를 같이 적는다.
+       *
+       * 셈은 삭는다 (agent/신뢰도.js). 그래서 「됨 3 · 안 됨 0」 두 줄이 화면에
+       * 똑같이 보여도 한 줄은 프롬프트에 실리고 다른 줄은 안 실릴 수 있다.
+       * 특히 「안 된다」 는 스스로를 봉인하던 자리라, 그것이 지금 입을 다물고
+       * 있다는 사실이야말로 사람이 봐야 하는 것이다.
+       *
+       * 판정은 배움이 낸 것을 그대로 받는다 — 여기서 다시 계산하면 언젠가
+       * 한쪽만 고쳐지고, 그때부터 화면이 실제와 다른 말을 한다.
+       */
+      const 셈 = (n) => (Number.isFinite(n) ? String(Math.round(n * 10) / 10) : '?');
+      const 날 = Number.isFinite(r.나이) ? `${Math.floor(r.나이)}일 전` : '언제인지 모름';
+      const 말 = r.판정 === '모름' ? `${날} — 아직 안 싣습니다` : `${날} · 프롬프트에 실림`;
+      say(`    ${표} ${pad(r.이름, 24)} ${c.gray(`됨 ${셈(r.ok)} · 안 됨 ${셈(r.no)}`)}`
+        + `  ${c.gray(말)}`);
     }
     say('');
   }

package/src/i18n/en.js

@@ -474,6 +474,10 @@ export const en = {
   'run.stopping': 'stopping…',
   'run.errKept': 'What arrived before the failure was kept in the conversation — you can carry on from there.',
   'ev.capped': 'The answer was cut off at {한계} tokens — raise the cap with /out, or have files written in parts',
+  'ev.phaseMove': '{왜} — from here on this runs as {새}, not {옛}',
+  'ev.phaseWhyEdit': 'Started changing files',
+  'ev.phaseWhyTodo': 'The plan is written down',
+  'ev.phaseTools': 'More tools from here ({도구}) — the prefix gets written once more',
   'ev.cutoff': 'The server stopped the answer without saying it had finished — it may have been cut mid-way',
   'ev.stalled': 'Nothing arrived for {n}s, so the connection was dropped — this is what came through',
   'ev.nudgeMissed': 'It was about to finish leaving {n} of the things you asked for undone — pushed back once',

package/src/i18n/ja.js

@@ -432,6 +432,10 @@ export const ja = {
   'run.stopping': '止めています…',
   'run.errKept': 'ここまで届いた分は会話に残しました — このまま続けて話せます。',
   'ev.capped': '答えが {한계} トークンで切れました — /out で上限を上げるか、ファイルは分けて書かせてください',
+  'ev.phaseMove': '{왜} — ここからは {옛} ではなく {새} で進めます',
+  'ev.phaseWhyEdit': 'ファイルを変更し始めました',
+  'ev.phaseWhyTodo': 'やることを書き終えました',
+  'ev.phaseTools': 'ツールが増えました ({도구}) — 先頭を一度書き直します',
   'ev.cutoff': 'サーバーが終わったとも言わずに答えを止めました — 途中で切れた可能性があります',
   'ev.stalled': '{n}秒間なにも届かなかったので切りました — 届いたぶんだけ表示します',
   'ev.nudgeMissed': '頼んだこと {n} 件を残したまま終えようとしたので、一度押し戻しました',

package/src/i18n/ko.js

@@ -505,6 +505,10 @@ export const ko = {
    * `deel -p` 뒤 스크립트로 넘어가던 것이 그 탓이다.
    */
   'ev.capped': '답이 {한계} 토큰에서 잘렸습니다 — /out 으로 상한을 올리거나, 파일은 나눠 쓰게 하세요',
+  'ev.phaseMove': '{왜} — 여기서부터 {옛} 대신 {새} 로 갑니다',
+  'ev.phaseWhyEdit': '파일을 바꾸기 시작했습니다',
+  'ev.phaseWhyTodo': '할 일을 다 적었습니다',
+  'ev.phaseTools': '도구가 늘었습니다 ({도구}) — 앞머리를 한 번 다시 씁니다',
   'ev.cutoff': '서버가 끝났다는 말 없이 답을 멈췄습니다 — 중간에서 끊겼을 수 있습니다',
   'ev.stalled': '{n}초 동안 아무것도 안 와서 끊었습니다 — 받은 데까지만 보여 드립니다',
   'ev.nudgeMissed': '시킨 것 {n}가지를 빼놓고 끝내려고 해서 한 번 되밀었습니다',

package/src/i18n/zh.js

@@ -432,6 +432,10 @@ export const zh = {
   'run.stopping': '正在停止…',
   'run.errKept': '出错前收到的内容已经留在对话里 — 可以直接接着说。',
   'ev.capped': '回答在 {한계} 个 token 处被截断 — 用 /out 调高上限，或者让文件分次写',
+  'ev.phaseMove': '{왜} — 从这里开始按 {새} 而不是 {옛} 进行',
+  'ev.phaseWhyEdit': '开始修改文件了',
+  'ev.phaseWhyTodo': '要做的事已经列完了',
+  'ev.phaseTools': '工具变多了 ({도구}) — 前缀要重写一次',
   'ev.cutoff': '服务端没说结束就停下了 — 回答可能是中途断的',
   'ev.stalled': '{n} 秒没有任何数据，已断开 — 只显示已收到的部分',
   'ev.nudgeMissed': '还剩你交代的 {n} 件事没做就要收尾，已经推回去一次',

package/src/oneshot.js

@@ -38,7 +38,7 @@ import { probeCtx, 기본값 as CTX_DEFAULT } from './backend/ctxsize.js';
 import { 잠잠기본 } from './backend/http.js';
 import { 인증서설정 } from './backend/clientcert.js';
 import { route } from './agent/route.js';
-import { get as getWork } from './agent/modes.js';
+import { get as getWork, 보일이름 } from './agent/modes.js';
 import { 모두끝내기 as 일감모두끝내기, 일감인자 } from './tools/jobs.js';
 import { 첫이름 } from './tools/label.js';
 
@@ -612,6 +612,21 @@ export async function runOnce(opts = {}) {
           곁(`  ${c.cyan('⚙')} ${c.gray(옮긴말('loop.wire', { 무엇: ev.무엇 }))}`);
           break;
 
+        /*
+         * 종합 모드가 턴 도중에 단계를 옮겼다 (agent/단계.js).
+         *
+         * 한 방 실행에서 특히 남겨야 하는 줄이다. `deel -p` 는 잡·CI 에서 돌고
+         * 그 기록만 나중에 남는다 — 「계획만 내고 끝날 줄 알았는데 파일이
+         * 바뀌어 있다」 를 되짚을 자리가 여기 말고는 없다.
+         */
+        case '단계옮김':
+          곁(`  ${c.hcyan('→')} ${c.gray(옮긴말('ev.phaseMove', {
+            왜: 옮긴말(ev.왜 === '바꿈' ? 'ev.phaseWhyEdit' : 'ev.phaseWhyTodo'),
+            옛: 보일이름(ev.옛),
+            새: 보일이름(ev.새),
+          }))}`);
+          break;
+
         case 'folded':
           곁(`  ${c.cyan('◲')} ${c.gray(`오래된 도구 결과 ${ev.접은것}개를 접었습니다 (${ev.아낀토큰.toLocaleString()} 토큰을 비움)`)}`);
           break;

package/src/repl.js

@@ -2120,6 +2120,48 @@ export async function chatLoop(opts = {}) {
             break;
           }
 
+          /*
+           * 게이트웨이가 이번 요청을 **다른 자리로** 보냈다.
+           *
+           * 프리픽스 캐시는 자리마다 따로라, 이 줄이 뜬 턴은 우리가 보낸 것이
+           * 한 글자도 안 달라졌어도 앞머리를 통째로 다시 쓴다. 청구서에서
+           * 「왜 이 한 줄만 열 배냐」 로 보이던 것이 이것이다.
+           *
+           * 값은 안 찍는다 — 사내 배포 이름이나 리전 주소일 수 있다. 우리가
+           * 쓸 것은 「바뀌었다」 하나뿐이다 (backend/adapter.js 의 간자리).
+           */
+          case '자리바뀜':
+            say(`  ${c.hyellow('⇄')} ${c.gray('게이트웨이가 이번 요청을 다른 자리로 보냈습니다 — 앞머리를 캐시에서 못 읽고 다시 씁니다.')}`);
+            if (session.level !== '쉬움') {
+              say(`     ${c.gray('한 대화를 한 자리에 붙여 두는 설정이 게이트웨이 쪽에 있습니다 (세션 고정).')}`);
+            }
+            break;
+
+          /*
+           * 종합 모드가 **단계를 옮겼다** (agent/단계.js).
+           *
+           * 이 줄이 없으면 사람은 화면의 모드 표시가 턴 도중에 왜 바뀌었는지
+           * 모른다 — 자기가 누른 적도 없는데 `~디버그` 가 `~코드` 로 바뀌어
+           * 있으면 그건 알림이 아니라 버그처럼 보인다. 그래서 무엇을 보고
+           * 옮겼는지(`왜`) 를 같이 적는다.
+           *
+           * 도구가 늘어난 경우는 한 줄 더 붙인다. 규격이 도구 목록을 앞머리
+           * 맨 앞에 렌더하므로, 도구가 하나 늘면 그 턴은 앞머리를 캐시에서 못
+           * 읽고 다시 쓴다. 접기(folded)에서 그 대가를 적기 시작한 것과 같은
+           * 이유다 — 이득만 보이고 값은 며칠 뒤 청구서에서 보는 일이 없게.
+           */
+          case '단계옮김': {
+            const 왜 = 옮긴말(ev.왜 === '바꿈' ? 'ev.phaseWhyEdit' : 'ev.phaseWhyTodo');
+            say(`  ${c.hcyan('→')} ${c.gray(옮긴말('ev.phaseMove', { 왜, 옛: 보일이름(ev.옛), 새: 보일이름(ev.새) }))}`);
+            if ((ev.늘어난도구?.length ?? 0) > 0 && session.level !== '쉬움') {
+              const 보일수 = Math.min(5, ev.늘어난도구.length);
+              const 이름들 = ev.늘어난도구.slice(0, 보일수).join(' · ')
+                + (ev.늘어난도구.length > 보일수 ? ` +${ev.늘어난도구.length - 보일수}` : '');
+              say(`     ${c.gray(옮긴말('ev.phaseTools', { 도구: 이름들 }))}`);
+            }
+            break;
+          }
+
           case 'trimmed':
             say(`  ${c.gray(`(컨텍스트가 차서 오래된 대화 ${ev.dropped}개를 줄였습니다)`)}`);
             break;
@@ -2148,6 +2190,16 @@ export async function chatLoop(opts = {}) {
             clearThinking();
             say(`  ${c.cyan('◲')} ${c.gray(`오래된 도구 결과 ${ev.접은것}개를 접었습니다 — `)}`
               + `${c.white(ev.아낀토큰.toLocaleString())} ${c.gray('토큰을 비웠습니다. 대화는 그대로입니다.')}`);
+            /*
+             * 접기는 **값이 드는 일**이다 (agent/compact.js 의 손익분기).
+             *
+             * 이력 가운데 글을 바꿔치므로 그 자리 뒤가 전부 새 글이 되고,
+             * 캐시가 도는 연결에서는 싸게 읽히던 것을 비싸게 다시 쓴다.
+             * 여태 화면에는 이득만 나왔다 — 대가는 며칠 뒤 청구서에서 봤다.
+             */
+            if (ev.캐시다시씀) {
+              say(`     ${c.gray('이번 턴은 앞머리를 캐시에서 못 읽고 다시 씁니다 — 값과 지연이 한 번 튑니다.')}`);
+            }
             /*
              * 무엇을 접었는지 이름으로 보여 준다.
              *
@@ -2244,7 +2296,7 @@ export async function chatLoop(opts = {}) {
             clearThinking();
             if (streamed) { 답비우기(); say(''); streamed = false; }
             say(`  ${mark.warn} ${c.gray(`답이 ${c.white(ev.cap.toLocaleString())} 토큰에서 잘렸습니다`)}`
-              + `${ev.정한값 ? c.gray(' (직접 정하신 상한입니다)') : c.gray(' — 더 못 올리는 천장입니다')}`);
+              + `${ev.정한값 ? c.gray(' (직접 정하신 상한입니다)') : c.gray(' — 서버가 알려 준 값이 없어 선 기본 상한입니다')}`);
             say(`     ${c.gray('한 번에 더 길게 받으려면')} ${c.cyan('/out 32k')}${c.gray('. 파일을 쓰는 중이었다면 Append 로 나눠 쓰게 하세요.')}`);
             break;
 
@@ -2478,7 +2530,29 @@ export async function chatLoop(opts = {}) {
     if (tools) bits.push(`${옮긴말('scr.tools')} ${옮긴말('unit.calls', { n: tools })}`);
     const dIn = (session.usage.prompt || session.usage.in) - before.in;
     const dOut = session.usage.out - before.out;
+    const d읽음 = (session.usage.cacheRead ?? 0) - before.cacheRead;
+    const d씀 = (session.usage.cacheWrite ?? 0) - before.cacheWrite;
     if (dIn || dOut) bits.push(`↑${dIn.toLocaleString()} ↓${dOut.toLocaleString()}`);
+    /*
+     * ── ↑ 안을 가른다 ────────────────────────────────────────────────────
+     *
+     * `↑798,620` 한 줄만 보면 그게 다 정가로 나간 것처럼 읽힌다. 실제로는
+     * 그중 대부분이 **캐시에서 읽힌 것**이고, 우리가 재 본 자리에서 읽기는
+     * 쓰기의 1/12.5 였다. 즉 이 두 숫자는 자릿수가 다른 돈이다.
+     *
+     * 이걸 안 가르면 사람이 할 수 있는 판단이 없다. 가르면 바로 보인다 —
+     * 「새로 쓴 것」 이 크면 캐시가 끊긴 것이고(자리가 바뀌었거나 접었거나),
+     * 「캐시에서」 가 크면 대화가 길 뿐 값은 안 나가고 있는 것이다.
+     *
+     * 잰 값이 없으면 안 적는다. 캐시를 안 세어 주는 서버에서 0 을 적어 두면
+     * 「캐시가 하나도 안 걸렸다」 로 읽히는데, 그건 우리가 모르는 것이다.
+     */
+    if (d읽음 > 0 || d씀 > 0) {
+      const 몫 = [];
+      if (d읽음 > 0) 몫.push(`캐시에서 ${d읽음.toLocaleString()}`);
+      if (d씀 > 0) 몫.push(`새로 씀 ${d씀.toLocaleString()}`);
+      bits.push(`↑ 안: ${몫.join(' · ')}`);
+    }
     /*
      * 이번 턴에 나간 돈.
      *