deel-local-cli 1.17.3 → 1.17.5

package/src/agent/loop.js

@@ -12,7 +12,7 @@ import { 살린쓰기 } from './salvage.js';
 import { 배울것, 길이문제인가 } from '../backend/learn.js';
 import { compact, shouldCompact, shouldFold, foldToolResults, foldImages, 못박을것, 접힌파일열쇠 } from './compact.js';
 import { 걸음수, 하위걸음수, 요약길이 } from './budget.js';
-import { Session } from './session.js';
+import { Session, estimateTokens } from './session.js';
 import { 최대깊이, 하위모드, 하위요약 } from '../tools/task.js';
 import { 찾기 as 에이전트찾기, 할일합치기, 도구줄이기 } from './agents.js';
 import { 프로필찾기, 쓸수있나, 연결만들기, 알릴말, 목록보기 } from './models.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,46 @@ 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']);
+
+/*
+ * 잘린 답을 「생각을 줄여」 다시 부를 때 쓰는 두 값.
+ *
+ * 눈금 한 칸을 내리면 생각 예산은 대략 네 할이 준다(agent/effort.js 의 배분).
+ * 그렇게 되찾은 자리가 **1,024토큰은 돼야** 답이 한 문단이라도 더 나온다.
+ * 그 아래에서 다시 부르면 같은 자리에서 또 잘리는데, 그 한 번이 프리픽스
+ * 전체와 출력 상한 전체를 다시 낸다.
+ *
+ * 상한에 견준 비율(예전의 15%)로 안 재는 까닭: 같은 15% 가 16k 상한에서는
+ * 2,400토큰이고 2k 상한에서는 300토큰이다. 같은 잣대인 척하면서 실제로는
+ * 상한이 클수록 헐거워진다.
+ */
+export const 되찾을몫 = 0.4;
+export const 쓸모있는자리 = 1024;
 
 /**
  * 호출 목록을 '같이 돌려도 되는 덩어리' 로 자른다.
@@ -399,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)
@@ -425,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) ──
    *
@@ -457,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,
   });
@@ -477,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;    // 직전 단계에서 도구가 오류를 냈나 → 다음 판단은 세게
@@ -673,6 +793,15 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0,
   while (steps < maxSteps) {
     steps++;
 
+    /*
+     * 단계를 **부르기 전에** 다시 본다 (위 단계옮기기).
+     *
+     * 부른 뒤에 옮기면 이번 걸음은 옛 시킴말로 나가고, 옮긴 보람이 한 걸음
+     * 늦는다. 마흔 걸음짜리 턴에서 그 한 걸음이 파일 내용 한 벌씩이다.
+     */
+    const 옮김 = 단계옮기기();
+    if (옮김) yield 옮김;
+
     // 부르기 **전에** 자리를 본다. 왜 여기인지는 자리만들기() 머리말에.
     yield* 자리만들기();
     if (접다멈췄나) return;
