@noobdemon/noob-cli 1.7.7 → 1.7.10

package/package.json

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

package/skills/dynamic-workflows/SKILL.md

@@ -0,0 +1,154 @@
+# Dynamic Workflows — Orchestrate Multi-Agent
+
+> Lấy cảm hứng từ bài "A harness for every task: dynamic workflows in Claude Code" (Thariq Shihipar, Anthropic). Bạn (parent agent) là NHẠC TRƯỞNG. Bạn KHÔNG tự làm hết — bạn lập kế hoạch, ủy thác cho sub-agent qua `spawn_agent` / `spawn_agents`, rồi tổng hợp kết quả.
+
+## Critical Rules — KHÔNG được vi phạm
+
+1. **Bạn là PARENT, không phải worker.** Việc nặng (đọc nhiều file, viết code dài, search rộng) hãy DELEGATE qua `spawn_agent`. Parent giữ context sạch để còn synthesize được.
+2. **Sub-agent KHÔNG nói trực tiếp với user.** Chúng trả về string cho bạn. Bạn là người viết báo cáo cuối tiếng Việt cho user.
+3. **Mọi prompt sub-agent PHẢI có 5 mục**: GOAL / INPUTS / METHOD / OUTPUT SHAPE / STOP CONDITION. Thiếu mục nào, sub-agent dễ lan man hoặc dừng sai chỗ.
+4. **Song song chỉ khi task ĐỘC LẬP.** Nếu B cần kết quả A → dùng `spawn_agent` tuần tự, KHÔNG nhét vào `spawn_agents`.
+5. **KHÔNG spawn cho việc nhỏ.** Mỗi sub-agent là 1 phiên model riêng → token. Nếu việc đọc 1 file + sửa 3 dòng, tự làm. Spawn dành cho việc đáng tách ra (≥ vài file, ≥ vài bước, hoặc cần góc nhìn riêng).
+6. **MAX_SUBAGENT_DEPTH = 3.** Bạn đang ở depth=0. Sub-agent của bạn (depth=1) cũng spawn được, nhưng cháu của bạn (depth=2) là tầng cuối — depth=3 sẽ bị từ chối.
+7. **Tổng hợp = dedupe + reconcile + chấm điểm**, không phải copy-paste. Sub-agent có thể mâu thuẫn — bạn quyết.
+
+## Tại sao cần workflow — 3 failure mode của single-context
+
+Khi để Claude vừa plan vừa execute trong CÙNG context window, task càng dài càng dễ rơi vào:
+
+1. **Agentic laziness** — dừng giữa chừng, tuyên bố "xong" khi mới làm 20/50 mục. Workflow chống bằng cách giao mỗi mục cho 1 sub-agent + parent đếm.
+2. **Self-preferential bias** — Claude thiên vị kết quả của chính nó khi được yêu cầu tự verify. Workflow chống bằng adversarial verification: agent KHÁC review, không phải agent đã làm.
+3. **Goal drift** — mục tiêu gốc bị loãng qua nhiều turn, đặc biệt sau auto-compact (mỗi lần summarize đều lossy, ràng buộc "don't do X" dễ mất). Workflow chống bằng cách mỗi sub-agent có goal cô đọng trong prompt, không phụ thuộc lịch sử dài.
+
+## 7 Pattern Workflow
+
+### 1. Fan-out + Synthesize
+Một task lớn chia thành N nhánh độc lập song song, rồi gom.
+- VD: "audit security toàn repo" → spawn_agents N sub-agent mỗi sub-agent audit 1 module → parent gom + ưu tiên hóa.
+- Khi dùng: task có thể PARTITION rõ ràng theo file/module/khía cạnh.
+
+### 2. Adversarial Verification
+Một sub-agent LÀM, một sub-agent khác PHẢN BIỆN với prompt thù địch.
+- VD: agent A viết migration SQL → agent B với role "DBA cẩn trọng, tìm mọi cạm bẫy" review → parent quyết apply hay sửa.
+- Khi dùng: code rủi ro cao, quyết định khó đảo ngược, claim cần verify.
+- **Skeptic persona** giảm false positive: khi verifier có xu hướng raise mọi thứ, thêm 1 sub-agent đóng vai "skeptic" review lại finding của verifier — chỉ giữ lại finding mà skeptic cũng đồng ý là vấn đề thật.
+
+### 3. Generate-and-Filter
+Sinh nhiều phương án song song, sau đó 1 sub-agent (hoặc parent) lọc.
+- VD: spawn_agents 5 sub-agent mỗi cái đề xuất 1 cách refactor → 1 sub-agent filter trả về top 2 + lý do.
+- Khi dùng: bài toán mở, cần đa dạng giải pháp.
+
+### 4. Tournament
+Bracket: ghép cặp 2 phương án, sub-agent judge chọn cái tốt hơn, lặp đến khi còn 1.
+- VD: 8 design proposal → 4 trận → 2 trận → 1 final.
+- Khi dùng: cần xếp hạng tương đối tin cậy, có thể tốn nhiều agent.
+
+### 5. Loop-Until-Done
+Sub-agent làm 1 vòng, parent check stop condition, chưa đạt → spawn lại với feedback.
+- VD: "viết test cho module X cho đến khi coverage ≥ 90%". Vòng 1 sub-agent viết test → parent chạy coverage → chưa đạt → spawn lại kèm danh sách dòng chưa cover.
+- Khi dùng: có metric đo được, tiến gần đích từng vòng.
+- ⚠️ LUÔN set hard cap số vòng (≤ 5) để tránh nổ token.
+
+### 6. Classify-and-Route
+Sub-agent đầu phân loại task, rồi route tới sub-agent chuyên dụng.
+- VD: user input "sửa bug" → classifier phân loại bug (race condition / null deref / logic) → route tới sub-agent có prompt chuyên sâu cho loại đó.
+- Khi dùng: input không đồng nhất, mỗi loại cần chiến lược khác.
+
+### 7. Diverse-Hypothesis Debug
+Khi debug bug khó, spawn_agents N sub-agent mỗi cái GIẢ ĐỊNH 1 nguyên nhân khác nhau và điều tra theo hướng đó.
+- VD: "test flaky đôi khi pass đôi khi fail" → 3 hypothesis: race condition / timezone / state leak → 3 sub-agent investigate song song → parent đối chiếu.
+- Khi dùng: bug có nhiều khả năng, không biết bắt đầu từ đâu.
+
+## Prompt Template cho Sub-Agent
+
+Mỗi `spawn_agent({task, context})` PHẢI có cấu trúc:
+
+```
+GOAL:
+<1-2 câu nêu mục tiêu cụ thể, đo được>
+
+INPUTS:
+- <file path / data / quyết định đã chốt mà sub-agent cần biết>
+- ...
+
+METHOD:
+<các bước nên làm; tự do nhưng định hướng>
+
+OUTPUT SHAPE:
+<format kết quả parent muốn nhận — markdown? JSON? bullet list? hãy CỤ THỂ>
+
+STOP CONDITION:
+<khi nào sub-agent coi như xong; ngăn nó lan man hoặc dừng quá sớm>
+```
+
+Khi gọi `spawn_agents` (song song), mỗi phần tử trong mảng tasks cũng theo cùng cấu trúc, chỉ khác `task` + `context`.
+
+## Token Budget — KHÔNG giới hạn, ưu tiên HOÀN THÀNH TASK
+
+**Quy tắc tối thượng: HOÀN THÀNH TASK > tiết kiệm token.** Đừng tự ý cắt ngắn, đừng skip pattern phù hợp chỉ vì "sợ tốn token". Token là chi phí có thể chấp nhận; task dở dang / kết quả sai mới là thất bại thật sự.
+
+- Cứ spawn đủ sub-agent cần thiết để task xong ĐÚNG và ĐỦ.
+- Nếu phân vân giữa "1 agent làm cả" vs "3 agent chia ra cho sạch context" — chọn 3 agent.
+- Nếu phân vân giữa "dừng sớm vì có vẻ đủ" vs "verify thêm 1 vòng adversarial" — verify.
+- Tournament 8→1 tốn ~14 agent? Cứ làm nếu task cần ranking tin cậy.
+- Chỉ tránh spawn khi việc THẬT SỰ NHỎ (vd sửa 1 dòng trong 1 file) — không phải vì lo token.
+- KHÔNG báo cáo "đã làm xong" khi chưa verify, để tiết kiệm 1 sub-agent verify là phản tác dụng.
+
+## Non-Technical Use Cases — workflow KHÔNG chỉ cho code
+
+Bài gốc nhấn mạnh: workflow thường còn hữu ích hơn cho việc PHI kỹ thuật. Một số use case mẫu:
+
+- **Rank hàng loạt item theo chất lượng** — vd 80 resume cho role backend: fan-out chấm sơ bộ → tournament/pairwise top 10 → double-check + verify. Tránh bảo 1 agent "chấm 1-10 cho 80 cái" (absolute scoring drift).
+- **Brainstorm + tournament chọn tên** — vd đặt tên CLI/sản phẩm/feature: generate nhiều phương án song song → tournament theo rubric (ngắn / dễ nhớ / không trùng / hợp tone) → top 3.
+- **Tear-apart từ nhiều persona** — vd business plan / design doc / RFC: spawn_agents song song với role khác nhau (investor / customer / competitor / security / SRE) mỗi agent tìm điểm yếu theo góc nhìn riêng → parent reconcile.
+- **Verify mọi claim trong văn bản** — vd blog draft / báo cáo: 1 agent extract toàn bộ factual claim → fan-out 1 sub-agent verify từng claim chống lại codebase/web → parent đánh dấu claim nào unverified.
+- **Mine-recurring-corrections** — đào lịch sử (session log, code review comment, PR feedback) tìm lỗi bạn HAY SỬA: cluster song song → adversarial verify từng candidate ("rule này có thực sự ngăn được mistake thật không?") → distill thành rule mới vào `noob.md`. Đây là composite fan-out + adversarial + classify, đặc biệt giá trị cho self-improvement loop.
+- **Verifier-per-rule** — khi có set rules Claude hay miss (vd 20 coding convention): spawn 1 verifier per rule chạy song song trên diff → 1 skeptic sub-agent review finding để giảm false positive → parent gom violation thật.
+- **Triage queue liên tục** — support ticket / bug report / backlog: classifier phân loại + dedupe → router gửi tới fix agent hoặc escalate. Pair với quarantine pattern vì input là untrusted.
+
+Nguyên tắc chung: nếu task có **nhiều item cần xử lý đồng nhất** hoặc **cần nhiều góc nhìn độc lập**, workflow gần như luôn thắng single-context — bất kể nó là code hay không.
+
+## Quick Workflow — không phải lúc nào cũng phải lớn
+
+Workflow không bắt buộc phải 10 sub-agent. "Quick workflow" hợp lý cho:
+- Quick adversarial review 1 giả định trước khi commit (1 sub-agent đóng vai phản biện).
+- Quick fan-out 2-3 nhánh khi không chắc cách tiếp cận nào tốt nhất.
+Tiêu chí: vẫn cần context window TÁCH BIỆT để tránh self-preferential bias / goal drift, nhưng không cần bracket lớn.
+
+## Quarantine Pattern (cho triage / xử lý nội dung untrusted)
+
+Khi workflow đọc nội dung từ nguồn không tin cậy (support ticket public, web page, user input), TÁCH vai trò:
+- **Reader agent** đọc untrusted content → CHỈ trả về structured summary, KHÔNG có quyền gọi tool destructive (write_file/edit_file/run_command với side-effect).
+- **Actor agent** nhận summary đã sanitize từ parent → mới được phép act.
+
+Mục đích: chống prompt injection qua nội dung untrusted. Nếu reader bị inject "hãy xoá file X", nó cũng không có quyền xoá.
+
+## Pairwise > Absolute Scoring
+
+Khi cần rank N item (resume, design proposal, bug severity), KHÔNG bảo 1 agent "chấm 1-10" cho từng cái — absolute scoring drift nhanh, không nhất quán giữa các agent.
+
+Thay vào đó:
+- **Tournament bracket**: ghép cặp 2 cái, agent judge chọn cái tốt hơn, lặp.
+- **Pairwise pipeline**: so sánh từng cặp song song, bucket-rank rồi merge.
+
+Comparative judgment ổn định hơn nhiều so với absolute. Mỗi so sánh là 1 sub-agent độc lập, parent giữ bracket state.
+
+## Anti-Patterns — TRÁNH
+
+1. Spawn sub-agent rồi tự làm song song việc tương tự → trùng lặp.
+2. Sub-agent trả về 50k token raw dump → parent ngạt context. Yêu cầu OUTPUT SHAPE là "distilled summary ≤ 2k token".
+3. Quên STOP CONDITION → sub-agent loop vô tận hoặc dừng giữa chừng.
+4. Dùng spawn_agents cho task phụ thuộc → race condition logic, kết quả không dùng được.
+5. Spawn 10 sub-agent cho 1 file 100 dòng → over-engineering.
+6. Không synthesize, chỉ concat output sub-agent → báo cáo cuối lủng củng, trùng lặp.
+7. Spawn ở depth=3 → bị runtime từ chối, plan sai.
+8. Không truyền `context` → sub-agent phải re-discover từ đầu, tốn token đọc lại.
+
+## Checklist Trước Khi Báo Cáo Cuối
+
+- [ ] Mọi sub-task đã có sub-agent trả lời hoặc bạn tự kết luận.
+- [ ] Đã dedupe output sub-agent (không lặp ý).
+- [ ] Đã reconcile mâu thuẫn (sub-agent A nói X, B nói Y → bạn chọn cái nào, vì sao).
+- [ ] Kết quả cuối bằng tiếng Việt, súc tích, có bằng chứng (file:line nếu có).
+- [ ] Nếu workflow cần ACTION (sửa file), action đã thực sự thực hiện qua tool, không chỉ "đề xuất".
+- [ ] Nếu có warning/risk, đã nêu rõ.

