@noobdemon/noob-cli 1.7.6 → 1.7.8

package/src/repl.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);
@@ -357,6 +384,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) {
@@ -458,6 +597,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 +1006,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 +1044,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 +1153,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 +1233,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 +1269,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 +1282,9 @@ NGUYÊN TẮC:
       case "u":
         await runUltra(arg);
         break;
+      case "loop":
+        await runLoop(arg);
+        break;
       case "init":
         await runInit();
         break;
@@ -1264,6 +1559,9 @@ function printHelp() {
         "  " + t.cmdFrontendDesign,
       "  " + t.cmdImprove,
         "  " + t.cmdUltra,
+        "  " + t.cmdWorkflow,
+        "  " + t.cmdGoal,
+        "  " + t.cmdLoop,
         "  " + t.cmdLearn,
         "  " + t.cmdCompact,
         "  " + t.cmdMemory,

package/src/subagent.js

@@ -1,67 +1,126 @@
-// Sub-agent: chạy một runAgent() con với history độc lập, dùng chung tool
-// runtime của cha. Hỗ trợ phân cấp (sub-agent có thể đẻ sub-agent tiếp) nhưng
-// giới hạn độ sâu để không nổ. Hỗ trợ song song qua spawn_agents (mảng).
-import { runAgent } from "./agent.js";
-import { TokenMeter } from "./tokens.js";
+// Sub-agent: chạy một runAgent() con với history riêng, dùng chung dispatcher tool
+// của cha. Cha (repl.js) truyền `dispatchTool` vào — cha là source of truth cho:
+//   - permission/approve UI
+//   - in log tool-call
+//   - xử lý spawn_agent lồng nhau (cha tự tăng depth khi forward xuống)
+//
+// Contract với cha (xem repl.js dispatcher spawn_agent/spawn_agents):
+//   Cha gọi: runSubAgent({ task, context, model, signal, tokenMeter, dispatchTool, depth, onLog })
+//   - dispatchTool(name, input) → Promise<{ allow, result }>  (cùng format runAgent.onTool kỳ vọng)
+//   - tokenMeter: cha truyền meter của phiên → token sub-agent cộng dồn vào tổng
+//   - signal: cha truyền abort.signal → cha Ctrl+C thì con dừng theo
+//   - depth: cha tăng sẵn (depth+1) trước khi gọi; sub-agent chỉ dùng để biết còn được spawn cháu hay không
+//
+// Trả về: Promise<string> — text cuối của sub-agent, để cha ghép vào tool result.
+//
+// Depth guard: MAX_SUBAGENT_DEPTH = 3. Khi depth >= MAX, sub-agent vẫn chạy nhưng
+// extraToolsDoc rỗng → model không thấy spawn_agent nữa, không spawn cháu được.
+// Cha cũng có guard riêng (line ~1001 repl.js) chặn spawn vượt MAX, đây là defence-in-depth.
+
+import { runAgent } from './agent.js';
 
 export const MAX_SUBAGENT_DEPTH = 3;
 
-// Tài liệu tool spawn_agent — chèn vào prompt khi agent mode bật. Mô tả cho
-// model biết WHEN dùng (task lớn, chia được) và HOW (song song vs tuần tự).
-export function spawnAgentToolsDoc(depth = 0) {
-  const canSpawn = depth < MAX_SUBAGENT_DEPTH;
-  return `# AGENT MODE — multi-agent
+export async function runSubAgent({
+  task,
+  context = '',
+  model,
+  signal,
+  tokenMeter,
+  dispatchTool,
+  depth = 1,
+  onLog,
+}) {
+  if (typeof dispatchTool !== 'function') {
+    throw new Error('runSubAgent: dispatchTool (từ cha) là bắt buộc');
+  }
+  if (!task || typeof task !== 'string') {
+    throw new Error('runSubAgent: task (string) là bắt buộc');
+  }
 
-Bạn đang ở chế độ AGENT. Khi gặp task LỚN có thể chia nhỏ, hãy ủy thác cho sub-agent thay vì tự làm hết một mình:
+  // Prompt khởi tạo: nêu rõ task + context (nếu có). Sub-agent có history riêng,
+  // KHÔNG kế thừa từ cha → giảm nhiễu, tiết kiệm token.
+  const userPrompt = context
+    ? `# Nhiệm vụ con\n${task}\n\n# Ngữ cảnh từ agent cha\n${context}`
+    : `# Nhiệm vụ con\n${task}`;
 
-- spawn_agent  {"task": str, "context"?: str}  — đẻ MỘT sub-agent làm "task". "context" là phần ngữ cảnh cần truyền (file paths, quyết định đã chốt, ràng buộc). Sub-agent có TOÀN BỘ tool (read/write/edit/run/grep/glob…) và history RIÊNG (không thấy hội thoại của bạn). Nó trả về một chuỗi tóm tắt kết quả.
-- spawn_agents {"tasks": [{"task": str, "context"?: str}, …]} — đẻ NHIỀU sub-agent CHẠY SONG SONG. Chỉ dùng khi các task ĐỘC LẬP (không phụ thuộc kết quả của nhau). Trả về mảng tóm tắt theo đúng thứ tự tasks.
+  const history = [{ role: 'user', content: userPrompt }];
 
-Quy tắc dùng:
-1. TUẦN TỰ (task B cần kết quả task A): gọi spawn_agent cho A, đọc kết quả, rồi spawn_agent cho B. KHÔNG dùng spawn_agents.
-2. SONG SONG (các task không liên quan): dùng MỘT lần spawn_agents với mảng tasks. Tiết kiệm thời gian.
-3. PHÂN CẤP (task phức tạp): sub-agent của bạn cũng có spawn_agent, nó tự chia tiếp. Độ sâu tối đa hiện tại: ${MAX_SUBAGENT_DEPTH} (bạn đang ở depth=${depth}${canSpawn ? "" : " — đã chạm trần, KHÔNG được spawn nữa, tự làm"}).
-4. Việc NHỎ/đơn giản: cứ tự làm, đừng spawn cho có. Spawn có overhead (mỗi sub-agent là 1 phiên model riêng → tốn token).
-5. Sau khi gom kết quả từ sub-agent, BẠN là người tổng hợp + trả lời cuối cho user. Sub-agent không nói chuyện trực tiếp với user.
+  // Nếu chưa chạm trần depth, cho phép spawn cháu. Chạm trần → bỏ doc.
+  const extraToolsDoc =
+    depth < MAX_SUBAGENT_DEPTH ? spawnAgentToolsDoc(depth) : '';
 
-Ví dụ song song: "viết test cho 3 module độc lập" → spawn_agents với 3 tasks.
-Ví dụ tuần tự: "thiết kế schema rồi viết migration" → spawn_agent(thiết kế) → đọc → spawn_agent(viết migration với schema đó).
-Ví dụ phân cấp: cha giao "build full app" → đẻ 1 sub-agent "build backend" → sub-agent đó tự đẻ tiếp "viết auth", "viết CRUD" song song.`;
-}
+  // onTool: forward thẳng dispatcher cha. Cha sẽ tự tăng depth khi spawn lồng
+  // (xem repl.js line 1027: `(n, inp) => dispatchTool(n, inp, depth + 1)`).
+  const onTool = async (name, input) => dispatchTool(name, input);
+
+  if (onLog) onLog(`▶ sub-agent depth=${depth} bắt đầu: ${task.slice(0, 80)}${task.length > 80 ? '…' : ''}`);
 
-// Chạy một sub-agent. dispatchTool: hàm để thực thi tool con (chia sẻ với cha).
-// model: dùng chung model của cha. onLog: callback để log tiến độ ra UI cha.
-export async function runSubAgent({ task, context, model, signal, dispatchTool, depth = 1, onLog, tokenMeter }) {
-  const sys = `Bạn là SUB-AGENT (depth=${depth}) được agent cha ủy thác MỘT nhiệm vụ cụ thể.
-
-# Cách làm việc
-- Tự quyết với thông tin được cấp + tự khám phá filesystem (list_dir/glob/grep/read_file). KHÔNG hỏi lại cha.
-- History của bạn TÁCH BIỆT với cha. Cha CHỈ thấy chuỗi trả lời cuối của bạn → hãy là một bản tóm tắt cô đọng (mục tiêu 1–2k token): mọi file đã đụng, phát hiện then chốt, lỗi/cảnh báo, và các đầu mối cha cần để hành động tiếp. Bỏ chi tiết quá trình thừa.
-- Làm điều nhỏ nhất giải quyết trọn vẹn nhiệm vụ. Không drive-by refactor.
-- Verify khi hợp lý (chạy build/test/lint). Báo trung thực phần đã/chưa verify.
-
-# NHIỆM VỤ
-${task}
-${context ? `\n# NGỮ CẢNH TỪ CHA\n${context}` : ""}`;
-  const history = [{ role: "user", content: sys }];
-  // Dùng chung meter của cha nếu được truyền vào → token sub-agent cộng dồn
-  // vào tổng phiên. Nếu không có thì tự tạo cục bộ (giữ tương thích cũ).
-  const meter = tokenMeter || new TokenMeter();
-  const before = { input: meter.input, output: meter.output };
-  onLog?.(`↳ sub-agent (depth=${depth}) bắt đầu: ${task.slice(0, 80)}${task.length > 80 ? "…" : ""}`);
   const result = await runAgent({
     history,
     model,
     signal,
-    tokenMeter: meter,
-    extraToolsDoc: spawnAgentToolsDoc(depth),
-    onTool: (name, input) => dispatchTool(name, input, depth),
-    onStatus: () => {},
-    onDelta: () => {},
-    onSteer: () => [],
+    tokenMeter,
+    onTool,
+    extraToolsDoc,
+    goal: task,
   });
-  const used = { input: meter.input - before.input, output: meter.output - before.output };
-  onLog?.(`↳ sub-agent (depth=${depth}) xong (↑${used.input} ↓${used.output})`);
-  // Trả về string sạch để cha (model) đọc dễ. Token đã cộng vào meter rồi.
-  return result;
+
+  if (onLog) onLog(`✓ sub-agent depth=${depth} xong`);
+
+  // runAgent trả về text cuối (assistant message không có tool block).
+  return typeof result === 'string' ? result : String(result ?? '');
+}
+
+// Tài liệu tool spawn_agent / spawn_agents để chèn vào prompt khi agent mode bật.
+// Dài & cụ thể vì model cần đủ context để dùng đúng (routing, depth, format).
+export function spawnAgentToolsDoc(depth = 0) {
+  const remaining = MAX_SUBAGENT_DEPTH - depth;
+  if (remaining <= 0) return '';
+  return `
+# Sub-agent tools (agent mode đang BẬT, depth=${depth}, MAX_SUBAGENT_DEPTH=${MAX_SUBAGENT_DEPTH})
+
+Khi nhiệm vụ phức tạp / chia được thành nhiều phần độc lập, bạn có thể spawn sub-agent để xử lý song song hoặc cô lập ngữ cảnh. Sub-agent có history riêng (không kế thừa từ cha → giảm nhiễu + tiết kiệm token), dùng chung token meter + signal abort với cha.
+
+## Tools
+- spawn_agent  {"task": str, "context"?: str, "model"?: str}
+  Chạy 1 sub-agent độc lập, trả về kết quả dạng string (text cuối của sub-agent).
+- spawn_agents {"agents": [{"task": str, "context"?: str, "model"?: str}, ...]}
+  Chạy NHIỀU sub-agent SONG SONG (Promise.all). Trả về mảng kết quả ghép theo thứ tự, mỗi phần có header "── sub-agent #N ──".
+
+## Rules
+1. TASK PHẢI CỤ THỂ: nêu rõ goal + output mong đợi (vd "đọc src/api.js, liệt kê tất cả endpoint + method, trả về dạng bảng markdown"). Đừng giao task mơ hồ kiểu "phân tích code".
+2. CONTEXT TRUYỀN GỌN: chỉ trích đoạn cần thiết (path, snippet, dữ liệu chốt). Không dump cả history cha vào — sub-agent có history riêng, dump = lãng phí token.
+3. KHÔNG GIỚI HẠN TOKEN — sub-agent chạy tới khi xong task hoặc gặp lỗi/abort. KHÔNG set field token_budget (đã gỡ khỏi runtime).
+4. DEPTH GUARD: depth hiện tại = ${depth}. Depth còn lại: ${remaining}. Khi depth >= ${MAX_SUBAGENT_DEPTH}, sub-agent KHÔNG thấy spawn_agent nữa (chống nổ đệ quy).
+5. ROUTING MODEL (field "model"?: str — TỐI ƯU CHI PHÍ):
+   - Task đơn giản (đọc file, tóm tắt, grep, format): dùng model rẻ — vd "deepseek-v4-flash", "gpt-5-mini", "kimi".
+   - Task khó (refactor đa file, debug bug phức tạp, review kỹ thuật): dùng model mạnh — vd "claude-opus-4-7", "gpt-5", "deepseek-v4".
+   - Bỏ field "model" hoặc để rỗng → sub-agent kế thừa model của cha (mặc định an toàn).
+   - Tên model: gõ ngắn gọn ("claude-opus-4-7", "kimi", "o3-mini") — runtime tự fuzzy match (bỏ prefix gateway-, chuẩn hoá dấu/space).
+6. KHI NÀO DÙNG spawn_agents (song song) vs spawn_agent (đơn):
+   - Song song khi N task độc lập, không phụ thuộc nhau (vd review 5 file riêng biệt, fan-out + synthesize, generate-and-filter).
+   - Đơn lẻ khi chỉ cô lập 1 task nặng (giữ history cha sạch) hoặc cần kết quả của task này trước khi quyết spawn task sau.
+7. SAU KHI NHẬN KẾT QUẢ: tổng hợp/synthesize trong agent cha — đừng paste nguyên block kết quả ra cho user. Sub-agent là worker, cha là orchestrator.
+
+## Ví dụ
+spawn_agent đơn:
+\`\`\`tool
+{"name": "spawn_agent", "input": {"task": "Đọc src/api.js, liệt kê tất cả hàm export kèm signature ngắn (tên + tham số). Trả về list markdown.", "context": "File ESM, dùng fetch streaming.", "model": "deepseek-v4-flash"}}
+\`\`\`
+
+spawn_agents song song (fan-out review 3 file):
+\`\`\`tool
+{"name": "spawn_agents", "input": {"agents": [
+  {"task": "Review src/agent.js — tìm bug logic, race condition. Trả về list bullet.", "model": "claude-opus-4-7"},
+  {"task": "Review src/api.js — kiểm error handling streaming. Trả về list bullet.", "model": "claude-opus-4-7"},
+  {"task": "Review src/tools.js — kiểm input validation. Trả về list bullet.", "model": "claude-opus-4-7"}
+]}}
+\`\`\`
+
+## Anti-pattern
+- KHÔNG spawn sub-agent cho task 1 bước (vd "đọc 1 file rồi trả về") — tự đọc bằng read_file rẻ hơn nhiều.
+- KHÔNG spawn nested sâu vô tội vạ — mỗi cấp depth = 1 lần gọi model + 1 history riêng = đắt.
+- KHÔNG để sub-agent tự spawn tiếp khi task của nó đã đơn giản — depth guard chỉ là cứu cánh, không phải license đệ quy.
+`;
 }

package/src/tokens.js

@@ -100,4 +100,20 @@ export class TokenMeter {
     this._tail = "";
     this._tailTokens = 0;
   }
+  // Serialize counter để persist qua --continue/--resume. Tail buffer là transient
+  // (chỉ phục vụ tính output realtime trong 1 lượt), KHÔNG cần lưu — endOutput()
+  // đã commit hết vào this.output trước khi persist() chạy ở cuối mỗi lượt.
+  serialize() {
+    return { input: this.input, output: this.output };
+  }
+  // Khôi phục từ snapshot — chỉ set 2 counter, tail giữ rỗng (lượt mới bắt đầu).
+  restore(data) {
+    if (!data || typeof data !== "object") return;
+    this.input = Math.max(0, data.input | 0);
+    this.output = Math.max(0, data.output | 0);
+    this._committedChars = 0;
+    this._committedTokens = 0;
+    this._tail = "";
+    this._tailTokens = 0;
+  }
 }