@noobdemon/noob-cli 1.10.13 → 1.10.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noobdemon/noob-cli",
-  "version": "1.10.13",
+  "version": "1.10.15",
   "publishConfig": {
     "access": "public"
   },

package/src/agent.js

@@ -144,12 +144,14 @@ const MAX_STEPS = 10000;
 
 // Loop detection: nếu model gọi cùng 1 tool với input giống nhau liên tiếp
 // quá ngưỡng này → coi là bị kẹt, inject thông báo để model chuyển bước.
-const LOOP_DETECT_WINDOW = 3;
+// Cũng phát hiện pattern vòng lặp (A-B-A-B, A-B-C-A-B-C) — model hay thoát
+// loop detection cũ bằng cách xen kẽ 2-3 tool call khác nhau.
+const LOOP_DETECT_WINDOW = 6;
 const LOOP_DETECT_THRESHOLD = 2;
-const MAX_PROMPT_CHARS = 600000; // ~150k tokens (50% của 300k window) — allow compaction only at >50%
+const MAX_PROMPT_CHARS = 1200000; // ~300k tokens (ngang context window) — compact() KHÔNG chạy trước auto-compact 80% (240k token) của repl.js
 // Khi history vượt ngưỡng này, gọi model phụ tóm tắt các lượt cũ thay vì cắt cụt
 // → giữ được "trí nhớ dài hạn" trong phiên mà không nổ context.
-const SUMMARIZE_THRESHOLD_CHARS = 400000; // ~100k tokens (33% của 300k window) — start summarizing early
+const SUMMARIZE_THRESHOLD_CHARS = 1000000; // ~250k tokens (83% window) — summarize chỉ chạy sau auto-compact 80%
 
 // HARD GOAL block (do /goal <text> set): chèn ngay sau memoryBlock, attention
 // cao. Mục đích — chống 3 failure mode bài "dynamic workflows" của Anthropic
@@ -588,36 +590,56 @@ export async function runAgent({ history, model, signal, onTool, onStatus, onDel
     }
 
     // ── Loop detection ──────────────────────────────────────────────────
-    // Theo dõi N tool call gần nhất. Nếu cùng tên + input giống nhau liên tiếp
-    // quá ngưỡng → model bị kẹt. Inject thông báo nhắc model chuyển bước.
-    // Nếu model vẫn lặp → force stop sau MAX_LOOP_DETECTIONS lần.
+    // Theo dõi N tool call gần nhất. Phát hiện 2 dạng kẹt:
+    //   (A) Cùng tool + input liên tiếp (A-A-A) — dễ, như model hay né.
+    //   (B) Pattern vòng (A-B-A-B, A-B-C-A-B-C) — model xen kẽ 2-3 tool
+    //       khác nhau để tránh phát hiện cũ. So nửa đầu vs nửa cuối window.
+    // Nếu phát hiện → inject cảnh báo. Nếu tái diễn → force stop.
     const inputStr = JSON.stringify(call.input || {});
     recentCalls.push({ name: call.name, inputStr });
     if (recentCalls.length > LOOP_DETECT_WINDOW) recentCalls.shift();
+    let loopType = null; // 'consecutive' | 'pattern' | null
     if (recentCalls.length >= LOOP_DETECT_THRESHOLD + 1) {
+      // (A) Same consecutive check
       const lastN = recentCalls.slice(-LOOP_DETECT_THRESHOLD);
       const allSame = lastN.every((c) => c.name === lastN[0].name && c.inputStr === lastN[0].inputStr);
-      if (allSame) {
-        loopDetectedCount++;
-        // Đã lặp quá nhiều lần liên tiếp → force stop
-        if (loopDetectedCount >= MAX_LOOP_DETECTIONS) {
-          history.push({
-            role: "tool",
-            name: "loop_detection",
-            content: `[LOOP DETECTED × ${loopDetectedCount}] Bạn đã gọi ${lastN[0].name} nhiều lần liên tiếp với cùng input — KHÔNG THỂ TIẾP TỤC. Dừng ngay lập tức.`,
-          });
-          return `[LOOP STOPPED] Đã dừng vì model bị kẹt trong vòng lặp gọi ${lastN[0].name} liên tục.`;
+      if (allSame) loopType = 'consecutive';
+    }
+    // (B) Pattern cycle check: tìm chu kỳ lặp trong window (độ dài 2-3)
+    if (!loopType && recentCalls.length >= 4) {
+      for (let cycleLen = 2; cycleLen <= Math.min(3, Math.floor(recentCalls.length / 2)); cycleLen++) {
+        const half = Math.floor(recentCalls.length / cycleLen) * cycleLen;
+        const first = recentCalls.slice(-half, -half + cycleLen);
+        const rest = recentCalls.slice(-half + cycleLen);
+        let matched = true;
+        for (let i = 0; i < rest.length; i++) {
+          if (rest[i].name !== first[i % cycleLen].name || rest[i].inputStr !== first[i % cycleLen].inputStr) {
+            matched = false;
+            break;
+          }
         }
-        // Đã lặp — inject cảnh báo, xoá calls để tránh trigger liên tục
-        recentCalls.length = 0;
+        if (matched) { loopType = 'pattern'; break; }
+      }
+    }
+    if (loopType) {
+      const label = loopType === 'consecutive' ? lastN[0].name : `pattern [${recentCalls.slice(-4).map((c) => c.name).join(", ")}]`;
+      loopDetectedCount++;
+      if (loopDetectedCount >= MAX_LOOP_DETECTIONS) {
         history.push({
           role: "tool",
           name: "loop_detection",
-          content: `[LOOP DETECTED × ${loopDetectedCount}] Bạn vừa gọi ${lastN[0].name} ${LOOP_DETECT_THRESHOLD} lần liên tiếp với cùng input — có vẻ bạn đang bị kẹt trong vòng lặp. HÃY CHUYỂN BƯỚC: gọi tool khác, hoặc trả lời Markdown nếu đã xong. KHÔNG được gọi cùng tool cùng input lần nữa. Nếu tiếp tục lặp, task sẽ bị dừng.`,
+          content: `[LOOP DETECTED × ${loopDetectedCount}] Bạn lặp lại ${label} nhiều lần — KHÔNG THỂ TIẾP TỤC. Dừng ngay.`,
         });
-      } else {
-        loopDetectedCount = 0; // model gọi tool khác → reset counter
+        return `[LOOP STOPPED] Đã dừng vì model bị kẹt trong vòng lặp.`;
       }
+      recentCalls.length = 0;
+      history.push({
+        role: "tool",
+        name: "loop_detection",
+        content: `[LOOP DETECTED × ${loopDetectedCount}] Bạn lặp lại ${label} — có vẻ đang kẹt. HÃY CHUYỂN BƯỚC: gọi tool khác hoặc trả lời Markdown nếu xong. KHÔNG lặp lại. Nếu tiếp tục, task sẽ dừng.`,
+      });
+    } else {
+      loopDetectedCount = 0; // tool khác → reset
     }
   }
   return t.maxSteps;