package/src/agent.js

@@ -82,6 +82,22 @@ const MAX_PROMPT_CHARS = 80000; // ngân sách ký tự cho phần hội thoại
 // → giữ được "trí nhớ dài hạn" trong phiên mà không nổ context.
 const SUMMARIZE_THRESHOLD_CHARS = 60000;
 
+// 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
+// nêu (agentic laziness / goal drift / self-preferential bias): cứ mỗi turn,
+// model nhìn lại MỤC TIÊU CỐT LÕI nguyên văn của user, không bị compaction
+// nuốt mất. KHÔNG paraphrase goal — giữ nguyên text user gõ.
+function goalBlock(goal) {
+  return [
+    "# HARD GOAL (set via /goal — BINDING)",
+    "Người dùng đã đặt MỤC TIÊU CỐT LÕI cho phiên này. Mọi lượt phản hồi/hành động PHẢI hướng tới việc hoàn thành goal này. KHÔNG được tuyên bố xong khi goal chưa thực sự đạt (chống agentic laziness). KHÔNG được trôi sang việc khác làm goal lu mờ (chống goal drift). Nếu user hỏi việc nhỏ trung gian, làm xong rồi quay lại goal.",
+    "",
+    "GOAL: " + goal.trim(),
+    "",
+    "Trước khi reply 'đã xong' / kết thúc phiên ULTRA / phát token hoàn thành, tự hỏi: goal trên đã ĐẠT chưa? Nếu chưa, làm tiếp.",
+  ].join("\n");
+}
+
 // Môi trường chạy thực: model cần biết OS + shell để emit lệnh ĐÚNG. Không có
 // khối này, trên Windows model hay emit lệnh Unix (wc/ls/cat/grep) → run_command
 // (PowerShell) báo lỗi.
