deel-local-cli 1.17.4 → 1.17.6

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-7%2C937%20passing-1a7f37?logo=checkmarx&logoColor=white)](docs/ko/develop.md)
+[![tests](https://img.shields.io/badge/tests-8%2C011%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)
@@ -268,7 +268,7 @@ deel --offline
 무엇이 어디로 갈 수 있는지는 켤 때 화면 맨 위에 늘 적혀 있습니다.
 
 ```
- deel 1.17.4  ⌂ 이 안
+ deel 1.17.6  ⌂ 이 안
  보냄    이 컴퓨터 안 127.0.0.1:11434  ← 여기 말고는 어디로도 안 갑니다
 ```
 
@@ -1185,7 +1185,7 @@ deel stats                    # 이 폴더에서 실제로 무엇을 했나 (.de
 ## 개발
 
 ```bash
-npm test          전체 검증 (7,937항목 — 몇몇은 터미널에 따라 갈립니다)
+npm test          전체 검증 (8,011항목 — 몇몇은 터미널에 따라 갈립니다)
 npm run coverage  검사가 소스의 어디를 밟았는지
 npm run verify    반입·통신 검증만
 npm run bench     편집 성공률 측정
@@ -1254,6 +1254,8 @@ zip 은 진짜 `unzip` 으로, tar 는 진짜 `tar` 가 만든 것을 읽혀 교
 
 | 판 | 무엇이 바뀌었나 |
 |---|---|
+| [1.17.6](docs/ko/releases/1.17.md#1176) | 살아 있다는 신호만 오고 내용이 안 오면, 여태 영원히 기다렸습니다 |
+| [1.17.5](docs/ko/releases/1.17.md#1175) | 한 턴 안에서 단계가 일을 따라갑니다 — 그리고 읽기 도구 넷이 여태 줄을 서 있었습니다 |
 | [1.17.4](docs/ko/releases/1.17.md#1174) | 같은 요청을 한 번 더 보내던 자리들 — 그리고 배운 것이 스스로를 봉인하던 자리 |
 | [1.17.3](docs/ko/releases/1.17.md#1173) | 「같은 대화다」 를 적는 표준 이름이 없습니다 — 아는 이름을 다 답니다 |
 | [1.17.2](docs/ko/releases/1.17.md#1172) | 다른 눈으로 한 번 더 — 한글이 못 여는 hwpx · 이름 없이 나가던 요청 둘 |

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-7%2C937%20passing-1a7f37?logo=checkmarx&logoColor=white)](docs/en/develop.md)
+[![tests](https://img.shields.io/badge/tests-8%2C011%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)
@@ -339,7 +339,7 @@ deel --offline
 The destination is printed at the top of every session:
 
 ```
- deel 1.17.4  ⌂ inside
+ deel 1.17.6  ⌂ inside
  Sends to this machine 127.0.0.1:11434  ← nowhere else
 ```
 
@@ -1258,7 +1258,7 @@ Stored in `~/.deel/config.json`. A `.deel/config.json` in the project folder tak
 ## Development
 
 ```bash
-npm test          Full suite (7,937 checks; a few are TTY-dependent)
+npm test          Full suite (8,011 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
@@ -1313,6 +1313,8 @@ so one run tells you everything.
 
 | Version | What changed |
 |---|---|
+| [1.17.6](docs/en/releases/1.17.md#1176) | Only keep-alive and no content used to mean waiting forever |
+| [1.17.5](docs/en/releases/1.17.md#1175) | The phase now follows the work inside a turn — and four read tools had been queueing up |
 | [1.17.4](docs/en/releases/1.17.md#1174) | The places that sent the same request twice — and where what it learned sealed itself in |
 | [1.17.3](docs/en/releases/1.17.md#1173) | No standard name for "same conversation" — it sends every name it knows |
 | [1.17.2](docs/en/releases/1.17.md#1172) | A second pair of eyes — an hwpx Hancom cannot open · two requests going out unnamed |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deel-local-cli",
-  "version": "1.17.4",
+  "version": "1.17.6",
   "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

@@ -50,7 +50,7 @@ import { allowEndpoint, setOffline } from '../safety/network.js';
 import { 지금모드, 바깥인가, 나갈수있나 } from '../safety/runmode.js';
 import { 주소가리기 } from '../safety/secrets.js';
 import { probeCtx, 기본값 as CTX_DEFAULT } from '../backend/ctxsize.js';
-import { 잠잠기본 } from '../backend/http.js';
+import { 잠잠기본, 무소식기본 } from '../backend/http.js';
 import { 인증서설정 } from '../backend/clientcert.js';
 import { 다붙이기 } from '../backend/mcp.js';
 import { 배움 } from '../agent/evolve.js';
@@ -229,6 +229,8 @@ export async function acp(opts = {}) {
        * 모았다가 한 번에 주는 사내 게이트웨이면 이 값을 올린다.
        */
         잠잠: prof.잠잠 ?? prof.streamIdleMs ?? 잠잠기본,
+        // 바이트는 오는데 내용이 안 올 때의 전체 상한 (backend/http.js 의 무소식기본).
+        무소식: prof.무소식 ?? prof.streamNoNewsMs ?? 무소식기본,
     // 게이트웨이가 우리 인증서를 요구하면 (mTLS, backend/clientcert.js).
       // 파일 경로만 싣는다 — 알맹이는 요청 직전에 읽는다.
         인증서: 인증서설정(prof),

package/src/agent/loop.js

@@ -20,6 +20,9 @@ import { allowTemporarily, isOffline } from '../safety/network.js';
 import { 가리기, 훑기, 가렸다는말, 봤다는말, 가릴까 } from '../safety/secrets.js';
 import { 바깥인가 } from '../safety/runmode.js';
 import { get as workMode } from './modes.js';
+// 종합 모드에서 단계가 일을 따라간다 (agent/단계.js).
+import { 다음단계 } from './단계.js';
+import { 묻지말라했나, 손대라했나 } from './route.js';
 import { 지시말 } from '../i18n/index.js';
 import { 빠진것, 빠졌다는말 } from './asks.js';
 import { 환경속열쇠들 } from '../config.js';
@@ -102,14 +105,31 @@ function thinkFor(conn, level) {
   return level;
 }
 
-// 아무것도 안 바꾸는 도구들. 이것들만 동시에 돌린다.
-//
-// 왜 이것만인가:
-//   Read 세 개를 동시에 하는 것은 안전하다 — 서로 안 건드린다.
-//   Write·Edit 을 동시에 돌리면 같은 파일을 두 갈래로 고칠 수 있고,
-//   되돌리기 스냅샷 순서도 뒤엉킨다. Bash 는 무슨 짓을 할지 알 수 없다.
-//   그래서 '읽기만 하는 것' 이라고 확실한 도구만 묶는다.
-const 읽기전용 = new Set(['Read', 'Glob', 'Grep', 'Skill', 'WebFetch']);
+/*
+ * 아무것도 안 바꾸는 도구들. **이것들만** 동시에 돌린다.
+ *
+ * 왜 이것만인가:
+ *   Read 세 개를 동시에 하는 것은 안전하다 — 서로 안 건드린다.
+ *   Write·Edit 을 동시에 돌리면 같은 파일을 두 갈래로 고칠 수 있고,
+ *   되돌리기 스냅샷 순서도 뒤엉킨다. Bash 는 무슨 짓을 할지 알 수 없다.
+ *   그래서 '읽기만 하는 것' 이라고 확실한 도구만 묶는다.
+ *
+ * ── 그런데 이 목록이 modes.js 의 읽기 갈래보다 **짧았다** ───────────────
+ *
+ * modes.js 는 읽기만 하는 도구를 열 개로 세는데(Read·Outline·Glob·Grep·Def·
+ * Refs·WebFetch·Skill·Recall·Ask), 여기는 다섯 개만 알고 있었다. 나머지는
+ * 「안전한지 모르겠다」 가 아니라 그냥 **빠져 있었다.**
+ *
+ * 값이 큰 자리다. 시킴말이 남의 코드를 볼 때 **제일 먼저 부르라고 적어 둔
+ * 도구가 Outline** 이고(modes.js 의 읽는법), 그게 여태 한 개씩 돌았다.
+ * Def·Refs 는 언어 서버 왕복이라 기다리는 시간이 곧 사람이 기다리는 시간인데
+ * 그것도 한 줄로 섰다. 파일 여섯 개의 모양을 보는 데 여섯 번을 왕복했다.
+ *
+ * Ask 만 뺀다. 그건 사람에게 묻는 도구다 — 셋을 한꺼번에 물으면 화면에
+ * 물음 셋이 겹쳐 뜨고, 어느 답이 어느 물음의 것인지 사람이 못 가른다.
+ * 읽기 전용인 것은 맞지만 **사람의 차례를 쓰는 도구**라 줄을 세워야 한다.
+ */
+const 읽기전용 = new Set(['Read', 'Outline', 'Glob', 'Grep', 'Def', 'Refs', 'Recall', 'Skill', 'WebFetch']);
 
 /*
  * 잘린 답을 「생각을 줄여」 다시 부를 때 쓰는 두 값.
@@ -414,7 +434,7 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0,
    * 여전히 설계 모드라고 떠 있는 채로 파일이 바뀐다. task.js 의 하위모드() 가
    * 모드 쪽에서 한 겹 막고, 여기가 도구 쪽에서 한 겹 더 막는다.
    */
-  const tools = toolSchemas(session.도구제한 ?? null, {
+  let tools = toolSchemas(session.도구제한 ?? null, {
     hasSkills: (session.skills?.length ?? 0) > 0,
     web: session.web !== false && !isOffline(),   // 오프라인이면 웹 도구는 아예 안 보여 준다
     work: session.effectiveWork(),                // 작업 모드가 쓰는 것만 (modes.js)
@@ -440,17 +460,17 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0,
    * 이름은 그 표에 없어서 undefined 를 읽다 죽는다. MCP 는 이름 목록이 아니라
    * ctx.mcp 로 따로 넘어가므로 하위도 그 길로 똑같이 받는다.
    */
-  const 내도구 = tools.map((t) => t.function.name).filter((n) => !n.startsWith('mcp__'));
+  let 내도구 = tools.map((t) => t.function.name).filter((n) => !n.startsWith('mcp__'));
   /*
    * 깊이 상한. 부모(0) → 하위(1) → 하위의 하위(2) 까지다.
    *
    * 상한에 닿으면 목록에서 Task 를 뺀다. "더 쪼개지 마라" 고 부탁하지 않는다 —
    * 모델은 부탁을 잊고, 잊으면 하위가 하위를 끝없이 낳는다.
    */
-  const 자식도구 = 깊이 + 1 >= 최대깊이 ? 내도구.filter((n) => n !== 'Task') : 내도구;
+  let 자식도구 = 깊이 + 1 >= 최대깊이 ? 내도구.filter((n) => n !== 'Task') : 내도구;
   // 모드마다 생각의 배분과 걸음 수가 다르다. 사용자가 따로 정했으면 그걸 존중한다.
-  const 모드 = workMode(session.effectiveWork());
-  const effort = session.effortSet ? session.effort : (모드.effort ?? session.effort);
+  let 모드 = workMode(session.effectiveWork());
+  let effort = session.effortSet ? session.effort : (모드.effort ?? session.effort);
   /*
    * ── 강도는 **천장**이고, 이번 턴 값은 시킨 말이 정한다 (agent/effort.js) ──
    *
@@ -472,8 +492,8 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0,
    * 그래서 파일 열 개를 읽고 경합 조건을 짚어야 하는 일까지 low 로 돌았다 —
    * 생각 블록이 0자로 나가고, 답이 그만큼 얕았다.
    */
-  const 천장 = session.thinkSet ? session.think : 천장고르기(모드.think, session.think, userText);
-  const think = 자동강도(userText, 천장, {
+  let 천장 = session.thinkSet ? session.think : 천장고르기(모드.think, session.think, userText);
+  let think = 자동강도(userText, 천장, {
     대화크기: session.messages.length,
     켜짐: session.autoThink !== false,
   });
@@ -492,7 +512,92 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0,
    * 없다 — 8k 모델에는 너무 크고, 655k 모델은 여유가 96% 남았는데도 만들다
    * 만 채로 끊겼다. 사람이 직접 준 값이 있으면 그것이 먼저다.
    */
-  const maxSteps = session.stepsSet ? session.maxSteps : 걸음수(모드.id, conn.ctx);
+  let maxSteps = session.stepsSet ? session.maxSteps : 걸음수(모드.id, conn.ctx);
+  /*
+   * ── 단계가 일을 따라간다 (agent/단계.js) ────────────────────────────────
+   *
+   * 종합 모드는 한마디를 보고 단계를 고르는데, 그 고르기가 **턴이 시작할 때 딱
+   * 한 번** 돌았다. 마흔 걸음짜리 턴에서 일의 성격은 몇 번씩 바뀌는데, 시킴말은
+   * 첫 걸음의 것 그대로였다 — 원인을 다 찾고 고치는 중인데도 화면과 시킴말은
+   * 끝까지 「디버그」 였다.
+   *
+   * 여기서 세는 것은 **이미 일어난 일**이다. 모델에게 「지금 무슨 단계냐」 고
+   * 한 번 더 묻지 않는다. 그러면 걸음마다 왕복이 하나 늘고, 그 판단이 더
+   * 나을 까닭도 없다.
+   */
+  const 이번턴본것 = { 할일: false, 바꿈: false };
+  const 묻지말라 = 묻지말라했나(userText);
+  // 계획에서 넘어갈 때만 본다. 「묻지 마라」 는 **어떻게**의 말이고,
+  // 「고쳐라」 는 **무엇을**의 말이다. 범위를 정하는 것은 뒤엣것이다(단계.js).
+  const 손대라 = 손대라했나(userText);
+  const 종합인가 = session.work === 'auto';
+
+  /**
+   * 단계를 옮겨야 하면 옮기고, 옮겼으면 알린다.
+   *
+   * 시킴말은 저절로 따라온다 — session.wire() 가 effectiveWork() 를 매번 보고
+   * 짓기 때문이다(agent/session.js). 여기서 다시 지어야 하는 것은 **도구와
+   * 걸음 수와 생각의 배분**이다.
+   *
+   * @returns {object|null} 알릴 것이 있으면 이벤트, 없으면 null
+   */
+  const 단계옮기기 = () => {
+    const 갈곳 = 다음단계({ 지금: 모드.id, 종합인가, 본것: 이번턴본것, 묻지말라, 손대라 });
+    if (!갈곳) return null;
+    const 옛모드 = 모드.id;
+    session.routed = 갈곳;
+    모드 = workMode(갈곳);
+
+    /*
+     * 도구가 늘면 **앞머리가 바뀐다.** 규격이 tools 를 맨 앞에 렌더하므로,
+     * 도구 하나가 늘어도 그 턴의 캐시는 거기서 끊긴다. 값이 드는 일이라
+     * 조용히 하지 않는다 — 화면에 적는다.
+     */
+    const 옛도구 = new Set(내도구);
+    tools = toolSchemas(session.도구제한 ?? null, {
+      hasSkills: (session.skills?.length ?? 0) > 0,
+      web: session.web !== false && !isOffline(),
+      work: session.effectiveWork(),
+      mcp: ctx.mcp ?? null,
+      에이전트들: 깊이 + 1 >= 최대깊이 ? null : (ctx.에이전트들 ?? null),
+      lsp: session.lsp === true,
+      ctx: conn.ctx ?? null,
+      vision: conn.vision === true,
+    });
+    내도구 = tools.map((t) => t.function.name).filter((n) => !n.startsWith('mcp__'));
+    자식도구 = 깊이 + 1 >= 최대깊이 ? 내도구.filter((n) => n !== 'Task') : 내도구;
+    const 늘어난것 = 내도구.filter((n) => !옛도구.has(n));
+
+    // 생각의 배분도 그 단계 것으로. 사람이 직접 정했으면 그것이 먼저다.
+    if (!session.effortSet) effort = 모드.effort ?? session.effort;
+    if (!session.thinkSet) {
+      천장 = 천장고르기(모드.think, session.think, userText);
+      think = 자동강도(userText, 천장, {
+        대화크기: session.messages.length,
+        켜짐: session.autoThink !== false,
+      });
+    }
+    /*
+     * 걸음 수는 **늘리기만** 한다.
+     *
+     * 계획 모드의 상한은 코드 모드보다 작다. 넘어가면서 그 작은 값을 그대로
+     * 들고 가면 만들다 말고 끊긴다. 반대로 줄이면 이미 지난 걸음 수보다 작아져
+     * 그 자리에서 턴이 끝나 버릴 수도 있다 — 어느 쪽으로도 줄일 이유가 없다.
+     */
+    if (!session.stepsSet) maxSteps = Math.max(maxSteps, 걸음수(모드.id, conn.ctx));
+
+    return {
+      type: '단계옮김',
+      옛: 옛모드,
+      새: 갈곳,
+      // 화면 글이 아니라 **까닭 이름**을 낸다. 옮겨 적는 것은 화면의 몫이다
+      // (i18n/*.js 의 ev.phaseWhy*). 여기서 한국어를 내면 영어 화면에 섞인다.
+      왜: 이번턴본것.바꿈 ? '바꿈' : '할일',
+      늘어난도구: 늘어난것,
+      걸음: maxSteps,
+    };
+  };
+
   const attempted = new Set();   // 같은 변경성 명령을 두 번 실행하지 않기 위한 기록
   let steps = 0;
   let lastToolFailed = false;    // 직전 단계에서 도구가 오류를 냈나 → 다음 판단은 세게
@@ -688,6 +793,15 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0,
   while (steps < maxSteps) {
     steps++;
 
+    /*
+     * 단계를 **부르기 전에** 다시 본다 (위 단계옮기기).
+     *
+     * 부른 뒤에 옮기면 이번 걸음은 옛 시킴말로 나가고, 옮긴 보람이 한 걸음
+     * 늦는다. 마흔 걸음짜리 턴에서 그 한 걸음이 파일 내용 한 벌씩이다.
+     */
+    const 옮김 = 단계옮기기();
+    if (옮김) yield 옮김;
+
     // 부르기 **전에** 자리를 본다. 왜 여기인지는 자리만들기() 머리말에.
     yield* 자리만들기();
     if (접다멈췄나) return;
@@ -1817,6 +1931,18 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0,
         if (call.name === 'Read' && result.content) session.noteRead(call.args.file_path, result.content);
         // 실제로 파일이 바뀐 것만 적는다. 턴 끝에 이 목록을 디스크와 견준다.
         if (result.changed) 손댄파일.add(result.changed);
+        /*
+         * 단계도 이걸 본다 (agent/단계.js).
+         *
+         * 「바꾸기 시작했다」 는 조사가 끝났다는 뜻이다. 손댄파일 로 재도
+         * 되지만 그 집합은 하위 작업이 바꾼 것까지 담으므로, 이 턴에서
+         * **내가** 바꿨나를 따로 센다. 하위가 바꿨다고 부모의 단계가
+         * 넘어가면, 부모는 아직 조사 중인데 시킴말만 바뀐다.
+         */
+        if (result.changed || result.여럿?.some((f) => f.ok) || result.바뀐것들?.length) {
+          이번턴본것.바꿈 = true;
+        }
+        if (call.name === 'TodoWrite' && !result.error) 이번턴본것.할일 = true;
         // 한 번에 여러 개를 쓴 경우. changed 하나만 보면 나머지가 조용히 빠져서,
         // 턴 끝에 "만들어졌다" 고 확인해 주는 파일이 넷 중 하나만 나온다.
         for (const f of result.여럿 ?? []) if (f.ok && f.path) 손댄파일.add(f.path);

package/src/agent/models.js

@@ -34,7 +34,7 @@
  */
 import { load, activeProfile, resolveKey } from '../config.js';
 import { isLocalHost, isOffline } from '../safety/network.js';
-import { 잠잠기본 } from '../backend/http.js';
+import { 잠잠기본, 무소식기본 } from '../backend/http.js';
 import { 인증서설정 } from '../backend/clientcert.js';
 
 // 컨텍스트를 못 알아냈을 때 쓰는 값. repl.js 와 같은 값을 봐야 한다.
@@ -59,6 +59,8 @@ export function 연결만들기(prof, { ctx = null, maxTokens = null } = {}) {
     maxTokens: maxTokens ?? prof.maxTokens ?? null,
     streaming: prof.streaming ?? false,
     잠잠: prof.잠잠 ?? prof.streamIdleMs ?? 잠잠기본,
+    // 바이트는 오는데 내용이 안 올 때의 전체 상한 (backend/http.js 의 무소식기본).
+    무소식: prof.무소식 ?? prof.streamNoNewsMs ?? 무소식기본,
     인증서: 인증서설정(prof),
     tools: prof.tools ?? false,
     json: prof.json ?? false,

package/src/agent/modes.js

@@ -18,7 +18,10 @@
 // Ask 는 **모든 모드**에 있다(읽기 갈래에 둔 이유가 그것이다). 갈림길은
 // 어느 모드에서나 생기고, 물어볼 길이 없으면 모델은 글로 "알려주세요" 하고
 // 턴을 끝내 버린다 — 그러면 여태 조사한 것이 통째로 버려진다.
-const 읽기 = ['Read', 'Outline', 'Glob', 'Grep', 'Def', 'Refs', 'WebFetch', 'Skill', 'Recall', 'Ask'];
+// 내보낸다 — loop.js 의 동시에 돌릴 목록이 이것보다 짧아지면 검사가 잡게(test/parallel.test.js).
+// 두 곳에 같은 목록을 따로 적어 둔 탓에 다섯 개가 몇 달 동안 줄을 서서 돌았다.
+export const 읽기도구 = ['Read', 'Outline', 'Glob', 'Grep', 'Def', 'Refs', 'WebFetch', 'Skill', 'Recall', 'Ask'];
+const 읽기 = 읽기도구;
 // 계획을 적는 도구. 파일을 안 건드리므로 읽기 전용 모드에서도 준다.
 //
 // Remember 도 여기 있다. 기억은 사용자의 소스를 안 건드리고 .deel/memory.md

package/src/agent//353/213/250/352/263/204.js

@@ -0,0 +1,133 @@
+/**
+ * 종합 모드에서 **단계가 일을 따라간다.**
+ *
+ * ── 무엇이 문제였나 ─────────────────────────────────────────────────────
+ *
+ * 종합 모드는 한마디를 보고 알맞은 작업 모드를 고른다(agent/route.js). 그런데
+ * 그 고르기가 **턴이 시작할 때 딱 한 번** 돌았다. 고른 뒤로는 그 턴이 끝날
+ * 때까지 안 바뀐다.
+ *
+ * 짧은 한마디에는 맞는 방식인데, 긴 일에서는 그게 곧 고장이다. 한 턴이 마흔
+ * 걸음을 도는 동안 일의 성격은 몇 번씩 바뀐다 —
+ *
+ *   「왜 안 되는지 찾아서 고쳐줘」 → 디버그로 시작한다. 열두 걸음쯤에 원인을
+ *   찾는다. 그때부터 남은 스물여덟 걸음은 **고치는 일**인데, 시킴말은 여전히
+ *   「원인을 찾아라 · 고치기 전에 재현부터 하라」 고 말하고 있다.
+ *
+ * 화면에도 `~디버그` 가 끝까지 떠 있다. 사람이 「알아서 계획·디버그·코드로
+ * 넘어가 달라」 고 한 것이 이 자리다.
+ *
+ * ── 무엇으로 옮기나 ─────────────────────────────────────────────────────
+ *
+ * 모델에게 「지금 무슨 단계냐」 고 한 번 더 묻지 않는다. 그러면 걸음마다 왕복이
+ * 하나 늘고, 그 판단은 route.js 가 낱말로 하던 것보다 나을 것도 없다.
+ *
+ * **이미 일어난 일**로 옮긴다. 짐작이 아니라 잰 것이다.
+ *
+ *   할 일을 적었다 (TodoWrite 에 남은 일이 있다)   → 계획은 끝났다
+ *   파일을 실제로 바꿨다                            → 만드는 중이다
+ *
+ * ── 앞으로만 간다 ───────────────────────────────────────────────────────
+ *
+ * 되돌아가지 않는다. 한 걸음 읽었다고 다시 조사 단계로 내려가면 단계가
+ * 걸음마다 오르내리고, 그때마다 시킴말이 바뀐다 — 그건 캐시를 걸음마다
+ * 깨뜨리면서 모델에게는 갈피를 못 잡게 하는 짓이다.
+ *
+ * ── 사람이 고른 모드는 안 건드린다 ──────────────────────────────────────
+ *
+ * `/plan` 을 직접 친 사람에게 계획 모드는 **약속**이다. 여기서 옮기는 것은
+ * 라우터가 **짐작한** 단계뿐이다. 그 둘을 가르는 것은 `종합인가` 하나다.
+ */
+
+/*
+ * ── 단계가 넘어가는 표 ──────────────────────────────────────────────────
+ *
+ * 왼쪽에서 오른쪽으로만 간다. 여기 없는 모드는 안 옮긴다.
+ *
+ *   auto  → code   무슨 일인지 못 고른 채로 시작했는데 파일을 바꾸기 시작했다.
+ *                  그러면 지금 하는 일은 만드는 일이다.
+ *   debug → code   원인을 찾아 고치기 시작했다. 남은 걸음은 만드는 일이다.
+ *   plan  → code   계획을 다 적었다. 다만 이건 조건이 하나 더 붙는다 (아래).
+ *
+ * `architect` · `inspect` · `ask` 는 **안 옮긴다.**
+ *
+ * 셋 다 라우터가 「이 턴은 말로 답하는 턴」 이라고 본 자리다. 그리고 그렇게
+ * 보려면 사람의 말에 고치라는 말이 없어야 한다(route.js 의 손대라했나 가
+ * 그 셋을 후보에서 뺀다). 즉 **사람이 고쳐 달라고 안 했다.** 안 시킨 일을
+ * 스스로 시작하는 것은 단계가 나아가는 것이 아니라 시킨 범위를 넘는 것이다.
+ */
+const 넘어갈곳 = {
+  auto: 'code',
+  debug: 'code',
+  plan: 'code',
+};
+
+/*
+ * `plan` 만 조건이 더 붙는다. **두 개다.**
+ *
+ * 계획 모드는 파일을 바꾸는 도구가 없다. 그래서 여기서 넘어가면 도구가
+ * 늘어나고, 늘어난 도구는 앞머리를 바꾸므로 캐시가 한 번 끊긴다. 값이 드는
+ * 일이라 아무 때나 하면 안 된다. 그보다 더 큰 것은, 이 자리가 **시킨 범위를
+ * 넘을 수 있는 유일한 자리**라는 점이다 — 다른 단계는 이미 파일을 바꿀 수
+ * 있는 자리에서 시작하지만 계획은 아니다.
+ *
+ *   (1) 사람이 「묻지 말고 끝까지」 라고 적어 뒀어야 한다.
+ *
+ *       「계획해서 만들어줘」 는 이미 다른 길이 있다 — 계획을 내고 승인을
+ *       받아 이어서 하는 길이다(route.js 의 겹친요청). 그 길이 있는데 여기서
+ *       몰래 넘어가면 사람이 보자고 한 계획을 못 보고 파일부터 바뀐다.
+ *       그런데 겹침 길은 「묻지 말라」 고 적은 사람에게는 꺼져 있다. 그 사람
+ *       에게는 승인 창이 값이 아니라 손해이기 때문이다. 그러면 계획만 내고
+ *       멈추는 턴이 남는다 — 시킨 일의 절반이다. 그 나머지 절반이 이 자리다.
+ *
+ *   (2) 그리고 사람이 **고쳐 달라고 했어야 한다** (route.js 의 손대라했나).
+ *
+ *       (1)만으로는 구멍이 하나 남는다. 「계획만 세워줘. 알아서 진행해」 처럼
+ *       **계획만 원하면서 묻지 말라고도 적은** 말이 있다. 그 사람은 승인 창이
+ *       싫다고 했을 뿐 파일을 고쳐 달라고 한 적이 없다. 그런데 (1)만 보면
+ *       할 일을 적는 순간 코드로 넘어가 파일이 바뀐다.
+ *
+ *       두 말은 뜻이 다르다 — 「묻지 마라」 는 **어떻게** 하라는 말이고,
+ *       「고쳐라」 는 **무엇을** 하라는 말이다. 범위를 정하는 것은 뒤엣것이다.
+ *       그래서 둘 다 있어야 넘어간다.
+ */
+const 말에있어야하는것 = {
+  plan: (말) => 말.묻지말라 === true && 말.손대라 === true,
+};
+
+/** 이 단계에서 다음으로 넘어가려면 무엇이 일어나야 하나. */
+const 신호 = {
+  // 파일을 바꾸기 전에는 아직 조사 중이다.
+  auto: (본것) => 본것?.바꿈 === true,
+  debug: (본것) => 본것?.바꿈 === true,
+  // 계획은 파일을 못 바꾼다. 그러니 「바꿨나」 로는 영영 안 넘어간다.
+  // 계획이 끝났다는 신호는 **적어 둔 할 일**이다.
+  plan: (본것) => 본것?.할일 === true,
+};
+
+/**
+ * 지금 걸음에서 어느 단계여야 하나.
+ *
+ * @param {object} 것
+ * @param {string} 것.지금      지금 단계 (작업 모드 id)
+ * @param {boolean} 것.종합인가 사람이 고른 모드가 아니라 종합 모드인가
+ * @param {object} 것.본것      { 할일: boolean, 바꿈: boolean } — 이번 턴에 일어난 일
+ * @param {boolean} 것.묻지말라 사람이 「묻지 말고 끝까지」 라고 적어 뒀나
+ * @param {boolean} 것.손대라   사람이 고쳐 달라고 했나 (route.js 의 손대라했나)
+ * @returns {string|null} 옮길 곳. 안 옮기면 null.
+ */
+export function 다음단계({ 지금, 종합인가, 본것, 묻지말라 = false, 손대라 = false }) {
+  // 사람이 고른 모드는 약속이다. 짐작만 옮긴다.
+  if (!종합인가) return null;
+  const 갈곳 = 넘어갈곳[지금];
+  if (!갈곳 || 갈곳 === 지금) return null;
+  const 잠금 = 말에있어야하는것[지금];
+  if (잠금 && !잠금({ 묻지말라, 손대라 })) return null;
+  return 신호[지금]?.(본것) ? 갈곳 : null;
+}
+
+/** 넘어가면서 도구가 늘어나나 — 늘면 앞머리를 다시 쓰게 되므로 사람에게 말해야 한다. */
+export function 도구가늘어나나(옛모드, 새모드, 도구가져오기) {
+  const 옛 = new Set(도구가져오기(옛모드));
+  return 도구가져오기(새모드).some((t) => !옛.has(t));
+}

package/src/backend/adapter.js

@@ -2,7 +2,10 @@
 // 진단(probe)과 에이전트 루프가 같은 함수를 쓴다.
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { req, headersFor, serverMessage, Aborted, 잠잠기본, 초로 } from './http.js';
+import {
+  req, headersFor, serverMessage, Aborted, 잠잠기본, 초로,
+  무소식기본, 무소식알림기본, 소식없음오류,
+} from './http.js';
 import { 할당량기억, 미리기다릴까, 마지막할당량, 할당량자리 } from './quota.js';
 import { 열쇠 as 열쇠받아오기, 쓸수있나 } from '../safety/authcmd.js';
 import { 말 } from '../i18n/index.js';
@@ -1223,6 +1226,32 @@ export async function* chatStream(conn, opts) {
   const dec = new TextDecoder();
   let buf = '';
 
+  /*
+   * ── 바이트 말고 **소식**을 잰다 (backend/http.js 의 무소식기본) ─────────
+   *
+   * 잠잠 시계는 조각이 오면 되감긴다. 그런데 keep-alive(`: ping`)와 빈 delta
+   * 는 조각이면서 내용이 없다 — 되감기기만 하고 화면에는 아무것도 안 남는다.
+   * 그 둘만 오는 동안은 천장이 사라진다.
+   *
+   * 여기서 세는 것은 **acc 가 자랐나** 다. 이벤트 수가 아니다 — 도구 인자는
+   * 글자로 쪼개져 와서 acc._raw 에만 쌓이고 이벤트를 안 낸다(mergeDeltaCalls).
+   * 이벤트만 세면 도구 호출을 길게 쓰는 중인 정상 흐름을 우리가 끊는다.
+   */
+  const 자란만큼 = () =>
+    acc.content.length
+    + acc.thinking.length
+    + (acc.거절글?.length ?? 0)
+    + (acc._raw?.reduce(
+      (n, c) => n + 1 + (c?.name?.length ?? 0) + (c?.args?.length ?? 0), 0) ?? 0)
+    + (acc.usage?.잰것 ? 1 : 0)
+    + (acc.stopped ? 1 : 0);
+
+  const 무소식 = conn.무소식 ?? 무소식기본;
+  const 무소식알림 = Math.min(conn.무소식알림 ?? 무소식알림기본, 무소식 > 0 ? 무소식 / 2 : Infinity);
+  let 마지막소식 = Date.now();
+  let 본만큼 = 자란만큼();
+  let 알렸나 = false;
+
   /*
    * 한 줄을 읽는 규칙. 루프 안에서도, **끝난 뒤에도** 같은 것을 쓴다.
    *
@@ -1292,6 +1321,51 @@ export async function* chatStream(conn, opts) {
       yield* 한줄(꼬리);
       break;
     }
+
+    /*
+     * 이번 조각으로 acc 가 자랐나. 자랐으면 시계를 되감고, 안 자랐으면 얼마나
+     * 오래 그랬는지 본다.
+     *
+     * 알림이 먼저고 끊기는 나중이다. 순서가 중요하다 — 끊기부터 만들면
+     * 「원래 이런 게이트웨이」 를 우리가 죽이면서 그 사실을 아무도 못 본다.
+     */
+    const 이번만큼 = 자란만큼();
+    if (이번만큼 !== 본만큼) {
+      본만큼 = 이번만큼;
+      마지막소식 = Date.now();
+      알렸나 = false;
+    } else {
+      const 흐른 = Date.now() - 마지막소식;
+      if (무소식 > 0 && 흐른 >= 무소식) {
+        /*
+         * 끊을 때는 **소켓도 같이 닫는다.**
+         *
+         * 안 닫으면 게이트웨이는 우리가 간 줄도 모르고 핑을 계속 보낸다. 그
+         * 연결이 프로그램이 끝날 때까지 남아서 겪을 때마다 하나씩 쌓인다.
+         * 잠잠 시계는 제 손으로 소켓을 끊고 있다(http.js 의 끊기) — 여기만
+         * 안 하면 같은 일을 반쪽만 하는 것이다. 검사에서 프로세스가 안 끝나서
+         * 잡혔다.
+         */
+        try { await reader.cancel(); } catch { /* 이미 닫혔으면 그만 */ }
+        /*
+         * 여기까지 받은 글은 **버리지 않는다.** 세 문단을 받아 놓고 그 뒤로
+         * keep-alive 만 오는 자리가 있다 — 통째로 던지면 사람은 아무것도 못
+         * 보고 같은 것을 다시 시킨다. 잠잠 시계가 하는 것과 같은 규칙이다.
+         *
+         * 한 글자도 못 받았으면 그건 그냥 실패다. 빈 답을 답이라고 부르지 않는다.
+         */
+        if (acc.content || acc.thinking || acc.toolCalls.length) {
+          acc.stopped = 흐름멎음;
+          acc.멎은초 = 초로(흐른);
+          break;
+        }
+        throw 소식없음오류(무소식);
+      }
+      if (!알렸나 && 흐른 >= 무소식알림) {
+        알렸나 = true;
+        yield { type: '소식없음', 초: 초로(흐른), 상한초: 무소식 > 0 ? 초로(무소식) : null };
+      }
+    }
   }
   /*
    * ── 끝을 안 알려 주고 끊긴 것은 '끝난 것' 이 아니다 ──────────────────────

package/src/backend/http.js

@@ -232,6 +232,57 @@ export function 멎음오류(잠잠) {
   );
 }
 
+/*
+ * ── 위 시계가 못 잡는 자리 ──────────────────────────────────────────────
+ *
+ * 잠잠 시계는 **바이트**를 잰다. 조각이 하나 오면 되감긴다(위 잠잠감시).
+ * 그런데 SSE 에는 내용이 없는 조각이 있다 —
+ *
+ *   `: ping`                                 규격이 정한 주석 줄. keep-alive.
+ *   `data: {"choices":[{"delta":{}}]}`       빈 delta. 살아 있다는 말만 한다.
+ *
+ * 둘 다 **바이트**다. 그래서 잠잠 시계를 되감는다. 그리고 둘 다 화면에
+ * 아무것도 안 남긴다 — 앞엣것은 JSON 이 아니라 파싱에서 버려지고, 뒤엣것은
+ * absorb 가 낼 이벤트가 없다.
+ *
+ * 머리말까지 재던 시계(timeout)는 머리말이 오는 순간 **꺼진다**(위 노드로·
+ * 직접흘려의 시계끄기). 그러면 남는 천장이 하나도 없다.
+ *
+ * 실제로 그렇게 됐다. 게이트웨이 뒤에서 15분 넘게, 오류도 없이, 스피너만
+ * 돌았다. 이벤트 루프는 멀쩡했다 — 기다릴 이유가 없어지는 순간이 영영 안
+ * 왔을 뿐이다.
+ *
+ * 그래서 시계를 하나 더 둔다. 바이트가 아니라 **소식**을 잰다. 흔히
+ * Logical Idle Timeout 이라 부르고, 그 위에 전체 상한(Total Timeout)을
+ * 같이 씌우는 것이 보통이다. 여기서는 둘을 한 쌍으로 둔다.
+ */
+
+/**
+ * 소식 없이 얼마나 두고 볼까 — **알리는** 자리.
+ *
+ * 끊지 않는다. 한 줄 적을 뿐이다. 추론을 감추는 게이트웨이는 원래 이 모양으로
+ * 정상 동작한다 — 상위 모델이 생각하는 동안 keep-alive 만 흘린다. 그걸
+ * 끊어 버리면 지금 잘 도는 연결을 우리가 죽이는 것이다.
+ *
+ * 90초로 잡는다. 사람이 「멈춘 건가」 를 의심하기 시작하는 자리다.
+ */
+export const 무소식알림기본 = 90000;
+
+/**
+ * 그래도 이건 넘기지 않는다 — **전체 상한**.
+ *
+ * 무한은 어떤 경우에도 맞는 답이 아니다. 10분은 어떤 모델의 첫 글자보다도
+ * 한참 뒤다. 0 으로 두면 이 상한을 안 쓴다(프로필의 `무소식`).
+ */
+export const 무소식기본 = 600000;
+
+export function 소식없음오류(무소식) {
+  return Object.assign(
+    new Error(`${초로(무소식)}초 동안 살아 있다는 신호만 오고 내용이 안 왔습니다`),
+    { name: 'NoNewsError', code: 'NONEWS', 무소식 },
+  );
+}
+
 /**
  * 밀리초를 사람에게 보여 줄 초로.
  *

package/src/commands.js

@@ -30,7 +30,7 @@ import { 말, 말 as 옮긴말, 언어, 언어들, 언어정하기, 언어고르
 import { 프로필찾기, 쓸수있나, 연결만들기, 알릴말, 목록보기 } from './agent/models.js';
 import { allowTemporarily } from './safety/network.js';
 import { chat, 규격이름, 더할머리 } from './backend/adapter.js';
-import { 잠잠기본 } from './backend/http.js';
+import { 잠잠기본, 무소식기본 } from './backend/http.js';
 import { 인증서설정, 인증서말 } from './backend/clientcert.js';
 import { 알림채움 } from './backend/retry.js';
 import { 프록시고르기, 프록시설정 } from './backend/proxy.js';
@@ -2944,6 +2944,8 @@ function 연결적용(session, p, ctx = null) {
     streaming: p.streaming, tools: p.tools, json: p.json, think: p.think,
     // 프로필마다 다를 수 있다 — 사내 게이트웨이는 잠잠 상한이 크고 로컬은 작다.
     잠잠: p.잠잠 ?? p.streamIdleMs ?? 잠잠기본,
+    // 바이트는 오는데 내용이 안 올 때의 전체 상한 (backend/http.js 의 무소식기본).
+    무소식: p.무소식 ?? p.streamNoNewsMs ?? 무소식기본,
     // 프로필마다 인증서가 다르다. 안 갈아 끼우면 옛 프로필의 신원으로 붙는다.
     인증서: 인증서설정(p),
     /*

package/src/i18n/en.js

@@ -474,6 +474,12 @@ 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.noNews': 'Only keep-alive for {초}s, no content yet — the gateway may still be waiting on the upstream model',
+  'ev.noNewsCap': 'Giving up at {상한초}s. If this is genuinely slow, raise streamNoNewsMs in the profile',
   '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,12 @@ export const ja = {
   'run.stopping': '止めています…',
   'run.errKept': 'ここまで届いた分は会話に残しました — このまま続けて話せます。',
   'ev.capped': '答えが {한계} トークンで切れました — /out で上限を上げるか、ファイルは分けて書かせてください',
+  'ev.phaseMove': '{왜} — ここからは {옛} ではなく {새} で進めます',
+  'ev.phaseWhyEdit': 'ファイルを変更し始めました',
+  'ev.phaseWhyTodo': 'やることを書き終えました',
+  'ev.phaseTools': 'ツールが増えました ({도구}) — 先頭を一度書き直します',
+  'ev.noNews': '{초}秒間生存信号だけで内容が来ていません — ゲートウェイが上位モデルを待っている可能性があります',
+  'ev.noNewsCap': '{상한초}秒で打ち切ります。本当に遅い場合は設定の streamNoNewsMs を上げてください',
   'ev.cutoff': 'サーバーが終わったとも言わずに答えを止めました — 途中で切れた可能性があります',
   'ev.stalled': '{n}秒間なにも届かなかったので切りました — 届いたぶんだけ表示します',
   'ev.nudgeMissed': '頼んだこと {n} 件を残したまま終えようとしたので、一度押し戻しました',

package/src/i18n/ko.js

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

package/src/i18n/zh.js

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

package/src/oneshot.js

@@ -35,10 +35,10 @@ import { allowEndpoint, setOffline } from './safety/network.js';
 import { 지금모드, 바깥인가, 나갈수있나 } from './safety/runmode.js';
 import { 주소가리기 } from './safety/secrets.js';
 import { probeCtx, 기본값 as CTX_DEFAULT } from './backend/ctxsize.js';
-import { 잠잠기본 } from './backend/http.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';
 
@@ -274,6 +274,8 @@ export async function runOnce(opts = {}) {
      * 모았다가 한 번에 주는 사내 게이트웨이면 이 값을 올린다.
      */
     잠잠: prof.잠잠 ?? prof.streamIdleMs ?? 잠잠기본,
+    // 바이트는 오는데 내용이 안 올 때의 전체 상한 (backend/http.js 의 무소식기본).
+    무소식: prof.무소식 ?? prof.streamNoNewsMs ?? 무소식기본,
     // 게이트웨이가 우리 인증서를 요구하면 (mTLS, backend/clientcert.js).
     // 파일 경로만 싣는다 — 알맹이는 요청 직전에 읽는다.
     인증서: 인증서설정(prof),
@@ -612,6 +614,27 @@ 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;
+
+        // 바이트만 오고 내용이 안 오는 자리. 배치 기록에 남아야 「그날 밤 왜
+        // 12분이 걸렸나」 를 나중에 읽을 수 있다.
+        case '소식없음':
+          곁(`  ${c.yellow('⧗')} ${c.gray(옮긴말('ev.noNews', { 초: ev.초 }))}`);
+          break;
+
         case 'folded':
           곁(`  ${c.cyan('◲')} ${c.gray(`오래된 도구 결과 ${ev.접은것}개를 접었습니다 (${ev.아낀토큰.toLocaleString()} 토큰을 비움)`)}`);
           break;

package/src/repl.js

@@ -48,7 +48,7 @@ import { 접을까 as 붙임접을까, 표만들기 as 붙임표, 펼치기 as
 import { 고른것풀기, 계획답풀기 } from './ui/pick.js';
 import { 이력지킴이 } from './ui/histline.js';
 import { probeCtx, 기본값 as CTX_DEFAULT } from './backend/ctxsize.js';
-import { 잠잠기본 } from './backend/http.js';
+import { 잠잠기본, 무소식기본 } from './backend/http.js';
 import { 인증서설정 } from './backend/clientcert.js';
 import { renderDiff, shortStat } from './ui/diff.js';
 import { expand as expandMentions } from './agent/mention.js';
@@ -249,6 +249,8 @@ export async function chatLoop(opts = {}) {
      * 모았다가 한 번에 주는 사내 게이트웨이면 이 값을 올린다.
      */
     잠잠: prof.잠잠 ?? prof.streamIdleMs ?? 잠잠기본,
+    // 바이트는 오는데 내용이 안 올 때의 전체 상한 (backend/http.js 의 무소식기본).
+    무소식: prof.무소식 ?? prof.streamNoNewsMs ?? 무소식기본,
     // 게이트웨이가 우리 인증서를 요구하면 (mTLS, backend/clientcert.js).
     // 파일 경로만 싣는다 — 알맹이는 요청 직전에 읽는다.
     인증서: 인증서설정(prof),
@@ -2137,6 +2139,48 @@ export async function chatLoop(opts = {}) {
             }
             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;
+          }
+
+          /*
+           * 바이트는 오는데 **내용이 안 온다** (backend/adapter.js).
+           *
+           * 여기가 없으면 화면에는 스피너만 돈다. 실제로 15분 넘게 그랬고,
+           * 사람은 프로그램이 멎은 줄 알았다. 멎은 게 아니라 기다릴 이유가
+           * 없어지는 순간이 안 온 것이라, 그걸 그대로 적어 준다.
+           *
+           * 끊지 않는다는 것도 같이 말한다 — 추론을 감추는 게이트웨이는 원래
+           * 이 모양으로 정상 동작하므로, 사람이 기다릴지 ESC 할지 고르게 한다.
+           */
+          case '소식없음':
+            say(`  ${c.yellow('⧗')} ${c.gray(옮긴말('ev.noNews', { 초: ev.초 }))}`);
+            if (ev.상한초) {
+              say(`     ${c.gray(옮긴말('ev.noNewsCap', { 상한초: ev.상한초 }))}`);
+            }
+            break;
+
           case 'trimmed':
             say(`  ${c.gray(`(컨텍스트가 차서 오래된 대화 ${ev.dropped}개를 줄였습니다)`)}`);
             break;