@noobdemon/noob-cli 1.7.7 → 1.7.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noobdemon/noob-cli",
-  "version": "1.7.7",
+  "version": "1.7.8",
   "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,12 +277,17 @@ 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) {
+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) → extraToolsDoc → runtimeContext → filesLedger →
-  // CONVERSATION. noob.md (đặc biệt phần `## Rules`) phải nằm sát SYSTEM để model coi là luật.
+  // 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.
   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", "");
   for (const m of msgs) {
@@ -339,7 +360,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 +376,38 @@ 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);
+    const prompt = buildPrompt(history, extraToolsDoc, goal);
     tokenMeter?.addInput(countTokens(prompt));
     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: prompt, 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 +418,48 @@ 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, 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,
+        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

@@ -26,16 +26,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 +65,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 +89,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, signal, onDelta, onReasoning, onStatus, idleMs = 120000, 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 });
     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ữ

package/src/i18n.js

@@ -65,6 +65,9 @@ export const t = {
   cmdFrontendDesign: "/frontend-design <yêu cầu>  thiết kế UI frontend chất lượng cao theo skill (/fd)",
   cmdImprove: "/improve [hint]  phân tích workspace & đề xuất tính năng cải thiện (/imp)",
   cmdUltra: "/ultra <mục tiêu>  tự hành: noob tự nghĩ & tự làm nhiệm vụ tới khi xong (/u)",
+  cmdWorkflow: "/workflow <yêu cầu>|save|list|load|run|delete  dynamic workflow đa sub-agent (/wf, /ultracode)",
+  cmdGoal: "/goal <text>|clear  đặt HARD GOAL cho phiên (chống goal drift; không arg = xem)",
+  cmdLoop: "/loop <interval> <task>  chạy task lặp lại (vd /loop 10m triage); /loop stop để dừng",
   cmdLearn: "/learn [ghi chú]  chưng cất bài học của phiên vào noob.md",
   cmdCompact: "/compact         tóm tắt phiên ngay để gọn ngữ cảnh (giữ trí nhớ dài hạn)",
   cmdMemory: "/memory          xem bộ nhớ noob.md (/mem)",
@@ -114,6 +117,18 @@ export const t = {
   ultraMax: "Ultra: chạm giới hạn số vòng — dừng để bạn kiểm tra & ra lệnh tiếp.",
   ultraNeedGoal: "Cần mục tiêu. Dùng: /ultra <mô tả mục tiêu>",
   ultraQuest: (n) => `tự nghĩ nhiệm vụ kế tiếp (vòng ${n})…`,
+  loopNeedArgs: "Cần task. Dùng: /loop <interval> <task>  (vd: /loop 5m kiểm tra log lỗi mới)  ·  /loop stop để dừng  ·  /loop để xem trạng thái",
+  loopBadInterval: (s) => `interval không hợp lệ: "${s}". Dùng dạng 30s / 5m / 1h / 2h30m.`,
+  loopStarted: (interval, task) => `🔁 Loop BẬT — chạy mỗi ${interval} (không giới hạn token): ${task}`,
+  // [GỠ BUDGET 2026-06-06] loopBadBudget + loopBudgetExceeded giữ lại để tương thích ngược nếu có code cũ gọi, không dùng nữa.
+  loopBadBudget: (s) => `(deprecated) ngân sách không còn được hỗ trợ: "${s}".`,
+  loopBudgetExceeded: (used, budget, ticks) => `(deprecated) loop không còn cap token.`,
+  loopStopped: "🔁 Loop đã dừng.",
+  loopNotRunning: "Không có loop nào đang chạy.",
+  loopStatus: (interval, task, ticks, nextIn) => `🔁 Loop: chạy mỗi ${interval} · đã ${ticks} lần · lần kế trong ~${nextIn}\n   task: ${task}`,
+  loopTick: (n) => `🔁 loop tick #${n}…`,
+  loopAutoStop: (n) => `Loop tự dừng sau tick #${n} — model phát <<LOOP_DONE>> (task hoàn tất).`,
+  loopAlreadyRunning: "Đã có loop đang chạy. /loop stop trước khi đặt loop mới.",
   learning: "đang chưng cất bài học vào noob.md…",
   compactRunning: "đang tóm tắt phiên để gọn ngữ cảnh…",
   compactEmpty: "Phiên còn trống — không có gì để tóm tắt.",
@@ -129,6 +144,26 @@ export const t = {
   improveRunning: "đang khảo sát workspace & soạn đề xuất cải thiện…",
   frontendDesignNoSkill: "không tìm thấy skills/frontend-design/SKILL.md — skill chưa được cài.",
   frontendDesignNeedReq: "cần mô tả yêu cầu. Ví dụ: /frontend-design landing page cho app nghe nhạc lo-fi",
+  workflowRunning: "đang chạy dynamic workflow đa sub-agent…",
+  workflowNoSkill: "không tìm thấy skills/dynamic-workflows/SKILL.md — skill chưa được cài.",
+  workflowNeedArg: "cần mô tả task. Ví dụ: /workflow audit toàn bộ src/ tìm lỗ hổng SQL injection",
+  workflowAgentAutoOn: "agent mode tự bật cho /workflow (cần spawn_agent)",
+  // saved workflows (CRUD)
+  workflowListEmpty: (dir) => `Chưa có workflow đã lưu. Tạo bằng /workflow save <name> <yêu cầu>. Thư mục: ${dir}`,
+  workflowListHeader: (dir) => `Workflow đã lưu (${dir}):`,
+  workflowSaveNeedArgs: "Cách dùng: /workflow save <name> <yêu cầu workflow>",
+  workflowSaveBadName: (n) => `Tên workflow không hợp lệ: '${n}'. Chỉ chấp nhận [a-z0-9_-], bắt đầu bằng chữ/số, tối đa 64 ký tự.`,
+  workflowSaveError: (n, e) => `Không lưu được workflow '${n}': ${e}`,
+  workflowSaveOk: (n, p) => `Đã lưu workflow '${n}' → ${p}`,
+  workflowRunNeedName: "Cách dùng: /workflow run <name> [thêm ngữ cảnh]",
+  workflowRunError: (n, e) => `Không nạp được workflow '${n}': ${e}`,
+  workflowRunOk: (n) => `Chạy workflow đã lưu '${n}'…`,
+  workflowLoadNeedName: "Cách dùng: /workflow load <name>",
+  workflowLoadError: (n, e) => `Không nạp được workflow '${n}': ${e}`,
+  workflowLoadOk: (n, p) => `Workflow '${n}' (${p}):`,
+  workflowDeleteNeedName: "Cách dùng: /workflow delete <name>",
+  workflowDeleteError: (n, e) => `Không xoá được workflow '${n}': ${e}`,
+  workflowDeleteOk: (n) => `Đã xoá workflow '${n}'.`,
   initOverwriteWarn: (p) => `⚠ Đã có noob.md tại ${p}. /init sẽ ghi đè nội dung hiện tại.`,
   initOverwriteConfirm: "Ghi đè? gõ 'y' để xác nhận, phím khác để huỷ › ",
   initCancel: "Huỷ /init — giữ nguyên noob.md.",

package/src/models.js

@@ -50,7 +50,20 @@ export const PROVIDERS = {
 export const DEFAULT_MODEL = "gateway-claude-opus-4-7";
 
 export function findModel(id) {
-  return MODELS.find((m) => m.id === id);
+  if (!id || typeof id !== "string") return undefined;
+  // Tier 1: exact id match (đường nhanh, dùng cho config + state nội bộ).
+  let hit = MODELS.find((m) => m.id === id);
+  if (hit) return hit;
+  // Tier 2: match mở rộng cho input từ model (sub-agent routing) hoặc user gõ tay.
+  // Bỏ prefix "gateway-", chuẩn hoá dấu (- _ . space → -), so id/name không phân biệt hoa thường.
+  const norm = (s) => String(s).toLowerCase().replace(/^gateway-/, "").replace(/[\s_.]+/g, "-").replace(/-+/g, "-");
+  const q = norm(id);
+  // Exact normalized match trước (tránh "opus" lỡ tay match nhầm "opus-4-1" khi muốn "opus-4-7").
+  hit = MODELS.find((m) => norm(m.id) === q || norm(m.name) === q);
+  if (hit) return hit;
+  // Tier 3: contains — chấp nhận khi CHỈ có 1 match duy nhất (tránh ambiguous).
+  const subs = MODELS.filter((m) => norm(m.id).includes(q) || norm(m.name).includes(q));
+  return subs.length === 1 ? subs[0] : undefined;
 }
 
 export function providerColor(providerKey) {