@noobdemon/noob-cli 1.7.7 → 1.7.10

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) {

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";
@@ -16,6 +16,7 @@ import { t } from "./i18n.js";
 import { checkLatest, runUpdate, CURRENT } from "./update.js";
 import * as sessions from "./sessions.js";
 import { loadSkill, listSkills } from "./skills.js";
+import { saveWorkflow, loadWorkflow, listWorkflows, deleteWorkflow, workflowsDir } from "./workflows.js";
 
 // Lệnh dùng cho autocomplete. Gõ "/l" → lọc các lệnh có "l" (login, logout,
 // clear, models, yolo…); ↑/↓ chọn, Tab điền, Enter chạy mục đang sáng.
@@ -31,9 +32,12 @@ const SLASH = [
   { name: "/init", desc: "quét dự án & tạo noob.md" },
   { name: "/karpathy", desc: "rà soát code (Karpathy)" },
   { name: "/frontend-design", desc: "thiết kế UI frontend chất lượng cao (skill)" },
+  { name: "/workflow", desc: "orchestrate multi-agent dynamic workflow (skill)" },
   { name: "/improve", desc: "phân tích workspace & gợi ý tính năng cải thiện" },
   { name: "/ultra", desc: "tự hành: tự nghĩ & làm nhiệm vụ" },
   { name: "/agent", desc: "bật/tắt agent mode (spawn sub-agent)" },
+  { name: "/goal", desc: "đặt HARD GOAL — model phải hướng tới tới khi /goal clear" },
+  { name: "/loop", desc: "chạy task định kỳ (vd: /loop 5m kiểm tra log) · /loop stop để dừng" },
   { name: "/tokens", desc: "xem số token đã dùng phiên này" },
   { name: "/learn", desc: "chưng cất bài học vào noob.md" },
   { name: "/memory", desc: "xem bộ nhớ noob.md" },
@@ -136,6 +140,8 @@ export async function startRepl(opts = {}) {
     yolo: !!opts.yolo || config.yoloDefault, // cờ --yolo HOẶC mặc định đã lưu (/auto-yolo)
     ultra: false, // chế độ tự hành (self-quest) đang chạy?
     agentMode: false, // /agent on → cho phép spawn_agent / spawn_agents
+    goal: null, // HARD GOAL (set qua /goal <text>) — inject vào mọi prompt tới khi /goal clear
+    loop: null, // /loop — {intervalMs, intervalStr, task, timer, ticks, startedAt} hoặc null
     extraRoots: [], // thư mục ngoài cwd được /add-dir cấp quyền (UX display only;
                     // source of truth là extraRoots trong src/tools.js)
     _longSessionWarned: false, // đã in cảnh báo phiên dài chưa (reset khi /clear)
@@ -278,16 +284,37 @@ export async function startRepl(opts = {}) {
     if (!session || !state.history.length) return; // đừng lưu phiên rỗng
     session.history = state.history; // giữ đồng bộ tuyệt đối với history sống
     session.model = state.model.id;
+    session.goal = state.goal || null; // HARD GOAL bền qua --continue/--resume
+    session.tokens = tokenMeter.serialize(); // counter cộng dồn để hiển thị nhất quán qua resume
+    // state.loop: serialize toàn bộ trừ `timer` (Timeout object không JSON được).
+    if (state.loop) {
+      const { timer, running, ...loopSnap } = state.loop;
+      session.loop = loopSnap;
+    } else {
+      session.loop = null;
+    }
     sessions.save(session);
   };
   async function restore(s) {
     session = s;
     state.history = s.history || [];
     state.mode = "chat";
+    state.goal = s.goal || null; // khôi phục HARD GOAL nếu phiên cũ có
     if (s.model) {
       const m = findModel(s.model);
       if (m) state.model = m;
     }
+    // Re-arm /loop nếu phiên cũ đang chạy loop (timer/running không serialize được).
+    if (s.loop && s.loop.task && s.loop.intervalMs) {
+      state.loop = {
+        ...s.loop,
+        running: false,
+        timer: null,
+        lastTickAt: Date.now(), // reset baseline để tick đầu chạy sau intervalMs
+      };
+      state.loop.timer = setInterval(makeLoopTick(s.loop.task), s.loop.intervalMs);
+      console.log(c.accent("  ↻ " + t.loopStatus(s.loop.intervalStr || fmtMs(s.loop.intervalMs), s.loop.task, s.loop.ticks || 0, fmtMs(s.loop.intervalMs))));
+    }
     console.log(c.ok("  ✓ " + t.sessionResumed(s.id)));
     const turns = state.history.filter((m) => m.role === "user");
     const tail = turns.slice(-5);
@@ -333,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.
@@ -357,6 +388,118 @@ Thực thi: đọc/tạo file cần thiết bằng tool, viết code production-
     persist();
   }
 
+  // /workflow <yêu cầu>           — chạy ad-hoc dynamic workflow
+  // /workflow save <name> <req>   — lưu prompt template ra ~/.noob/workflows/<name>.md
+  // /workflow run <name> [extra]  — chạy workflow đã lưu (extra context optional)
+  // /workflow load <name>         — xem nội dung workflow đã lưu (không chạy)
+  // /workflow list                — liệt kê workflow đã lưu
+  // /workflow delete <name>       — xoá workflow đã lưu
+  // Cảm hứng tweet_dump.txt L183–193 ("saving and sharing dynamic workflows").
+  async function runWorkflow(arg) {
+    if (!config.apiKey) return console.log(c.tool("  " + t.notLoggedIn));
+    if (!arg) return console.log(c.err("  " + (t.workflowNeedArg || "Cách dùng: /workflow <mô tả task lớn cần orchestrate>")));
+    // Detect sub-command. Sub-command tách bằng khoảng trắng đầu tiên.
+    const m = arg.match(/^(save|run|load|list|delete|rm|ls)\b\s*([\s\S]*)$/i);
+    if (m) {
+      const sub = m[1].toLowerCase();
+      const rest = m[2].trim();
+      if (sub === "list" || sub === "ls") return workflowList();
+      if (sub === "load") return workflowLoad(rest);
+      if (sub === "delete" || sub === "rm") return workflowDelete(rest);
+      if (sub === "save") return workflowSave(rest);
+      if (sub === "run") return workflowRun(rest);
+    }
+    // Default: ad-hoc workflow (giữ behavior cũ).
+    await workflowExecute(arg);
+  }
+
+  // Chạy thật workflow prompt — chia sẻ giữa ad-hoc và `run <name>`.
+  async function workflowExecute(userRequest) {
+    const skill = loadSkill("dynamic-workflows");
+    if (!skill) return console.log(c.err("  " + (t.workflowNoSkill || "Không tìm thấy skill dynamic-workflows")));
+    if (!state.agent) {
+      state.agent = true;
+      console.log(c.tool("  " + (t.workflowAgentAutoOn || "agent mode tự bật cho /workflow")));
+    }
+    const prompt = `Bạn đang thực thi SKILL "dynamic-workflows". Đọc kỹ playbook dưới đây và TUÂN THỦ khi orchestrate multi-agent workflow.
+
+=== SKILL: dynamic-workflows ===
+${skill}
+=== HẾT SKILL ===
+
+YÊU CẦU NGƯỜI DÙNG:
+${userRequest}
+
+Thực thi:
+1. Viết PLAN ngắn (sub-tasks, sequential vs parallel, synthesis step, stop condition).
+2. Spawn sub-agent theo plan — dùng spawn_agents cho công việc song song độc lập, spawn_agent tuần tự khi có phụ thuộc.
+3. Mỗi prompt sub-agent đều có GOAL / INPUTS / METHOD / OUTPUT SHAPE / STOP CONDITION (theo skill).
+4. Gom kết quả, dedupe, reconcile xung đột, viết báo cáo cuối tiếng Việt cho người dùng. Sub-agent KHÔNG nói trực tiếp với user.`;
+    console.log(c.tool("  🎼 " + (t.workflowRunning || "Dynamic workflow running…")));
+    await handle(prompt);
+    persist();
+  }
+
+  function workflowList() {
+    const items = listWorkflows();
+    if (!items.length) {
+      console.log(c.dim("  " + (t.workflowListEmpty ? t.workflowListEmpty(workflowsDir()) : `Chưa có workflow đã lưu. Tạo bằng /workflow save <name> <yêu cầu>. Thư mục: ${workflowsDir()}`)));
+      return;
+    }
+    console.log(c.tool("  " + (t.workflowListHeader ? t.workflowListHeader(workflowsDir()) : `Workflow đã lưu (${workflowsDir()}):`)));
+    for (const it of items) {
+      const desc = it.description ? c.dim(" — " + it.description) : "";
+      const date = it.updated ? c.dim(" [" + it.updated.slice(0, 10) + "]") : "";
+      console.log("    " + c.accent(it.name) + desc + date);
+    }
+  }
+
+  function workflowLoad(name) {
+    if (!name) return console.log(c.err("  " + (t.workflowLoadNeedName || "Cách dùng: /workflow load <name>")));
+    const r = loadWorkflow(name);
+    if (!r.ok) return console.log(c.err("  " + (t.workflowLoadError ? t.workflowLoadError(name, r.error) : `Không nạp được workflow '${name}': ${r.error}`)));
+    console.log(c.tool("  " + (t.workflowLoadOk ? t.workflowLoadOk(r.name, r.path) : `Workflow '${r.name}' (${r.path}):`)));
+    if (r.meta.description) console.log(c.dim("    " + r.meta.description));
+    if (r.meta.updated) console.log(c.dim("    updated: " + r.meta.updated));
+    console.log("");
+    console.log(r.prompt);
+  }
+
+  function workflowDelete(name) {
+    if (!name) return console.log(c.err("  " + (t.workflowDeleteNeedName || "Cách dùng: /workflow delete <name>")));
+    const r = deleteWorkflow(name);
+    if (!r.ok) return console.log(c.err("  " + (t.workflowDeleteError ? t.workflowDeleteError(name, r.error) : `Không xoá được workflow '${name}': ${r.error}`)));
+    console.log(c.tool("  " + (t.workflowDeleteOk ? t.workflowDeleteOk(name) : `Đã xoá workflow '${name}'.`)));
+  }
+
+  function workflowSave(rest) {
+    // /workflow save <name> <yêu cầu...>
+    const m = rest.match(/^(\S+)\s+([\s\S]+)$/);
+    if (!m) return console.log(c.err("  " + (t.workflowSaveNeedArgs || "Cách dùng: /workflow save <name> <yêu cầu workflow>")));
+    const name = m[1];
+    const prompt = m[2].trim();
+    const r = saveWorkflow(name, prompt);
+    if (!r.ok) {
+      const msg = r.error === "invalid_name"
+        ? (t.workflowSaveBadName ? t.workflowSaveBadName(name) : `Tên workflow không hợp lệ: '${name}'. Chỉ chấp nhận [a-z0-9_-], bắt đầu bằng chữ/số, tối đa 64 ký tự.`)
+        : (t.workflowSaveError ? t.workflowSaveError(name, r.error) : `Không lưu được workflow '${name}': ${r.error}`);
+      return console.log(c.err("  " + msg));
+    }
+    console.log(c.tool("  💾 " + (t.workflowSaveOk ? t.workflowSaveOk(name, r.path) : `Đã lưu workflow '${name}' → ${r.path}`)));
+  }
+
+  async function workflowRun(rest) {
+    if (!rest) return console.log(c.err("  " + (t.workflowRunNeedName || "Cách dùng: /workflow run <name> [thêm ngữ cảnh]")));
+    const m = rest.match(/^(\S+)(?:\s+([\s\S]+))?$/);
+    const name = m[1];
+    const extra = (m[2] || "").trim();
+    const r = loadWorkflow(name);
+    if (!r.ok) return console.log(c.err("  " + (t.workflowRunError ? t.workflowRunError(name, r.error) : `Không nạp được workflow '${name}': ${r.error}`)));
+    const userRequest = extra ? `${r.prompt}\n\nNgữ cảnh bổ sung cho lần chạy này:\n${extra}` : r.prompt;
+    console.log(c.tool("  ▶️  " + (t.workflowRunOk ? t.workflowRunOk(name) : `Chạy workflow đã lưu '${name}'…`)));
+    await workflowExecute(userRequest);
+  }
+
   // /improve [hint] — model rà soát workspace & đề xuất tính năng/cải tiến.
   // KHÔNG sửa code, chỉ phân tích & đề xuất.
   async function runImprove(arg) {
@@ -396,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}
 
@@ -429,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));
@@ -458,6 +628,125 @@ Tự đánh giá: còn THIẾU gì để đạt mục tiêu? Chọn 1 nhiệm v
     }
   }
 
