@noobdemon/noob-cli 1.7.8 → 1.7.10

package/package.json

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

package/src/agent.js

@@ -277,30 +277,24 @@ function memoryBlock() {
 // The proxy is stateless, so we serialize the whole transcript into one prompt.
 // extraToolsDoc: chuỗi mô tả thêm tool (vd spawn_agent khi agent mode bật) được
 // chèn ngay sau SYSTEM để model biết và dùng được.
-function buildPrompt(history, extraToolsDoc, goal) {
-  const msgs = compact(history, MAX_PROMPT_CHARS);
-  // Thứ tự CÓ CHỦ ĐÍCH: SYSTEM → memoryBlock (Rules dự án, vị trí mạnh thứ 2,
-  // tránh lost-in-the-middle) → goalBlock (hard completion requirement, attention
-  // cao — chống agentic laziness + goal drift) → extraToolsDoc → runtimeContext
-  // → filesLedger → CONVERSATION. noob.md (đặc biệt phần `## Rules`) phải nằm
-  // sát SYSTEM để model coi là luật.
+function buildSystem(history, extraToolsDoc, goal) {
   const parts = [SYSTEM, "", memoryBlock()];
-  if (goal && goal.trim()) {
-    parts.push("", goalBlock(goal));
-  }
+  if (goal && goal.trim()) parts.push("", goalBlock(goal));
   if (extraToolsDoc) parts.push("", extraToolsDoc);
-  parts.push("", runtimeContext(), "", filesLedger(history), "", "=".repeat(60), "# CONVERSATION", "");
+  parts.push("", runtimeContext());
+  return parts.join("\n");
+}
+
+function buildUserMessage(history) {
+  const msgs = compact(history, MAX_PROMPT_CHARS);
+  const parts = [filesLedger(history), "", "=".repeat(60), "# CONVERSATION", ""];
   for (const m of msgs) {
     if (m.role === "user") parts.push(`## USER\n${m.content}`);
     else if (m.role === "assistant") parts.push(`## ASSISTANT\n${m.content}`);
     else if (m.role === "tool") parts.push(`## TOOL RESULT (${m.name})\n${m.content}`);
     parts.push("");
   }
-  parts.push("=".repeat(60));
-  // Recency bias: câu chốt cuối prompt nằm ở vị trí attention mạnh nhất. Nhắc
-  // model đối chiếu FILES CHANGED trước khi claim đã sửa file — chống ảo giác
-  // "đã tạo file" khi chưa gọi write_file/edit_file.
-  parts.push("Continue. Emit a tool block to act, or reply in Markdown if done. Before claiming any file was created/edited, verify it appears in the FILES CHANGED list above — if not, emit the tool call now.");
+  parts.push("=".repeat(60), "Continue. Emit a tool block to act, or reply in Markdown if done. Before claiming any file was created/edited, verify it appears in the FILES CHANGED list above — if not, emit the tool call now.");
   return parts.join("\n");
 }
 
@@ -376,8 +370,9 @@ export async function runAgent({ history, model, signal, onTool, onStatus, onDel
     // Bộ nhớ dài hạn: thử tóm tắt nếu history đã phình. Im lặng nếu không cần.
     try { await maybeSummarize(history, { model, signal }); } catch {}
 
-    const prompt = buildPrompt(history, extraToolsDoc, goal);
-    tokenMeter?.addInput(countTokens(prompt));
+    const system = buildSystem(history, extraToolsDoc, goal);
+    const message = buildUserMessage(history);
+    tokenMeter?.addInput(countTokens(message));
     onStatus?.("thinking");
     onDelta?.({ type: "step-start" });
     // Stream + auto-retry: bao lớp resilience cho lỗi stream cut / empty / network.
@@ -385,7 +380,7 @@ export async function runAgent({ history, model, signal, onTool, onStatus, onDel
     // trường hợp api.js trả về với finishReason bất thường (tool_unclosed/empty) hoặc
     // throw ApiError retryable (network drop, 5xx, timeout).
     const { text, finishReason } = await streamWithRetry({
-      model, message: prompt, signal, tokenMeter, onDelta, onStatus,
+      model, message, system, signal, tokenMeter, onDelta, onStatus,
     });
     tokenMeter?.endOutput();
     onDelta?.({ type: "step-end" });
@@ -426,7 +421,7 @@ export async function runAgent({ history, model, signal, onTool, onStatus, onDel
  *   backoff (1s, 2s, 4s, 8s, max 30s), tối đa 8 lần thử trước khi bỏ cuộc.
  * - Throw lại nếu signal abort hoặc lỗi không retryable.
  */
-async function streamWithRetry({ model, message, signal, tokenMeter, onDelta, onStatus }) {
+async function streamWithRetry({ model, message, system, signal, tokenMeter, onDelta, onStatus }) {
   const MAX_RETRIES = 8;
   let lastErr = null;
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
@@ -435,6 +430,7 @@ async function streamWithRetry({ model, message, signal, tokenMeter, onDelta, on
         mode: "chat",
         model,
         message,
+        system,
         signal,
         onDelta: (d) => {
           tokenMeter?.pushOutputDelta(d);

package/src/api.js

@@ -3,6 +3,33 @@
 // upstream. The CLI only ever sees the gateway URL + the user's key.
 import { config } from "./config.js";
 
+// ── memoryToken: per-session random token for upstream conversation state.
+// Browser sends something like "uuid_uuid" (two v4 UUIDs joined by _).
+// Upstream requires both `remember: true` and a valid `memoryToken`.
+// ────────────────────────────────────────────────────────────────────────────
+let _sessionMemoryToken = null;
+
+function makeUUID() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === "x" ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}
+
+function makeMemoryToken() {
+  return `${makeUUID()}_${makeUUID()}`;
+}
+
+function getMemoryToken() {
+  if (!_sessionMemoryToken) _sessionMemoryToken = makeMemoryToken();
+  return _sessionMemoryToken;
+}
+
+export function resetMemoryToken() {
+  _sessionMemoryToken = null;
+}
+
 // Opt-in TLS escape hatch for machines behind a TLS-intercepting / broken-
 // revocation proxy. Off by default. Prefer fixing the trust store.
 // LƯU Ý: gọi từ bin/noob.js SAU khi parse argv — vì ESM import được hoist nên
@@ -89,7 +116,7 @@ function hasUnclosedToolBlock(text) {
  *
  * @returns {Promise<{text:string, reasoning:string}>}
  */
-export async function stream({ mode = "chat", message, model, signal, onDelta, onReasoning, onStatus, idleMs = 120000, maxContinues = Infinity }) {
+export async function stream({ mode = "chat", message, model, system, conversation, effort, signal, onDelta, onReasoning, onStatus, idleMs = 25000, maxContinues = Infinity }) {
   const endpoint = mode === "search" ? "/api/search" : mode === "merge" ? "/api/merge" : "/api/chat";
 
   let fullText = "";
@@ -99,7 +126,7 @@ export async function stream({ mode = "chat", message, model, signal, onDelta, o
   let emptyStreak = 0; // số lần liên tiếp stream rỗng (chống loop vô tận khi upstream chết hẳn)
 
   for (let attempt = 0; ; attempt++) {
-    const r = await streamOnce({ endpoint, mode, message: prompt, model, signal, idleMs, onStatus, onDelta, onReasoning });
+    const r = await streamOnce({ endpoint, mode, message: prompt, model, system, conversation, effort, signal, idleMs, onStatus, onDelta, onReasoning });
     fullText = mode === "chat" ? fullText + r.text : r.text; // chat: ghép các đoạn nối tiếp; mode khác: thay thế
     if (r.reasoning) reasoning = r.reasoning;
 
@@ -148,8 +175,18 @@ function continuationPrompt(message, partial) {
  * One network attempt of the stream. Returns this attempt's accumulated text +
  * a `truncated` flag telling the caller whether the reply was cut short.
  */
-async function streamOnce({ endpoint, mode, message, model, signal, idleMs, onStatus, onDelta, onReasoning }) {
-  const body = mode === "search" ? { query: message } : mode === "merge" ? { message } : { message, model };
+async function streamOnce({ endpoint, mode, message, model, system, conversation, effort, signal, idleMs, onStatus, onDelta, onReasoning }) {
+  // chat body: gửi system + conversation riêng để gateway forward đúng tới upstream.
+  // Worker gateway (handleChat) + upstream đều nhận shape này.
+  let body;
+  if (mode === "search") body = { query: message };
+  else if (mode === "merge") body = { message };
+  else {
+    body = { message, model, remember: true, memoryToken: getMemoryToken() };
+    if (system) body.customInstructions = system;
+    if (Array.isArray(conversation) && conversation.length) body.conversation = conversation;
+    if (effort) body.effort = effort;
+  }
 
   // Idle-timeout: nếu KHÔNG nhận được byte nào trong idleMs (kết nối treo), tự
   // huỷ và báo lỗi rõ ràng — thay vì spinner quay vô tận. Vẫn tôn trọng signal
@@ -158,14 +195,65 @@ async function streamOnce({ endpoint, mode, message, model, signal, idleMs, onSt
   let timedOut = false;
   const onUserAbort = () => ctrl.abort();
   signal?.addEventListener("abort", onUserAbort, { once: true });
-  let idle;
-  const arm = () => {
-    clearTimeout(idle);
-    idle = setTimeout(() => {
+  // Hai loại timer tách rời (xem comment dài bên dưới):
+  //  - WIRE: kết nối TCP còn thở không? Reset mỗi khi reader.read() trả bytes
+  //    (kể cả comment SSE `: keepalive` từ worker). Ngưỡng cao (idleMs*2) — chỉ
+  //    để bắt trường hợp socket chết cứng không còn cả heartbeat.
+  //  - CONTENT: upstream có thực sự đang nghĩ/nói không? Reset chỉ khi parser
+  //    thấy delta/status/reasoning/done/truncated thật. WARN/PROBE/idleMs gắn
+  //    vào timer này. Đây là fix cho bug: worker phát `: keepalive\n\n` mỗi 15s
+  //    bất kể upstream Vercel còn sống hay đã treo → nếu reset idle theo wire,
+  //    status đếm thời gian sẽ chạy mãi không bao giờ trigger probe/abort.
+  let wireIdle = null;
+  let contentIdle = null;
+  let warnTimer = null;
+  let probeTimer = null;
+  let probeInFlight = false;
+  const WARN_MS = Math.min(8000, idleMs / 3);
+  const PROBE_MS = Math.min(12000, (idleMs * 2) / 3);
+  const WIRE_MS = idleMs * 2; // socket dead-cứng (mất cả heartbeat) — ngưỡng rộng
+  const clearContentTimers = () => {
+    clearTimeout(warnTimer); warnTimer = null;
+    clearTimeout(probeTimer); probeTimer = null;
+    clearTimeout(contentIdle); contentIdle = null;
+  };
+  const armContent = () => {
+    clearContentTimers();
+    warnTimer = setTimeout(() => {
+      if (onStatus) onStatus("Đang chờ proxy phản hồi…");
+    }, WARN_MS);
+    probeTimer = setTimeout(async () => {
+      if (probeInFlight || ctrl.signal.aborted) return;
+      probeInFlight = true;
+      try {
+        const probeCtl = new AbortController();
+        const probeT = setTimeout(() => probeCtl.abort(), 3000);
+        const r = await fetch(config.gatewayUrl + "/api/usage", { headers: authHeaders(), signal: probeCtl.signal });
+        clearTimeout(probeT);
+        if (!r.ok && r.status >= 500) throw new Error("proxy 5xx");
+      } catch {
+        if (!ctrl.signal.aborted) {
+          timedOut = true;
+          if (onStatus) onStatus("Proxy không phản hồi — đang gọi lại model…");
+          ctrl.abort();
+        }
+      } finally {
+        probeInFlight = false;
+      }
+    }, PROBE_MS);
+    contentIdle = setTimeout(() => {
       timedOut = true;
       ctrl.abort();
     }, idleMs);
   };
+  const armWire = () => {
+    clearTimeout(wireIdle);
+    wireIdle = setTimeout(() => {
+      // Mất cả heartbeat → socket chết cứng. Abort, lớp trên sẽ retry.
+      timedOut = true;
+      ctrl.abort();
+    }, WIRE_MS);
+  };
 
   let text = "";
   let reasoning = "";
@@ -184,6 +272,12 @@ async function streamOnce({ endpoint, mode, message, model, signal, idleMs, onSt
     } catch {
       return;
     }
+    // Có ít nhất 1 field nội dung thực → upstream đang nghĩ/nói. Reset content
+    // idle/warn/probe. JSON rỗng `{}` (ping) hoặc comment `: keepalive` của
+    // worker KHÔNG khớp điều kiện này → không che mất idle detection.
+    if (p.status || p.delta || p.reasoning || p.done || p.truncated || p.error) {
+      armContent();
+    }
     if (p.status && onStatus) onStatus(p.status);
     if (p.delta) {
       text += p.delta;
@@ -200,7 +294,8 @@ async function streamOnce({ endpoint, mode, message, model, signal, idleMs, onSt
   };
 
   try {
-    arm();
+    armWire();
+    armContent();
     const resp = await fetch(config.gatewayUrl + endpoint, {
       method: "POST",
       headers: authHeaders(),
@@ -214,7 +309,7 @@ async function streamOnce({ endpoint, mode, message, model, signal, idleMs, onSt
     let buf = "";
     while (true) {
       const { done, value } = await reader.read();
-      arm(); // có hoạt động → gia hạn idle
+      armWire(); // bất kỳ byte nào tới → socket còn thở, gia hạn wire idle
       if (done) break;
       buf += decoder.decode(value, { stream: true });
       let nl;
@@ -239,7 +334,8 @@ async function streamOnce({ endpoint, mode, message, model, signal, idleMs, onSt
     if (mode === "chat" && text) return { text, reasoning, truncated: true };
     throw err;
   } finally {
-    clearTimeout(idle);
+    clearTimeout(wireIdle);
+    clearContentTimers();
     signal?.removeEventListener("abort", onUserAbort);
   }
 }

package/src/repl.js

@@ -6,7 +6,7 @@ import { createTui } from "./tui.js";
 import { runAgent, maybeSummarize } from "./agent.js";
 import { runSubAgent, spawnAgentToolsDoc, MAX_SUBAGENT_DEPTH } from "./subagent.js";
 import { TokenMeter } from "./tokens.js";
-import { stream, usage, ApiError } from "./api.js";
+import { stream, usage, ApiError, resetMemoryToken } from "./api.js";
 import { runTool, describe, DESTRUCTIVE, addRoot, listRoots } from "./tools.js";
 import { MODELS, PROVIDERS, findModel, providerColor, DEFAULT_MODEL } from "./models.js";
 import { c, banner, modelBadge, renderMarkdown, box } from "./ui.js";
@@ -360,7 +360,11 @@ export async function startRepl(opts = {}) {
     );
     console.log(c.dim("\n  " + t.sessionResumeHint) + "\n");
   }
-  const startFresh = () => (session = sessions.newSession({ cwd: process.cwd(), model: state.model.id }));
+  const startFresh = () => {
+    session = sessions.newSession({ cwd: process.cwd(), model: state.model.id });
+    // Reset per-session upstream memory token so the next chat starts fresh.
+    resetMemoryToken();
+  };
 
   // /frontend-design <yêu cầu> — vận dụng skill frontend-design (skills/frontend-design/SKILL.md)
   // để model tạo UI frontend chất lượng cao, tránh "AI slop" aesthetic.
@@ -535,6 +539,20 @@ Cuối cùng: tóm tắt + danh sách sửa theo thứ tự ưu tiên. Thẳng t
   // bắt nhầm khi model chỉ NHẮC tới token giữa văn xuôi. Không bao giờ chấp nhận
   // ở lượt lập kế hoạch (xem vòng lặp bên dưới).
   const ultraIsDone = (a) => a.trimEnd().endsWith(ULTRA_DONE);
+  // Detect "stuck": model bối rối, không nhận task, chỉ hỏi lại user hoặc spam
+  // list_dir/ls vô nghĩa. Xảy ra khi goal trống nghĩa / bị paste system prompt /
+  // model mất ngữ cảnh. 2 vòng stuck liên tiếp → auto-exit để không loop vô hạn.
+  const STUCK_PHRASES = [
+    "chưa giao task", "chưa nêu tác vụ", "chưa có yêu cầu", "chưa có task",
+    "không nhận task", "không thể nhận vai", "bạn muốn mình làm gì",
+    "chưa rõ yêu cầu", "cần mục tiêu rõ", "vui lòng cho biết",
+    "please provide", "what would you like", "no task", "clarify",
+  ];
+  const ultraLooksStuck = (a) => {
+    if (!a) return true;
+    const s = a.toLowerCase();
+    return STUCK_PHRASES.some((p) => s.includes(p));
+  };
   const ultraStart = (goal) => `# CHẾ ĐỘ ULTRA (tự hành)
 Mục tiêu tổng: ${goal}
 
@@ -568,10 +586,23 @@ Tự đánh giá: còn THIẾU gì để đạt mục tiêu? Chọn 1 nhiệm v
       let answer = await handle(ultraStart(goal));
       persist();
       let i = 0;
+      let stuckStreak = 0; // đếm vòng liên tiếp model bối rối / không nhận task
+      const STUCK_MAX = 2;
       // Lượt đầu = lập kế hoạch → KHÔNG xét hoàn thành. Mỗi vòng sau là một lượt
       // "tiếp tục" có cổng kiểm chứng; chỉ dừng khi token nằm ở CUỐI câu trả lời.
+      // Cũng dừng sớm nếu model 2 vòng liên tiếp tỏ ra mất ngữ cảnh (goal trống
+      // nghĩa, paste system prompt, model hỏi lại user) → tránh spam list_dir.
       while (state.ultra && i < MAX_QUESTS) {
         if (!answer) break; // lượt bị ngắt/ lỗi → dừng tự hành, đừng quay vô ích
+        if (ultraLooksStuck(answer)) {
+          stuckStreak++;
+          if (stuckStreak >= STUCK_MAX) {
+            console.log(c.err("  ⚠ ULTRA stuck: model không nhận task " + stuckStreak + " vòng liên tiếp. Thoát. Gõ /ultra <mục tiêu rõ> để thử lại."));
+            break;
+          }
+        } else {
+          stuckStreak = 0;
+        }
         i++;
         console.log(c.accent("  ↻ " + t.ultraQuest(i)));
         answer = await handle(ultraContinue(goal));