@noobdemon/noob-cli 1.7.7 → 1.7.10

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;
+  }
 }

package/src/tools.js

@@ -98,8 +98,15 @@ process.on("SIGTERM", () => {
   process.exit(143);
 });
 
+// Helper: throw nếu signal đã abort. Dùng ở đầu mỗi tool + giữa các vòng walk dài
+// để tool fs (glob/grep) cũng phản ứng với Ctrl+C, không chỉ run_command.
+function checkAbort(signal) {
+  if (signal?.aborted) throw new Error("aborted");
+}
+
 export const TOOLS = {
-  async read_file({ path: p, offset, limit }) {
+  async read_file({ path: p, offset, limit }, { signal } = {}) {
+    checkAbort(signal);
     const data = await fs.readFile(abs(p), "utf8");
     let lines = data.split("\n");
     const start = offset ? Math.max(0, offset - 1) : 0;
@@ -110,14 +117,16 @@ export const TOOLS = {
     );
   },
 
-  async write_file({ path: p, content }) {
+  async write_file({ path: p, content }, { signal } = {}) {
+    checkAbort(signal);
     await fs.mkdir(path.dirname(abs(p)), { recursive: true });
     await fs.writeFile(abs(p), content ?? "", "utf8");
     const n = (content ?? "").split("\n").length;
     return `Wrote ${n} line(s) to ${rel(abs(p))}`;
   },
 
-  async edit_file({ path: p, old_string, new_string, replace_all }) {
+  async edit_file({ path: p, old_string, new_string, replace_all }, { signal } = {}) {
+    checkAbort(signal);
     const file = abs(p);
     const data = await fs.readFile(file, "utf8");
     if (old_string === new_string) throw new Error("old_string and new_string are identical");
@@ -163,7 +172,8 @@ export const TOOLS = {
     );
   },
 
-  async list_dir({ path: p = "." }) {
+  async list_dir({ path: p = "." }, { signal } = {}) {
+    checkAbort(signal);
     const dir = abs(p);
     const entries = await fs.readdir(dir, { withFileTypes: true });
     const rows = entries
@@ -173,10 +183,13 @@ export const TOOLS = {
     return clip(`${rel(dir)}/  (${rows.length} entries)\n` + rows.map((r) => "  " + r).join("\n"));
   },
 
-  async glob({ pattern }) {
+  async glob({ pattern }, { signal } = {}) {
+    checkAbort(signal);
     const hits = [];
     const rx = globToRegExp(pattern);
     const roots = listRoots();
+    // Check signal mỗi ~256 entries thay vì mỗi entry — đỡ overhead trên repo lớn.
+    let tickCounter = 0;
     for (const root of roots) {
       (function walk(dir) {
         let ents;
@@ -186,6 +199,7 @@ export const TOOLS = {
           return;
         }
         for (const e of ents) {
+          if ((++tickCounter & 0xff) === 0) checkAbort(signal);
           if (SKIP_DIRS.has(e.name) || e.name.startsWith(".git")) continue;
           const full = path.join(dir, e.name);
           if (e.isDirectory()) walk(full);
@@ -198,11 +212,14 @@ export const TOOLS = {
     return hits.length ? clip(hits.join("\n")) : "No files matched.";
   },
 
-  async grep({ pattern, path: p, glob: g }) {
+  async grep({ pattern, path: p, glob: g }, { signal } = {}) {
+    checkAbort(signal);
     const rx = new RegExp(pattern, "i");
     const gRx = g ? globToRegExp(g) : null;
     const out = [];
+    let tickCounter = 0;
     function scanFile(full) {
+      if ((++tickCounter & 0xff) === 0) checkAbort(signal);
       const disp = displayPath(full);
       const relp = disp.split(path.sep).join("/");
       if (gRx && !gRx.test(relp)) return;
@@ -250,7 +267,7 @@ export const TOOLS = {
     return out.length ? clip(out.join("\n")) : "No matches.";
   },
 
-  run_command({ command, timeout = 60000, background = false }) {
+  run_command({ command, timeout = 60000, background = false }, { signal } = {}) {
     const isWin = process.platform === "win32";
     const shell = isWin ? "powershell.exe" : "/bin/bash";
     const args = isWin ? ["-NoProfile", "-NonInteractive", "-Command", command] : ["-c", command];
@@ -289,19 +306,34 @@ export const TOOLS = {
       const child = spawn(shell, args, { cwd: cwd(), stdio: ["ignore", "pipe", "pipe"] });
       let out = "";
       let timedOut = false;
+      let aborted = false;
       const killer = setTimeout(() => {
         timedOut = true;
-        child.kill();
+        killBgTree(child);
       }, timeout);
+      // Ctrl+C trong lúc command đang chạy → kill cây tiến trình con (Windows
+      // dùng taskkill /T để diệt cả grand-children, vd npm spawn node).
+      const onAbort = () => {
+        aborted = true;
+        killBgTree(child);
+      };
+      if (signal) {
+        if (signal.aborted) onAbort();
+        else signal.addEventListener("abort", onAbort, { once: true });
+      }
       child.stdout.on("data", (d) => (out += d));
       child.stderr.on("data", (d) => (out += d));
       child.on("error", (e) => {
         clearTimeout(killer);
+        signal?.removeEventListener?.("abort", onAbort);
         resolve(`Failed to start command: ${e.message}`);
       });
       child.on("close", (code) => {
         clearTimeout(killer);
-        const tail = timedOut
+        signal?.removeEventListener?.("abort", onAbort);
+        const tail = aborted
+          ? `\n[aborted by user (Ctrl+C) — killed.]`
+          : timedOut
           ? `\n[timed out after ${Math.round(timeout / 1000)}s — killed. If this is a server or other long-running task, re-run with {"background": true} instead.]`
           : `\n[exit code ${code}]`;
         resolve(clip((out.trim() || "(no output)") + tail));
@@ -445,8 +477,11 @@ export function describe(name, input) {
   }
 }
 
-export async function runTool(name, input) {
+export async function runTool(name, input, opts = {}) {
   const fn = TOOLS[name];
   if (!fn) throw new Error(`Unknown tool: ${name}`);
-  return await fn(input || {});
+  const { signal } = opts;
+  // Pre-check: nếu user đã Ctrl+C trước khi tool kịp chạy, bail ngay.
+  if (signal?.aborted) throw new Error("aborted");
+  return await fn(input || {}, { signal });
 }

package/src/workflows.js

@@ -0,0 +1,142 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+// CRUD workflow đã lưu. Cảm hứng từ tweet_dump.txt L183–193 ("saving and sharing
+// dynamic workflows"): user nhấn 's' để snapshot prompt template ra file rồi tái
+// dùng. Map sang noob: lưu Markdown ở ~/.noob/workflows/<name>.md, format có
+// front-matter YAML-lite + body là prompt template.
+
+const DIR = path.join(os.homedir(), ".noob", "workflows");
+
+function ensureDir() {
+  try { fs.mkdirSync(DIR, { recursive: true }); } catch {}
+}
+
+// Tên file an toàn — chỉ cho phép [a-z0-9-_], chống path traversal.
+function sanitizeName(name) {
+  if (!name || typeof name !== "string") return null;
+  const trimmed = name.trim().toLowerCase();
+  if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(trimmed)) return null;
+  return trimmed;
+}
+
+function filePath(name) {
+  const safe = sanitizeName(name);
+  if (!safe) return null;
+  return path.join(DIR, safe + ".md");
+}
+
+// Parse front-matter cực tối giản: --- ... --- ở đầu file, key: value mỗi dòng.
+function parseFile(raw) {
+  const meta = {};
+  let body = raw;
+  const m = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+  if (m) {
+    for (const line of m[1].split(/\r?\n/)) {
+      const kv = line.match(/^([a-zA-Z][a-zA-Z0-9_-]*):\s*(.*)$/);
+      if (kv) meta[kv[1]] = kv[2].trim();
+    }
+    body = m[2];
+  }
+  return { meta, body };
+}
+
+function serialize(meta, body) {
+  const lines = ["---"];
+  for (const [k, v] of Object.entries(meta)) {
+    lines.push(`${k}: ${String(v).replace(/\r?\n/g, " ")}`);
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(body);
+  return lines.join("\n");
+}
+
+// Lưu workflow. Trả về { ok, path?, error? }.
+export function saveWorkflow(name, prompt, opts = {}) {
+  const safe = sanitizeName(name);
+  if (!safe) return { ok: false, error: "invalid_name" };
+  if (!prompt || typeof prompt !== "string" || !prompt.trim()) {
+    return { ok: false, error: "empty_prompt" };
+  }
+  ensureDir();
+  const fp = path.join(DIR, safe + ".md");
+  const meta = {
+    name: safe,
+    created: opts.created || new Date().toISOString(),
+    updated: new Date().toISOString(),
+  };
+  if (opts.description) meta.description = opts.description;
+  try {
+    fs.writeFileSync(fp, serialize(meta, prompt.trim()), "utf8");
+    return { ok: true, path: fp };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+// Đọc workflow. Trả về { ok, name, prompt, meta, path } hoặc { ok: false }.
+export function loadWorkflow(name) {
+  const fp = filePath(name);
+  if (!fp) return { ok: false, error: "invalid_name" };
+  if (!fs.existsSync(fp)) return { ok: false, error: "not_found" };
+  try {
+    const raw = fs.readFileSync(fp, "utf8");
+    const { meta, body } = parseFile(raw);
+    return { ok: true, name: sanitizeName(name), prompt: body.trim(), meta, path: fp };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+// Liệt kê tất cả workflow đã lưu. Trả về mảng { name, description?, updated? }.
+export function listWorkflows() {
+  ensureDir();
+  let entries;
+  try {
+    entries = fs.readdirSync(DIR);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const f of entries) {
+    if (!f.endsWith(".md")) continue;
+    const name = f.slice(0, -3);
+    if (!sanitizeName(name)) continue;
+    try {
+      const raw = fs.readFileSync(path.join(DIR, f), "utf8");
+      const { meta } = parseFile(raw);
+      out.push({
+        name,
+        description: meta.description || "",
+        updated: meta.updated || "",
+      });
+    } catch {
+      out.push({ name, description: "", updated: "" });
+    }
+  }
+  // Sort theo updated desc (mới nhất lên đầu), fallback alphabet.
+  out.sort((a, b) => {
+    if (a.updated && b.updated) return b.updated.localeCompare(a.updated);
+    return a.name.localeCompare(b.name);
+  });
+  return out;
+}
+
+// Xoá workflow. Trả về { ok, error? }.
+export function deleteWorkflow(name) {
+  const fp = filePath(name);
+  if (!fp) return { ok: false, error: "invalid_name" };
+  if (!fs.existsSync(fp)) return { ok: false, error: "not_found" };
+  try {
+    fs.unlinkSync(fp);
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+export function workflowsDir() {
+  return DIR;
+}