@@ -803,6 +932,38 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0,
     try {
       yield* askModel(cap, level);
 
+      /*
+       * ── 게이트웨이가 이번 요청을 **다른 자리로** 보냈나 ─────────────────
+       *
+       * 같은 모델이 여러 자리에 올라가 있으면 프리픽스 캐시는 **자리마다**
+       * 따로다. 다음 요청이 다른 자리로 가는 순간, 우리가 보낸 것이 한 글자도
+       * 안 달라져도 캐시는 0% 가 되고 그 턴은 전액 다시 나간다.
+       *
+       * 여태 이건 화면에 안 나왔다. 사람이 볼 수 있는 것은 며칠 뒤 청구서의
+       * 튄 줄 하나뿐이고, 그 줄만 보면 원인이 우리 쪽인지 게이트웨이 쪽인지
+       * 가를 방법이 없다. 서버가 말해 줄 때는 그 자리에서 말한다.
+       *
+       * 서버가 안 알려 주면 **아무 말도 안 한다.** 모르는 것을 「안 바뀌었다」
+       * 로 적지 않는다 (backend/adapter.js 의 간자리).
+       */
+      if (msg?.간자리) {
+        if (session.간자리 && session.간자리 !== msg.간자리) {
+          /*
+           * **한 대화에 한 번만** 말한다.
+           *
+           * 세션 고정 없이 돌아가며 나눠 주는 게이트웨이에서는 이게 걸음마다
+           * 바뀐다 — 그리고 그건 사실이다. 다만 사실이라고 걸음마다 찍으면
+           * 그 줄은 곧 아무도 안 읽고, 그러면 정작 한 번만 튀는 자리도 같이
+           * 안 읽힌다. 한 번 말하면 사람이 알아야 할 것은 다 말한 셈이다.
+           */
+          if (!session.자리바뀐것을말했나) {
+            session.자리바뀐것을말했나 = true;
+            yield { type: '자리바뀜', 몇번째: steps };
+          }
+        }
+        session.간자리 = msg.간자리;
+      }
+
       /*
        * 대답이 잘렸다면 한 번은 다시 부른다.
        *
@@ -821,9 +982,68 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0,
        * 그 경우는 아래 '살려 쓰기' 가 받는다.
        */
       const full = Math.max(cap, fullCap(room));
-      const 낮춘생각 = level === 'off' || level === 'low' ? level : shiftLevel(level, -1);
+      /*
+       * `low` 에서도 한 칸 더 내려간다 — `off` 로.
+       *
+       * 여태 여기서 멈춰 있었다. 그런데 지금은 「생각이 실제로 자리를 먹었을
+       * 때만 다시 부른다」 이므로, low 인데 생각이 1,024토큰어치 자리를 먹은
+       * 판에서 다시 부르기를 거절하는 것은 앞뒤가 안 맞는다. 되찾을 자리가
+       * 있다고 재 놓고 안 되찾는 셈이다.
+       *
+       * 이 턴 하나만 끈다. 다음 걸음은 사람이 정한 눈금으로 되돌아간다.
+       */
+      const 낮춘생각 = level === 'off' ? level : shiftLevel(level, -1);
       let 마지막상한 = cap;
-      if (wasCut(msg) && (full > cap || 낮춘생각 !== level)) {
+      /*
+       * ── 생각을 줄이는 것이 **자리를 실제로 내는가** ──────────────────────
+       *
+       * 위 글이 「생각을 줄이면 예산이 실제로 남는다」 고 적어 뒀다. 맞는
+       * 말인데, **생각을 안 한 턴에는 안 맞는다.** 상한을 못 올리는 자리에서
+       * 이 조건은 `낮춘생각 !== level` 하나로 걸리므로, 생각이 0토큰이었어도
+       * 눈금이 medium 이기만 하면 다시 부른다. 그러면 같은 상한으로 같은 답을
+       * 다시 받고, 같은 자리에서 또 잘린다 — 바로 위 글이 「그건 그냥 낭비다」
+       * 라고 적어 둔 그 일이다.
+       *
+       * 실제로 그 값을 봤다. 16,384 에서 잘린 답을 같은 16,384 로 다시 받아
+       * 또 잘렸고, 그 한 번이 프리픽스 122K 와 출력 16K 를 통째로 다시 냈다.
+       *
+       * 그래서 **잰다.** 생각이 이번 답에서 자리를 얼마나 먹었는지 보고,
+       * 눈금 한 칸으로 되찾을 만한 몫일 때만 다시 부른다. 서버가 추론 토큰을
+       * 세어 주면 그 값을 쓰고, 안 세어 주면 흘러온 생각 글로 어림한다.
+       * 둘 다 없으면 생각은 자리를 안 먹은 것이다 — 없는 것을 있다고 치고
+       * 한 번 더 부르지 않는다.
+       */
+      /*
+       * 생각이 얼마나 먹었나를 **세 갈래로** 잰다. 하나만 보면 못 잰다.
+       *
+       *   1. 서버가 세어 준 추론 토큰      — 있으면 제일 정확하다
+       *   2. 흘러온 생각 글               — 세어 주지 않는 창구에서 쓴다
+       *   3. **낸 토큰에서 보이는 글을 뺀 것** — 위 둘이 다 없을 때
+       *
+       * 3번이 중요하다. 게이트웨이가 생각 블록을 지워서 넘기면 1도 2도 0이
+       * 되는데, 그때 「생각을 안 했다」 고 읽으면 정말로 생각에 예산을 다 쓴
+       * 턴에서 다시 부르기를 그만둔다. 관측이 없는 것과 사건이 없는 것은
+       * 다르다 — 그런데 **낸 토큰은 지워지지 않는다.** 답으로 나온 글이
+       * 짧은데 낸 토큰이 상한에 닿았다면, 그 차이가 곧 안 보이는 생각이다.
+       */
+      const 낸것 = Number(msg?.usage?.out ?? 0) || 0;
+      const 보인글 = estimateTokens(String(msg?.content ?? ''));
+      const 생각몫 = Math.max(
+        Number(msg?.usage?.reasoning ?? 0) || 0,
+        estimateTokens(String(msg?.thinking ?? '')),
+        낸것 > 0 ? 낸것 - 보인글 : 0,
+      );
+      /*
+       * 그 몫에서 **눈금 한 칸이 실제로 되찾아 줄 자리**가 쓸 만한가.
+       *
+       * 상한에 견준 비율로 재면 안 된다 — 같은 15% 가 16k 상한에서는 2,400
+       * 토큰이고 2k 상한에서는 300토큰이라, 같은 잣대인 척하면서 다르게 잰다.
+       * 되찾은 자리가 한 문단이라도 더 나올 만큼인지가 재야 할 것이고,
+       * 그건 절대량이다.
+       */
+      const 생각이자리를먹었나 = 생각몫 * 되찾을몫 >= 쓸모있는자리;
+      const 다시부를까 = wasCut(msg) && (full > cap || (낮춘생각 !== level && 생각이자리를먹었나));
+      if (다시부를까) {
         yield {
           type: 'retry',
           why: full > cap ? '대답이 상한에서 잘렸습니다' : '대답이 잘렸습니다 — 생각을 줄여 자리를 냅니다',
@@ -1711,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/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/agent//354/204/261/355/225/234/352/270/260/353/241/235.js

@@ -0,0 +1,66 @@
+/**
+ * 배운 것을 파일에서 읽어들일 때 **모양을 잰다.**
+ *
+ * ── 왜 따로 있나 ────────────────────────────────────────────────────────
+ *
+ * 신뢰도.js 는 「이 셈을 얼마나 믿을까」 를 정한다. 여기는 그 앞이다 —
+ * 「이게 애초에 우리가 적은 모양이 맞나」. 통계와 문지기는 다른 일이고,
+ * 섞어 두면 통계 문턱을 만질 때마다 문지기도 같이 흔들린다.
+ *
+ * ── 왜 문지기가 필요한가 ────────────────────────────────────────────────
+ *
+ * `배운것.json` 은 그냥 파일이다. 사람이 열어 고칠 수 있고, 다른 판이 다른
+ * 모양으로 적어 뒀을 수도 있고, 쓰다 만 채로 남았을 수도 있다.
+ *
+ * 그런데 그 안의 **열쇠는 시스템 프롬프트에 그대로 실린다** (evolve.js 의
+ * 요약 — 역따옴표로 감싸서 나간다). 그러니 이 파일을 읽는 자리가 곧 프롬프트로
+ * 들어가는 문이고, 문에는 자물쇠가 있어야 한다.
+ *
+ * 여기서 재는 것은 「참인가」 가 아니라 **「실려도 되는 꼴인가」** 다.
+ * 참인지는 신뢰도.js 가 정한다.
+ */
+
+const 열쇠최대 = 40;
+
+/*
+ * 무엇을 막을지가 아니라 **무엇만 받을지**를 적는다.
+ *
+ * 막을 것을 적으면 언젠가 빠뜨린다. 이 열쇠는 명령 이름 두 낱말이라 받을 것이
+ * 좁게 정해져 있다 — 글자·숫자·띄어쓰기와 경로에 쓰는 몇 개뿐이다.
+ *
+ * 역따옴표와 줄바꿈이 이 목록에 없는 것이 요점이다. 이 글자는 프롬프트에서
+ * 역따옴표로 감싸여 나가므로, 역따옴표 하나면 그 자리에서 틀이 깨지고
+ * 그다음 글이 명령 이름 행세를 한다.
+ */
+const 받을꼴 = /^[A-Za-z0-9 _.:@+/-]+$/;
+
+export function 성한열쇠인가(열쇠) {
+  const s = String(열쇠 ?? '');
+  if (!s || s.length > 열쇠최대) return false;
+  return 받을꼴.test(s);
+}
+
+export function 성한기록인가(r) {
+  if (!r || typeof r !== 'object') return false;
+  for (const 칸 of ['ok', 'no']) {
+    const v = Number(r[칸]);
+    if (!Number.isFinite(v) || v < 0) return false;
+  }
+  // 날짜가 없거나 못 읽으면 못 믿는다. 나이를 모르는 주장은 안 싣는다
+  // (신뢰도.js 의 며칠됐나 가 그때 무한대를 돌려준다).
+  return Number.isFinite(Date.parse(String(r.at ?? '')));
+}
+
+/**
+ * 표에서 모양이 안 맞는 것을 걷어낸 **사본**을 돌려준다.
+ *
+ * 고쳐서 쓰지 않는다. 모양이 안 맞는 것을 우리 짐작으로 고쳐 놓으면, 무엇이
+ * 어떻게 바뀌었는지가 또 아무 데도 안 남는다.
+ */
+export function 거른표(표) {
+  const out = {};
+  for (const [k, v] of Object.entries(표 ?? {})) {
+    if (성한열쇠인가(k) && 성한기록인가(v)) out[k] = v;
+  }
+  return out;
+}