deel-local-cli 1.6.2 → 1.6.3

package/README.md

@@ -989,6 +989,7 @@ zip 은 진짜 `unzip` 으로, tar 는 진짜 `tar` 가 만든 것을 읽혀 교
 
 | 판 | 무엇이 바뀌었나 |
 |---|---|
+| **[1.6.3](docs/ko/releases.md#163)** | 일이 되고 있는데 헛돈다고 끊던 자리 — 배열로 옮기면 무엇이 움직였는지가 사라졌다 |
 | **[1.6.2](docs/ko/releases.md#162)** | 누르면 멈추고, 시킨 대로 하고, 안 끊긴다 — ESC · 되묻기 · 요청 누락 · 붙여넣기 접기 · 끊긴 자리 잇기 |
 | **[1.6.1](docs/ko/releases.md#161)** | 헛도는 턴을 만들던 자리들 — 울타리가 `/dev/null` 까지 막던 것 · 옷 문서를 못 읽던 것 · 파일에서 그림이 사라지던 것 |
 | **[1.6.0](docs/ko/releases.md#160)** | 사내망에서 안 되던 것들 — 프록시 · 429 · 윈도우 셸 · 5만 개 저장소 · PDF · 캡처 붙여넣기 · 에디터 이어하기 |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deel-local-cli",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "description": "로컬 모델·사내 게이트웨이 전용 코딩 에이전트 CLI — 외부 의존성 0개 / Zero-dependency coding agent CLI for local LLMs and private gateways",
   "type": "module",
   "license": "MIT",

package/src/agent/loop.js

@@ -247,6 +247,13 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0,
    * 결과가 달라졌으면 그대로 싣는다. 고치고 나서 다시 읽는 것은 정상이다.
    */
   const 부른것 = new Map();
+  /*
+   * 그 부름을 마지막으로 봤을 때, 이 턴이 파일을 몇 개나 손댔었나.
+   *
+   * 되풀이를 셀 때 이 값과 견준다. 그 사이에 파일이 늘었으면 일이 되고
+   * 있는 것이라 되풀이 셈을 처음부터 다시 센다 — 까닭은 세는 자리에.
+   */
+  const 반복진척 = new Map();
   /*
    * 서명은 한 모양으로 맞춰 놓고 견준다 (NFC).
    *
@@ -1139,6 +1146,14 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0,
         // 한 번에 여러 개를 쓴 경우. changed 하나만 보면 나머지가 조용히 빠져서,
         // 턴 끝에 "만들어졌다" 고 확인해 주는 파일이 넷 중 하나만 나온다.
         for (const f of result.여럿 ?? []) if (f.ok && f.path) 손댄파일.add(f.path);
+        /*
+         * 옮긴 것도 손댄 것이다.
+         *
+         * Move 는 파일을 고치는 게 아니라 자리를 바꾸므로 changed·여럿 이
+         * 아니라 바뀐것들 로 온다. 이걸 안 세면 스물두 개를 옮겨 놓고도
+         * 이 턴은 "아무것도 안 했다" 고 알고 있게 된다.
+         */
+        for (const f of result.바뀐것들 ?? []) 손댄파일.add(f);
 
         // 앞에서 똑같이 부른 적이 있고 결과도 같으면, 결과를 다시 싣지 않는다.
         let 실을것 = 실을글(result);
@@ -1150,13 +1165,40 @@ export async function* run(session, ctx, userText, { signal = null, 깊이 = 0,
           const 앞것 = 부른것.get(서명);
           if (앞것 !== undefined && 앞것 === 같은꼴) {
             session.본것?.본것('되풀이');
-            const n = (막힘.get(`반복|${서명}`) ?? 0) + 1;
+            /*
+             * ── 되풀이와 「일하면서 장부를 다시 쓴 것」 은 다르다 ──────────
+             *
+             * 「폴더 정리 해줘」 에서 이 자리가 사람의 턴을 죽였다. 화면은
+             * 이랬다.
+             *
+             *   Move 7개 옮김 → TodoWrite → Move 22개 옮김 → TodoWrite
+             *   → ⊘ 같은 자리에서 헛돌고 있어 멈췄습니다
+             *
+             * 파일은 스물아홉 개가 실제로 움직이고 있었다. 헛돈 것은 할 일
+             * 목록을 같은 값으로 다시 쓴 것뿐이다. 그런데 세는 자리는 그
+             * 사이에 무슨 일이 있었는지를 안 봤다 — 같은 부름이 세 번이면
+             * 그것으로 끝이었다.
+             *
+             * 이 파일 머리말에 스스로 적어 둔 원칙이 있다: 헛도는 것은
+             * '잘 되고 있는 긴 작업' 과 구분해야 한다. 그 구분을 여기에
+             * 넣는다 — **그 사이에 파일이 진짜로 바뀌었으면 처음부터 다시
+             * 센다.** 아무것도 안 바뀐 채로 되풀이하는 것만 헛도는 것이다.
+             *
+             * 이러면 끝없이 돌 수 있지 않나: 아니다. 손댄파일 은 서로 다른
+             * 파일만 세므로, 같은 자리를 맴돌면 안 늘어난다. 늘어난다는 것은
+             * 매번 새 파일이 움직였다는 뜻이고, 그건 일이 되고 있는 것이다.
+             * 그래도 걸음 수 상한이 마지막 울타리로 남아 있다.
+             */
+            const 그새한일 = 손댄파일.size > (반복진척.get(서명) ?? 0);
+            const n = 그새한일 ? 1 : (막힘.get(`반복|${서명}`) ?? 0) + 1;
             막힘.set(`반복|${서명}`, n);
+            반복진척.set(서명, 손댄파일.size);
             실을것 = `앞에서 부른 ${call.name} 과 인자도 결과도 같습니다. 결과는 그대로라 다시 싣지 않습니다.`
               + ' 같은 것을 또 부르지 말고 다음 일로 넘어가세요.';
             if (n + 1 >= MAX_SAME) 멈출까 = `${call.name} 을 같은 인자로 계속 부르고 있습니다 — 결과가 매번 같습니다`;
           } else {
             부른것.set(서명, 같은꼴);
+            반복진척.set(서명, 손댄파일.size);
           }
         }
 

package/src/tools/index.js

@@ -588,10 +588,24 @@ function 한개옮기기({ from, to, overwrite = false }, ctx) {
 function 여러개옮기기(목록, ctx) {
   const 된것 = [];
   const 안된것 = [];
+  /*
+   * ── 무엇이 움직였는지 모아서 돌려준다 ──────────────────────────────
+   *
+   * 여기서 한 개짜리 결과의 `changed` 를 버리고 있었다. 그래서 스물두
+   * 개를 옮기면 화면에는 `22개 옮김` 이 뜨는데, **턴이 아는 「손댄
+   * 파일」 은 0개**였다. 그 값은 여러 군데가 본다 — 턴 끝의 만든 파일
+   * 목록, `/commit`, 그리고 헛도는지 재는 자리. 그 자리들이 전부
+   * "아무 일도 안 일어났다" 로 알고 있었다.
+   *
+   * 한 개씩 옮길 때는 멀쩡했다. 배열로 부를 때만 새던 자리다.
+   */
+  const 바뀐것들 = [];
   for (const 하나 of 목록) {
     const r = 한개옮기기(하나, ctx);
-    if (r.error) 안된것.push(`${하나.from ?? '?'} → ${하나.to ?? '?'}: ${r.error}`);
-    else 된것.push(r.content);
+    if (r.error) { 안된것.push(`${하나.from ?? '?'} → ${하나.to ?? '?'}: ${r.error}`); continue; }
+    된것.push(r.content);
+    // 폴더를 옮겼으면 그 안의 파일 하나하나가, 아니면 옮겨 간 자리가 답이다.
+    for (const f of r.바뀐것들 ?? (r.changed ? [r.changed] : [])) 바뀐것들.push(f);
   }
   /*
    * 하나도 못 옮겼으면 오류로 돌려준다. 그래야 모델이 '됐다' 고 넘어가지
@@ -605,6 +619,7 @@ function 여러개옮기기(목록, ctx) {
       + (안된것.length ? `\n${안된것.map((e) => `  ✗ ${e.split('\n')[0]}`).join('\n')}` : '')
       + (안된것.length ? '\n\n실패한 것만 다시 보내세요. 된 것은 다시 안 보내도 됩니다.' : ''),
     summary: `${된것.length}개 옮김${안된것.length ? ` · ${안된것.length}개 실패` : ''}`,
+    바뀐것들,
   };
 }
 

package/src/tools/todo.js

@@ -95,6 +95,34 @@ export const TODO_TOOL = {
     const 이전 = ctx.todos ?? [];
     ctx.todos = items;
 
+    /*
+     * ── 똑같은 목록을 또 보냈으면 그렇다고 말한다 ────────────────────────
+     *
+     * 「폴더 정리 해줘」 에서 이 자리가 걸렸다. 모델이 파일을 옮긴 뒤
+     * 목록을 갱신하려 했는데, 끝난 줄을 done 으로 안 바꾸고 **글자 하나
+     * 안 틀린 같은 목록**을 다시 보냈다. 그러면 여기서는 성공으로 돌려주고
+     * 「3개 중 1개 완료」 라는 앞과 똑같은 글이 나간다. 모델 쪽에서 보면
+     * 갱신이 된 것이므로, 다음 걸음에 또 같은 것을 보낸다. 그렇게 세 번이면
+     * 헛돈다고 판정돼 턴이 죽었다.
+     *
+     * 오류로 만들지는 않는다. 목록은 실제로 저장됐고, 틀린 것을 한 것도
+     * 아니다. 다만 **아무 일도 안 일어났다는 사실**과 그럴 때 무엇을 해야
+     * 하는지를 그 자리에서 알려 준다.
+     */
+    const 같은목록 = 이전.length === items.length
+      && items.every((x, i) => 이전[i]?.text === x.text && 이전[i]?.state === x.state);
+    if (같은목록) {
+      return {
+        content: `${render(items)}\n\n`
+          + '이 목록은 앞에 보낸 것과 글자 하나까지 같습니다 — 바뀐 것이 없습니다.\n'
+          + '방금 끝낸 일이 있으면 그 줄을 done 으로 바꿔서 보내고,'
+          + ' 없으면 목록을 다시 보내지 말고 다음 일을 하세요.',
+        summary: '그대로 (바뀐 것 없음)',
+        todos: items,
+        안바뀜: true,
+      };
+    }
+
     const 끝난것 = items.filter((x) => x.state === 'done').length;
     const 새로끝난 = items.filter((x) =>
       x.state === 'done' && !이전.some((y) => y.text === x.text && y.state === 'done'));