+  // /loop — chạy task định kỳ (tweet_dump.txt: "Pair triage workflows with /loop
+  // to have Claude do this continuously" + "be run at regular intervals"). Combo
+  // tự nhiên với /goal (hard completion req) — gõ /goal trước, rồi /loop để chạy
+  // task tới khi goal đạt qua từng tick.
+  // Cú pháp: /loop <interval> <task>  (vd: /loop 5m kiểm tra log lỗi mới)
+  //         /loop stop  — dừng loop hiện tại
+  //         /loop       — xem trạng thái
+  // Interval parser: 30s / 5m / 1h / 2h30m / 90s — số + đơn vị (s/m/h), nối được.
+  function parseInterval(s) {
+    if (!s) return null;
+    const re = /(\d+)\s*(h|m|s)/gi;
+    let total = 0, matched = false, m;
+    while ((m = re.exec(s)) !== null) {
+      matched = true;
+      const n = parseInt(m[1], 10);
+      const u = m[2].toLowerCase();
+      if (u === "h") total += n * 3600_000;
+      else if (u === "m") total += n * 60_000;
+      else total += n * 1000;
+    }
+    if (!matched || total < 5000) return null; // tối thiểu 5s — tránh hammer
+    return total;
+  }
+  function fmtMs(ms) {
+    if (ms < 60_000) return Math.round(ms / 1000) + "s";
+    if (ms < 3600_000) {
+      const m = Math.floor(ms / 60_000), s = Math.round((ms % 60_000) / 1000);
+      return s ? `${m}m${s}s` : `${m}m`;
+    }
+    const h = Math.floor(ms / 3600_000), mm = Math.round((ms % 3600_000) / 60_000);
+    return mm ? `${h}h${mm}m` : `${h}h`;
+  }
+  function stopLoop() {
+    if (!state.loop) return false;
+    clearInterval(state.loop.timer);
+    state.loop = null;
+    return true;
+  }
+  // Factory tạo tick handler — tách ra để cả runLoop và restore() dùng chung.
+  // Capture task qua tham số (không phải closure scope) → re-arm được sau resume.
+  function makeLoopTick(task) {
+    return async () => {
+      if (!state.loop) return; // đã bị stop
+      if (state.loop.running) return; // tick trước còn chạy → skip lượt này
+      state.loop.running = true;
+      state.loop.ticks++;
+      state.loop.lastTickAt = Date.now();
+      try {
+        console.log(c.dim("  " + t.loopTick(state.loop.ticks)));
+        const answer = await handle(loopTickPrompt(task, state.loop.ticks));
+        persist();
+        if (loopIsDone(answer)) {
+          console.log(c.ok("  ✓ " + t.loopAutoStop(state.loop.ticks)));
+          stopLoop();
+        }
+        // [GỠ BUDGET 2026-06-06] Không còn cap token cho /loop — loop dừng theo
+        // <<LOOP_DONE>> hoặc /loop stop, không bị cắt giữa chừng vì "hết token".
+      } catch (e) {
+        console.log(c.err("  loop tick lỗi: " + (e?.message || e)));
+      } finally {
+        if (state.loop) state.loop.running = false;
+      }
+    };
+  }
+  // /loop auto-stop: model phát token <<LOOP_DONE>> ở CUỐI reply khi thấy không
+  // còn việc / goal đã đạt → loop tự dừng. Combo tự nhiên với /goal: gõ /goal
+  // trước rồi /loop, model tự đánh giá goal mỗi tick và phát LOOP_DONE khi đủ.
+  const LOOP_DONE = "<<LOOP_DONE>>";
+  const loopIsDone = (a) => a && a.trimEnd().endsWith(LOOP_DONE);
+  const loopTickPrompt = (task, n) => `[LOOP tick #${n}] ${task}
+
+Đây là tick định kỳ trong chế độ /loop. Làm việc bình thường — đọc/sửa file, chạy lệnh nếu cần.
+Sau khi xong tick này, TỰ ĐÁNH GIÁ:
+- Nếu còn việc / điều kiện chưa đạt → trả lời bình thường, KHÔNG phát token.
+- Nếu task này đã hoàn tất hẳn (mọi điều cần làm đều đã làm, hoặc goal nếu có đã đạt) và không còn lý do để tick tiếp → đặt token ${LOOP_DONE} TRÊN MỘT DÒNG RIÊNG ở CUỐI reply để dừng loop.`;
+
+  async function runLoop(arg) {
+    const a = (arg || "").trim();
+    // /loop (no arg) → status
+    if (!a) {
+      if (!state.loop) return console.log(c.dim("  " + t.loopNotRunning) + c.dim("  " + t.loopNeedArgs));
+      const L = state.loop;
+      const elapsed = Date.now() - L.lastTickAt;
+      const nextIn = Math.max(0, L.intervalMs - elapsed);
+      return console.log(c.accent("  " + t.loopStatus(L.intervalStr, L.task, L.ticks, fmtMs(nextIn))));
+    }
+    // /loop stop
+    if (/^(stop|off|dừng|dung|tắt|tat)$/i.test(a)) {
+      if (stopLoop()) console.log(c.ok("  " + t.loopStopped));
+      else console.log(c.dim("  " + t.loopNotRunning));
+      return;
+    }
+    if (state.loop) return console.log(c.err("  " + t.loopAlreadyRunning));
+    if (!config.apiKey) return console.log(c.tool("  " + t.notLoggedIn));
+    // parse <interval> <task>
+    // [GỠ BUDGET 2026-06-06] Cú pháp đơn giản: /loop <interval> <task>. Không còn cap token.
+    const firstSpace = a.search(/\s/);
+    if (firstSpace < 0) return console.log(c.err("  " + t.loopNeedArgs));
+    const intervalStr = a.slice(0, firstSpace).trim();
+    const task = a.slice(firstSpace + 1).trim();
+    if (!task) return console.log(c.err("  " + t.loopNeedArgs));
+    const intervalMs = parseInterval(intervalStr);
+    if (!intervalMs) return console.log(c.err("  " + t.loopBadInterval(intervalStr)));
+    const normInterval = fmtMs(intervalMs);
+    state.loop = {
+      intervalMs,
+      intervalStr: normInterval,
+      task,
+      ticks: 0,
+      startedAt: Date.now(),
+      lastTickAt: Date.now(),
+      running: false, // chống re-entrant (tick trước chưa xong, tick sau tới)
+      timer: null,
+    };
+    console.log(c.accent("  " + t.loopStarted(normInterval, task)));
+    state.loop.timer = setInterval(makeLoopTick(task), intervalMs);
+    // KHÔNG tick ngay — user có thể muốn gõ thêm lệnh khác trước khi tick đầu chạy.
+  }
+
   // /init — quét dự án & sinh noob.md tổng quan (giống `/init` của Claude Code).
   // Nếu noob.md đã có: hỏi xác nhận ghi đè trước khi giao việc cho model.
   async function runInit() {
@@ -748,18 +1037,28 @@ NGUYÊN TẮC:
           console.log(chalk.hex("#8b5cf6")(`  ⊕ spawn ${tasks.length} sub-agent (depth ${depth + 1}/${MAX_SUBAGENT_DEPTH})`));
           startSpin(t.thinking);
           try {
-            const results = await Promise.all(tasks.map((task, i) =>
-              runSubAgent({
+            const results = await Promise.all(tasks.map((task, i) => {
+              // Per-sub-agent model routing: task.model có thể là id model hoặc tên thân thiện.
+              // findModel() resolve cả hai; nếu không match thì fallback model của cha.
+              let subModel = state.model.id;
+              let modelTag = "";
+              if (task?.model) {
+                const m = findModel(task.model);
+                if (m) { subModel = m.id; modelTag = ` [${m.name}]`; }
+                else modelTag = ` [model "${task.model}" không khớp — dùng ${state.model.name}]`;
+              }
+              // [GỠ BUDGET 2026-06-06] Sub-agent chạy không giới hạn token.
+              return runSubAgent({
                 task: task?.task || task?.prompt || "",
                 context: task?.context || "",
                 depth: depth + 1,
-                model: state.model.id,
+                model: subModel,
                 signal: abort.signal,
                 tokenMeter,
                 dispatchTool: (n, inp) => dispatchTool(n, inp, depth + 1),
-                onLog: (msg) => { stopSpin(); console.log(chalk.hex("#8b5cf6")("  " + msg)); startSpin(t.thinking); },
-              }).then((r) => `── sub-agent #${i + 1} ──\n${r}`).catch((e) => `── sub-agent #${i + 1} (LỖI) ──\n${e?.message || String(e)}`)
-            ));
+                onLog: (msg) => { stopSpin(); console.log(chalk.hex("#8b5cf6")("  " + msg + modelTag)); startSpin(t.thinking); },
+              }).then((r) => `── sub-agent #${i + 1}${modelTag} ──\n${r}`).catch((e) => `── sub-agent #${i + 1}${modelTag} (LỖI) ──\n${e?.message || String(e)}`);
+            }));
             return { allow: true, result: results.join("\n\n") };
           } catch (err) {
             return { allow: true, result: "ERROR sub-agent: " + (err?.message || String(err)) };
@@ -776,6 +1075,7 @@ NGUYÊN TẮC:
         model: state.model.id,
         signal: abort.signal,
         tokenMeter,
+        goal: state.goal,
         extraToolsDoc: state.agentMode ? spawnAgentToolsDoc(0) : "",
         onStatus: () => tick(t.thinking),
         onSteer: () => {
@@ -884,7 +1184,7 @@ NGUYÊN TẮC:
 
     tui.status(c.dim("  " + t.running));
     try {
-      const result = await runTool(name, input);
+      const result = await runTool(name, input, { signal: abort?.signal });
       tui.status(null);
       console.log(c.ok("  ✓ ") + c.dim(firstLine(result)));
       return { allow: true, result };
@@ -964,6 +1264,24 @@ NGUYÊN TẮC:
         console.log((state.agentMode ? c.accent : c.dim)("  agent mode: " + (state.agentMode ? "BẬT (spawn_agent / spawn_agents khả dụng, depth tối đa " + MAX_SUBAGENT_DEPTH + ")" : "tắt")));
         break;
       }
+      case "goal": {
+        // HARD GOAL = completion requirement (xem tweet_dump.txt mục "Combine
+        // with /goal and /loop"). Set xong sẽ inject vào MỌI prompt tới khi clear.
+        const v = arg.trim();
+        if (!v) {
+          if (state.goal) console.log(c.accent("  🎯 goal: ") + state.goal);
+          else console.log(c.dim("  chưa đặt goal. Cú pháp: /goal <mục tiêu> · /goal clear để xoá"));
+        } else if (v.toLowerCase() === "clear" || v.toLowerCase() === "off" || v.toLowerCase() === "xoá" || v.toLowerCase() === "xoa") {
+          state.goal = null;
+          console.log(c.dim("  đã xoá goal"));
+          persist();
+        } else {
+          state.goal = v;
+          console.log(c.accent("  🎯 đã đặt goal: ") + v);
+          persist();
+        }
+        break;
+      }
       case "tokens": {
         console.log(c.dim(`  tokens — input: ${tokenMeter.input.toLocaleString("vi-VN")} · output: ${tokenMeter.output.toLocaleString("vi-VN")} · tổng: ${tokenMeter.total.toLocaleString("vi-VN")} · ${tokenMeter.format()}`));
         break;
@@ -982,6 +1300,11 @@ NGUYÊN TẮC:
       case "fd":
         await runFrontendDesign(arg);
         break;
+      case "workflow":
+      case "wf":
+      case "ultracode":
+        await runWorkflow(arg);
+        break;
       case "improve":
       case "imp":
         await runImprove(arg);
@@ -990,6 +1313,9 @@ NGUYÊN TẮC:
       case "u":
         await runUltra(arg);
         break;
+      case "loop":
+        await runLoop(arg);
+        break;
       case "init":
         await runInit();
         break;
@@ -1264,6 +1590,9 @@ function printHelp() {
         "  " + t.cmdFrontendDesign,
       "  " + t.cmdImprove,
         "  " + t.cmdUltra,
+        "  " + t.cmdWorkflow,
+        "  " + t.cmdGoal,
+        "  " + t.cmdLoop,
         "  " + t.cmdLearn,
         "  " + t.cmdCompact,
         "  " + t.cmdMemory,