@@ -261,25 +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) {
-  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) → 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 (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");
 }
 
@@ -339,7 +354,10 @@ function extractJsonObject(s, from) {
  * @param {(msg:string)=>void} opts.onStatus      thinking/streaming status
  * @returns {Promise<string>} the final assistant answer (no tool block)
  */
-export async function runAgent({ history, model, signal, onTool, onStatus, onDelta, onSteer, tokenMeter, extraToolsDoc }) {
+export async function runAgent({ history, model, signal, onTool, onStatus, onDelta, onSteer, tokenMeter, extraToolsDoc, goal }) {
+  // [GỠ BUDGET 2026-06-06] Không còn token budget enforcement. Agent/loop/sub-agent
+  // chạy không giới hạn token. Dừng theo: GOAL đạt, <<LOOP_DONE>>, <<ULTRA_DONE>>,
+  // model tự kết thúc reply không có tool block, hoặc user Ctrl+C.
   for (let step = 0; step < MAX_STEPS; step++) {
     // Mỗi 100 bước log một mốc để người dùng biết noob vẫn đang chạy (task dài).
     if (step > 0 && step % 100 === 0) onStatus?.(`đã chạy ${step} bước…`);
@@ -352,26 +370,39 @@ 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);
-    tokenMeter?.addInput(countTokens(prompt));
+    const system = buildSystem(history, extraToolsDoc, goal);
+    const message = buildUserMessage(history);
+    tokenMeter?.addInput(countTokens(message));
     onStatus?.("thinking");
     onDelta?.({ type: "step-start" });
-    const { text } = await stream({
-      mode: "chat",
-      model,
-      message: prompt,
-      signal,
-      onDelta: (d) => {
-        tokenMeter?.pushOutputDelta(d);
-        onDelta?.({ type: "delta", text: d });
-      },
+    // Stream + auto-retry: bao lớp resilience cho lỗi stream cut / empty / network.
+    // api.js đã tự nối tiếp khi truncated (maxContinues=Infinity); agent.js xử lý các
+    // 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, system, signal, tokenMeter, onDelta, onStatus,
     });
     tokenMeter?.endOutput();
     onDelta?.({ type: "step-end" });
     history.push({ role: "assistant", content: text });
 
     const call = parseToolCall(text);
-    if (!call) return text; // final answer
+    if (!call) {
+      // Không có tool call. Nếu finishReason bất thường (empty/tool_unclosed) →
+      // model bị cắt ngay trước khi kịp gọi tool → nudge tiếp 1 lượt nữa thay vì
+      // return text rỗng/dở dang.
+      if (finishReason === "empty" || finishReason === "tool_unclosed") {
+        history.push({
+          role: "tool",
+          name: "stream_recovery",
+          content: finishReason === "tool_unclosed"
+            ? "[STREAM CUT] Bạn vừa emit tool block mở mà chưa đóng. Lặp lại tool call đó NGUYÊN VẸN, đóng đúng cú pháp ```tool ... ``` rồi STOP."
+            : "[STREAM EMPTY] Lượt vừa rồi không trả về text. Hãy tiếp tục công việc — nếu cần tool thì emit tool block, nếu xong thì tổng kết.",
+        });
+        continue;
+      }
+      return text; // final answer
+    }
 
     const { allow, result } = await onTool(call.name, call.input);
     history.push({
@@ -382,3 +413,49 @@ export async function runAgent({ history, model, signal, onTool, onStatus, onDel
   }
   return t.maxSteps;
 }
+
+/**
+ * Bao lớp resilience quanh stream():
+ * - api.js đã tự nối tiếp khi gateway báo truncated (maxContinues=Infinity).
+ * - Tại đây chỉ xử lý ApiError retryable (network drop / 5xx / timeout): exponential
+ *   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, system, signal, tokenMeter, onDelta, onStatus }) {
+  const MAX_RETRIES = 8;
+  let lastErr = null;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      const result = await stream({
+        mode: "chat",
+        model,
+        message,
+        system,
+        signal,
+        onDelta: (d) => {
+          tokenMeter?.pushOutputDelta(d);
+          onDelta?.({ type: "delta", text: d });
+        },
+      });
+      return result; // { text, reasoning, finishReason }
+    } catch (err) {
+      if (signal?.aborted) throw err; // user Ctrl+C — không retry
+      if (err?.name !== "ApiError" || !err.retryable) throw err; // lỗi cứng — bail
+      lastErr = err;
+      if (attempt >= MAX_RETRIES) break;
+      const backoff = Math.min(30000, 1000 * Math.pow(2, attempt));
+      onStatus?.(`mạng lỗi (${err.message}) — thử lại sau ${(backoff/1000)|0}s [${attempt+1}/${MAX_RETRIES}]`);
+      await sleep(backoff, signal);
+    }
+  }
+  throw lastErr || new Error("streamWithRetry: exhausted retries");
+}
+
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const id = setTimeout(() => { cleanup(); resolve(); }, ms);
+    const onAbort = () => { cleanup(); reject(new Error("aborted")); };
+    const cleanup = () => { clearTimeout(id); signal?.removeEventListener("abort", onAbort); };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}

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
@@ -26,16 +53,32 @@ function authHeaders() {
 }
 
 class ApiError extends Error {
-  constructor(message, { status, code, reset_at, plan } = {}) {
+  constructor(message, { status, code, reset_at, plan, retryable, partial } = {}) {
     super(message);
     this.name = "ApiError";
     this.status = status;
     this.code = code;
     this.reset_at = reset_at;
     this.plan = plan;
+    // retryable: true nếu lỗi network/5xx/timeout (caller có thể tự retry); false
+    // nếu lỗi 4xx auth/bad-request (retry vô nghĩa). Tự suy ra khi không truyền.
+    this.retryable = retryable ?? deriveRetryable({ status, code });
+    // partial: phần text đã nhận được trước khi lỗi (cho phép caller continue).
+    this.partial = partial || "";
   }
 }
 
+// Phân loại lỗi gateway: 5xx + 408/429 (không phải plan limit) + timeout/network
+// → retryable. 4xx khác (401 auth, 400 bad request, 429 plan_limit) → KHÔNG retry.
+function deriveRetryable({ status, code }) {
+  if (code === "timeout") return true;
+  if (code === "plan_limit") return false;
+  if (!status) return true; // không có status = network drop / fetch throw → retry
+  if (status >= 500) return true;
+  if (status === 408 || status === 429) return true;
+  return false;
+}
+
 async function parseError(resp) {
   let j = null;
   try {
@@ -49,6 +92,17 @@ async function parseError(resp) {
   });
 }
 
+// Tool block detection: kiểm tra text có chứa fenced ```tool đang dở (mở mà chưa
+// đóng) — nếu có, đó là tín hiệu rõ ràng stream bị cắt giữa lúc emit tool call.
+function hasUnclosedToolBlock(text) {
+  if (!text) return false;
+  const opens = (text.match(/```tool\b/g) || []).length;
+  if (opens === 0) return false;
+  // Đếm closing fence ``` sau mỗi ```tool. Heuristic: nếu số ``` lẻ → mở dở.
+  const fences = (text.match(/```/g) || []).length;
+  return fences % 2 === 1;
+}
+
 /**
  * Stream a chat/merge/search request from the gateway.
  *
@@ -62,25 +116,43 @@ async function parseError(resp) {
  *
  * @returns {Promise<{text:string, reasoning:string}>}
  */
-export async function stream({ mode = "chat", message, model, signal, onDelta, onReasoning, onStatus, idleMs = 120000, maxContinues = 6 }) {
+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 = "";
   let reasoning = "";
   let prompt = message; // prompt gửi đi: lần đầu = nguyên bản, các lần sau = nối tiếp
+  let lastFinishReason = "stop"; // stop | truncated | tool_unclosed | empty | network_drop
+  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;
 
-    // Còn nối tiếp được không? Chỉ với chat, khi bị cắt, còn lượt, và lần này có
-    // ra chữ thật (đoạn rỗng → coi như xong, tránh lặp vô tận).
-    if (!r.truncated || mode !== "chat" || attempt >= maxContinues || !r.text.trim()) break;
+    // Phát hiện thêm: tool block mở mà chưa đóng → coi như bị cắt dù gateway báo done.
+    const toolUnclosed = mode === "chat" && hasUnclosedToolBlock(fullText);
+    const truncated = r.truncated || toolUnclosed;
+
+    if (!truncated) { lastFinishReason = "stop"; break; }
+    if (mode !== "chat") { lastFinishReason = "truncated"; break; }
+
+    // Đếm chuỗi rỗng: nếu 3 lần liên tiếp model trả rỗng → upstream chết hẳn, dừng.
+    if (!r.text.trim()) {
+      emptyStreak++;
+      if (emptyStreak >= 3) { lastFinishReason = "empty"; break; }
+    } else {
+      emptyStreak = 0;
+    }
+
+    if (attempt >= maxContinues) {
+      lastFinishReason = toolUnclosed ? "tool_unclosed" : "truncated";
+      break;
+    }
     prompt = continuationPrompt(message, fullText);
   }
 
-  return { text: fullText.trim(), reasoning: reasoning.trim() };
+  return { text: fullText.trim(), reasoning: reasoning.trim(), finishReason: lastFinishReason };
 }
 
 // Dựng prompt "nối tiếp" khi câu trả lời bị cắt giữa chừng: gửi lại nguyên ngữ
@@ -103,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
@@ -113,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 = "";
@@ -139,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;
@@ -155,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(),
@@ -169,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;
@@ -194,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);
   }
 }