@noobdemon/noob-cli 1.11.1 → 1.12.1

package/CHANGELOG.md

@@ -2,6 +2,45 @@
 
 Tất cả thay đổi đáng kể của `@noobdemon/noob-cli` được ghi vào file này.
 
+## [1.12.1] - 2026-06-11
+
+### Fixed
+- **TDZ ReferenceError khi workflow / tool out-of-scope ask permission** (`src/repl.js`): 3 helper `askPermission`/`askAddRoot`/`askWorkflowAgentMode` trước đây khai báo `const` rải rác (line ~405/1648/1655) — SAU chỗ gọi đầu tiên trong scope `startRepl` → JS Temporal Dead Zone throw `Cannot access 'askAddRoot' before initialization`. Exception bị `uncaughtException` handler nuốt im lặng → user gõ `y` mà flow chết, workflow approve xong không chạy. Fix: gom 3 const lên line 147 ngay sau `function ask`, trước mọi function khác. Verify bằng E2E smoke spawn bin thật (`scripts/smoke-tdz.mjs`, 3/3 PASS).
+- **Todo progress bar không reset khi chuyển task** (`src/repl/todos.js`): parser cũ scan toàn lịch sử rồi dedupe theo text → todo task A vẫn đếm vào bar dù model đã viết list mới cho task B (bar 5/10 nhưng reply chỉ có 3 todo). Fix: scan reverse, dừng ở assistant message **đầu tiên** có ≥1 dòng `- [ ]`/`- [x]` — coi đó là "todo list hiện tại", bỏ qua mọi message trước. Tự nhiên reset khi model viết list mới.
+
+### Changed
+- **Todo parser hardening** (`src/repl/todos.js`): skip dòng nằm trong code fence ` ``` ` (paste README/snippet có checkbox không bị bắt nhầm), chấp nhận cả `[X]` viết hoa (cờ `/i` cho cả `RE_DONE` và `RE_TODO`), bỏ qua message có content kiểu non-string (multimodal array).
+
+## [1.12.0] - 2026-06-11
+
+### Added
+- **Diff preview trước khi approve `edit_file`/`write_file`** (`src/diff.js`): permission prompt hiện unified diff màu (`-` đỏ, `+` xanh, context dim) thay vì tóm tắt raw. `edit_file` đọc file gốc + locate `old_string` → diff vùng thay đổi với context xung quanh. `write_file` overwrite → diff cũ vs mới; file mới → `(file MỚI · N dòng)` xanh top 20 dòng. Bắt model bịa nội dung sớm.
+- **Workflow resume + per-run journal** (`src/workflow-runs.js`): mỗi `/workflow run` ghi journal vào `<cwd>/.noob/workflow-runs/<id>.json` (mỗi sub-agent task: hash crc32(task+context+model), status, result). Ctrl+C / mất mạng giữa fan-out → `/workflow resume <id>` skip task đã done, chỉ chạy lại pending. 3 sub-command mới: `/workflow runs|log|resume`.
+- **Quota usage trong status bar** (`src/api.js` + `src/ui.js`): meta line append `· 4.7k/5k req` cạnh token meter, màu theo % used (dim <70%, vàng 70-85%, đỏ >85%). `/api/usage` cache TTL 90s + background refresh — không spam gateway. Cache bust khi `/login`/`/logout`. Plan admin skip hoàn toàn.
+
+### Changed
+- **Render markdown trong stream mode** (`src/ui.js` + `src/repl.js`): trước đây streaming path in raw `**bold**`, `` `code` ``, `## heading` không màu. Giờ `makeStreamPrinter` flush theo dòng hoàn chỉnh, render inline:
+  - `**bold**` → vàng `#fbbf24` đậm (nhãn `**Vấn đề/cơ hội:**` đập vào mắt)
+  - `` `inline code` `` → xanh lá `#34d399` (path/file.ts:23 tách rõ)
+  - Heading phân tầng: `#` brand gradient, `##` tím, `###` cyan, `####+` xám sáng
+  - Bullet `*`/`-` → `•` xanh accent; code fence (```lang ... ```) pass-through raw
+- **Refactor `src/repl.js` −8.1%** (102KB → 93.8KB): tách 4 module mới với dependency injection rõ ràng — `src/repl/permission.js` (askPermission/askAddRoot/askWorkflowAgentMode), `src/repl/commands/prompts.js` (runImprove/runKarpathy), `src/repl/state.js` (createState factory), `src/repl/utils.js` (shortCwd/relTime/truncate/fmtK/fmtTime/preview/firstLine/shortPath). Mỗi module test được riêng bằng mock object thay vì bám closure.
+- **Context window tăng 300k → 2M tokens** (`src/tokens.js`) + tinh chỉnh ngưỡng auto-compact (`src/repl.js` + `src/agent.js`):
+  - Ngưỡng warning kéo xuống cho context lớn: 40% (800k) nhắc nhẹ, 60% (1.2M) cảnh báo mạnh, 75% (1.5M) auto-compact. Trước đây 60/70/80% → với 2M context sẽ để tới 1.6M mới compact, quá trễ vì mỗi lượt cuối có thể ăn 200k+ tokens.
+  - `SUMMARIZE_THRESHOLD_CHARS` 1M → 6M chars (~1.5M tokens), match với mốc 75% auto-compact.
+  - `keepTail` tăng 4/8 → 16/24 messages: với phiên dài 2M tokens, giữ 4 message cuối là quá ít — model mất hết context tool result gần nhất (vd chuỗi edit_file + run_command đang dở).
+
+## [1.11.2] - 2026-06-10
+
+### Fixed
+- **Hết tình trạng "timeout nhiều hơn done"** — task chưa xong đã ngủm: chuyển backend gateway sang upstream mới ổn định hơn (upstream cũ hay cắt stream giữa chừng ở phút thứ 4-5 với câu trả lời dài). User không phải đổi gì, chạy `noob update` là dùng được.
+- **Thấy progress khi model đang nghĩ lâu**: gateway giờ phát status `"đang nghĩ… (Ns)"` mỗi 30s khi upstream im lặng → khỏi tưởng treo và Ctrl+C oan. Heartbeat connection cũng đẩy về 10s liên tục để Cloudflare không đóng socket.
+- **CLI tự bắt được khi gateway chết im lặng** (`src/api.js`): idle timeout 60s — nếu không nhận được byte nào (kể cả keepalive) trong 60s thì coi như chết, retry lại thay vì treo vô tận.
+- **Chống vòng lặp "nối tiếp vô hạn"** (`src/api.js`): `maxContinues` cap ở 5 lần thay vì `Infinity`. Trước đây nếu upstream cứ trả truncated, CLI nối tiếp mãi → user thấy treo.
+
+### Chore
+- ESLint ignore `worker/**` (sub-project Cloudflare Worker riêng).
+
 ## [1.11.1] - 2026-06-10
 
 ### Fixed

package/package.json

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

package/src/agent.js

@@ -146,7 +146,7 @@ const LOOP_DETECT_THRESHOLD = 2;
 const MAX_PROMPT_CHARS = 1200000; // ~300k tokens (ngang context window) — compact() KHÔNG chạy trước auto-compact 80% (240k token) của repl.js
 // Khi history vượt ngưỡng này, gọi model phụ tóm tắt các lượt cũ thay vì cắt cụt
 // → giữ được "trí nhớ dài hạn" trong phiên mà không nổ context.
-const SUMMARIZE_THRESHOLD_CHARS = 1000000; // ~250k tokens (83% window) — summarize chỉ chạy sau auto-compact 80%
+const SUMMARIZE_THRESHOLD_CHARS = 6000000; // ~1.5M tokens (75% window) — summarize chỉ chạy sau auto-compact 75% với CONTEXT_WINDOW=2M
 
 // 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
@@ -258,9 +258,12 @@ export async function maybeSummarize(history, { model, signal, force = false } =
   if (!history?.length) return false;
   const totalChars = history.reduce((s, m) => s + (m.content?.length || 0), 0);
   if (!force && totalChars < SUMMARIZE_THRESHOLD_CHARS) return false;
-  // Giữ 8 message cuối nguyên vẹn; tóm tắt phần trước.
-  // Khi force (gọi từ /compact), giữ ít tail hơn để tóm tắt mạnh hơn.
-  const keepTail = force ? 4 : 8;
+  // Giữ tail nguyên vẹn; tóm tắt phần trước.
+  // Với CONTEXT_WINDOW = 2M tokens, tail cần đủ lớn để giữ context tool result
+  // gần nhất (vd 10 lượt cuối có thể là chuỗi edit_file + run_command đang dở).
+  // force (gọi từ /compact hoặc auto-compact 75%): giữ 16 tail.
+  // non-force: giữ 24 tail (rộng tay hơn vì phiên rất dài mới trigger).
+  const keepTail = force ? 16 : 24;
   if (history.length <= keepTail + 2) return false;
   // Nếu lượt đầu đã là summary (role=system, name=summary) → tóm tắt thêm.
   const head = history.slice(0, history.length - keepTail);

package/src/api.js

@@ -165,7 +165,12 @@ export async function stream({
   onDelta,
   onReasoning,
   onStatus,
-  maxContinues = Infinity,
+  // Cap continuation: trước đây Infinity → khi upstream cứ trả truncated liên
+  // tục (effort:high bị Vercel cắt 300s mỗi lần, hoặc CF wall-clock cắt fetch
+  // upstream), CLI nối tiếp vô hạn → user thấy như treo. 5 lần là rộng rãi cho
+  // câu trả lời rất dài + vài lần bị cắt; nhiều hơn nữa = upstream/gateway
+  // hỏng thật, dừng tốt hơn.
+  maxContinues = 5,
 }) {
   const endpoint =
     mode === 'search' ? '/api/search' : mode === 'merge' ? '/api/merge' : '/api/chat';
@@ -287,6 +292,17 @@ async function streamOnce({
   let sawDone = false; // thấy {done} = stream kết thúc tử tế (không bị cắt)
   let truncated = false; // gateway báo upstream bị cắt giữa chừng
 
+  // Idle timeout client-side: gateway phát keepalive (`: keepalive\n\n`) mỗi 10s.
+  // Nếu 60s liên tiếp không nhận được gì (kể cả keepalive comment), nghĩa là
+  // gateway/CF connection đã chết im lặng. Throw retryable thay vì treo vô tận.
+  const IDLE_MS = 60000;
+  let lastByteAt = Date.now();
+  const idleTimer = setInterval(() => {
+    if (Date.now() - lastByteAt > IDLE_MS) {
+      ctrl.abort(new Error('idle_timeout'));
+    }
+  }, 5000);
+
   // Một dòng SSE → cập nhật text/reasoning. Tách ra để dùng lại khi flush dòng cuối.
   const processLine = (rawLine) => {
     const line = rawLine.trim();
@@ -332,6 +348,7 @@ async function streamOnce({
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
+      lastByteAt = Date.now(); // bất kỳ byte nào (kể cả keepalive comment) → reset idle timer
       buf += decoder.decode(value, { stream: true });
       // Chuẩn hoá CRLF→LF: một số reverse proxy (Cloudflare, nginx config khác)
       // gửi line endings \r\n. processLine() có trim() nên \r trailing tự rụng,
@@ -353,21 +370,60 @@ async function streamOnce({
 
     return { text, reasoning, truncated };
   } catch (err) {
+    // Phân biệt user abort (Ctrl+C — signal cha) với idle_timeout (ctrl.abort
+    // bên trong khi gateway im lặng quá lâu). Cả hai cùng làm fetch throw
+    // AbortError nên check signal cha trước.
     if (signal?.aborted) throw err; // người dùng bấm Ctrl+C → huỷ thật, không nối tiếp
-    // Rớt mạng giữa chừng (không phải huỷ): với chat, nếu đã có
-    // chữ thì trả phần đã nhận + cờ truncated để lớp trên nối tiếp.
+    const isIdle = ctrl.signal.aborted && err?.name === 'AbortError';
+    // Rớt mạng giữa chừng (không phải huỷ user): với chat, nếu đã có chữ thì
+    // trả phần đã nhận + cờ truncated để lớp trên nối tiếp.
     if (mode === 'chat' && text) return { text, reasoning, truncated: true };
+    // Chưa có chữ nào và là idle_timeout → throw lỗi retryable rõ ràng (thay
+    // vì AbortError chung chung) để streamWithRetry biết cần thử lại.
+    if (isIdle) {
+      throw new ApiError('idle_timeout: gateway im lặng quá lâu', {
+        code: 'idle_timeout',
+        retryable: true,
+      });
+    }
     throw err;
   } finally {
+    clearInterval(idleTimer);
     signal?.removeEventListener('abort', onUserAbort);
   }
 }
 
+// Cache /api/usage trong 90s để gọi từ status bar không spam gateway. Key cache
+// theo apiKey — đổi key (login khác) thì cache bust ngay. Bypass cache bằng
+// usage({ force: true }) cho /usage command (user gõ tay → muốn realtime).
+let _usageCache = { key: null, at: 0, data: null };
+const USAGE_CACHE_MS = 90_000;
+
 /** Fetch the current key's quota/usage from the gateway (no request consumed). */
-export async function usage() {
+export async function usage({ force = false } = {}) {
+  const now = Date.now();
+  const key = config.apiKey || '';
+  if (!force && _usageCache.data && _usageCache.key === key && now - _usageCache.at < USAGE_CACHE_MS) {
+    return _usageCache.data;
+  }
   const resp = await fetch(config.gatewayUrl + '/api/usage', { headers: authHeaders() });
   if (!resp.ok) throw await parseError(resp);
-  return await resp.json();
+  const data = await resp.json();
+  _usageCache = { key, at: now, data };
+  return data;
+}
+
+/** Trả về usage đã cache mà KHÔNG fetch (cho status bar render sync). Null nếu chưa có. */
+export function cachedUsage() {
+  const key = config.apiKey || '';
+  if (!_usageCache.data || _usageCache.key !== key) return null;
+  if (Date.now() - _usageCache.at > USAGE_CACHE_MS) return null;
+  return _usageCache.data;
+}
+
+/** Bust cache (gọi sau khi đổi key / logout). */
+export function resetUsageCache() {
+  _usageCache = { key: null, at: 0, data: null };
 }
 
 export { ApiError };

package/src/diff.js

@@ -0,0 +1,152 @@
+// Minimal line-based unified diff cho permission preview. KHÔNG phải implementation
+// đầy đủ của Myers — chỉ cần LCS + emit context để show user trước khi approve.
+//
+// Mục tiêu: user thấy CHÍNH XÁC dòng nào bị xoá / thêm, không bị model bịa nội dung.
+// Output dạng unified diff (` @@`, `-`, `+`, ` `), colorize bằng chalk ở caller.
+//
+// Performance: O(M*N) LCS table. M, N ≤ ~vài trăm dòng cho 1 edit_file → đủ nhanh.
+// File lớn hơn (write_file overwrite 1k+ dòng) → caller truncate trước khi gọi.
+import chalk from 'chalk';
+
+// LCS table giữa 2 mảng lines. Trả về matrix (M+1) x (N+1).
+function lcsTable(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const t = Array.from({ length: m + 1 }, () => new Uint32Array(n + 1));
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (a[i - 1] === b[j - 1]) t[i][j] = t[i - 1][j - 1] + 1;
+      else t[i][j] = t[i - 1][j] >= t[i][j - 1] ? t[i - 1][j] : t[i][j - 1];
+    }
+  }
+  return t;
+}
+
+// Backtrack LCS → mảng các op { type: 'eq'|'del'|'add', text }.
+// Output theo thứ tự xuất hiện trong file (top-down).
+function diffLines(a, b) {
+  const t = lcsTable(a, b);
+  const ops = [];
+  let i = a.length;
+  let j = b.length;
+  while (i > 0 && j > 0) {
+    if (a[i - 1] === b[j - 1]) {
+      ops.push({ type: 'eq', text: a[i - 1] });
+      i--; j--;
+    } else if (t[i - 1][j] >= t[i][j - 1]) {
+      ops.push({ type: 'del', text: a[i - 1] });
+      i--;
+    } else {
+      ops.push({ type: 'add', text: b[j - 1] });
+      j--;
+    }
+  }
+  while (i > 0) { ops.push({ type: 'del', text: a[--i] }); }
+  while (j > 0) { ops.push({ type: 'add', text: b[--j] }); }
+  return ops.reverse();
+}
+
+// Group ops thành hunks (cụm thay đổi + context). `context` = số dòng eq trước/sau
+// mỗi cụm del/add. Mặc định 3 — chuẩn unified diff.
+function groupHunks(ops, context = 3) {
+  const hunks = [];
+  let cur = null;
+  let trailingEq = 0;
+  for (let k = 0; k < ops.length; k++) {
+    const op = ops[k];
+    if (op.type === 'eq') {
+      if (!cur) {
+        // Chưa có hunk đang mở → giữ trong sliding window context để mở hunk kế tiếp.
+        continue;
+      }
+      cur.ops.push(op);
+      trailingEq++;
+      if (trailingEq > context * 2) {
+        // Đã đủ context sau → đóng hunk, trim eq thừa.
+        const trimCount = trailingEq - context;
+        cur.ops.splice(cur.ops.length - trimCount, trimCount);
+        hunks.push(cur);
+        cur = null;
+        trailingEq = 0;
+      }
+    } else {
+      trailingEq = 0;
+      if (!cur) {
+        // Mở hunk mới: thêm context trước (eq trong window vừa rồi).
+        cur = { ops: [] };
+        // Lấy `context` eq lùi từ vị trí hiện tại.
+        const start = Math.max(0, k - context);
+        for (let p = start; p < k; p++) {
+          if (ops[p].type === 'eq') cur.ops.push(ops[p]);
+        }
+      }
+      cur.ops.push(op);
+    }
+  }
+  if (cur) {
+    // Trim trailing eq nếu vượt context.
+    while (cur.ops.length > 0 && cur.ops[cur.ops.length - 1].type === 'eq') {
+      let trail = 0;
+      for (let p = cur.ops.length - 1; p >= 0 && cur.ops[p].type === 'eq'; p--) trail++;
+      if (trail > context) cur.ops.splice(cur.ops.length - (trail - context), trail - context);
+      break;
+    }
+    hunks.push(cur);
+  }
+  return hunks;
+}
+
+// Render unified diff với màu. `label` là tiêu đề (vd path file).
+// `maxLines` cap tổng số dòng render (mặc định 60) — diff quá dài hiện cuối `... +N dòng`.
+export function renderUnifiedDiff(oldText, newText, { label = '', context = 3, maxLines = 60 } = {}) {
+  const a = oldText.split('\n');
+  const b = newText.split('\n');
+  const ops = diffLines(a, b);
+  const hunks = groupHunks(ops, context);
+  const out = [];
+  out.push(chalk.dim('  ┌─ ' + label));
+  if (!hunks.length) {
+    out.push(chalk.dim('  │ ') + chalk.dim('(không có thay đổi)'));
+    out.push(chalk.dim('  └─'));
+    return out.join('\n');
+  }
+  let printed = 0;
+  let truncated = 0;
+  for (let h = 0; h < hunks.length; h++) {
+    if (h > 0) out.push(chalk.dim('  │ ' + chalk.dim('@@')));
+    for (const op of hunks[h].ops) {
+      if (printed >= maxLines) {
+        truncated++;
+        continue;
+      }
+      const text = String(op.text).slice(0, 200);
+      let line;
+      if (op.type === 'add') line = chalk.green('+ ') + chalk.green(text);
+      else if (op.type === 'del') line = chalk.red('- ') + chalk.red(text);
+      else line = chalk.dim('  ') + chalk.dim(text);
+      out.push(chalk.dim('  │ ') + line);
+      printed++;
+    }
+  }
+  if (truncated) {
+    out.push(chalk.dim('  │ ') + chalk.dim(`… +${truncated} dòng nữa (truncated)`));
+  }
+  out.push(chalk.dim('  └─'));
+  return out.join('\n');
+}
+
+// Render preview cho file mới (write_file path chưa tồn tại).
+// Hiển thị top N dòng + count tổng. Không có concept diff.
+export function renderNewFilePreview(content, { label = '', maxLines = 20 } = {}) {
+  const lines = String(content || '').split('\n');
+  const head = lines.slice(0, maxLines);
+  const more = lines.length - head.length;
+  const out = [];
+  out.push(chalk.dim('  ┌─ ' + label + ' ') + chalk.green(`(file MỚI · ${lines.length} dòng)`));
+  for (const l of head) {
+    out.push(chalk.dim('  │ ') + chalk.green('+ ') + chalk.green(l.slice(0, 200)));
+  }
+  if (more > 0) out.push(chalk.dim('  │ ') + chalk.dim(`… +${more} dòng nữa`));
+  out.push(chalk.dim('  └─'));
+  return out.join('\n');
+}

package/src/repl/commands/prompts.js

@@ -0,0 +1,45 @@
+// Slash commands chạy 1 prompt cố định qua handle() + persist().
+// Tách khỏi src/repl.js — cả 2 cùng pattern, đơn giản, không động state phức tạp.
+//
+// Caller truyền:
+//   - config: để check apiKey
+//   - c, t: color + i18n
+//   - handle: async function (prompt) → đẩy 1 lượt user tới agent loop
+//   - persist: lưu session sau lượt
+
+/**
+ * /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.
+ */
+export async function runImprove(arg, { config, c, t, handle, persist }) {
+  if (!config.apiKey) return console.log(c.tool('  ' + t.notLoggedIn));
+  const focus = arg
+    ? `\nNgười dùng nhấn mạnh: "${arg}". Ưu tiên theo hướng đó nhưng vẫn nêu gợi ý quan trọng khác.`
+    : '';
+  const prompt = `Đóng vai senior engineer & product reviewer. KHẢO SÁT workspace hiện tại và đề xuất TÍNH NĂNG / CẢI TIẾN cho dự án.${focus}\n\nQUY TRÌNH (dùng tool, không nói suông):\n1. list_dir thư mục gốc để nắm cấu trúc.\n2. Đọc README.md, package.json, noob.md, CHANGELOG.md (nếu có) để hiểu mục đích & trạng thái.\n3. list_dir/glob các thư mục mã chính. KHÔNG đọc hết file — chỉ đủ để nắm kiến trúc.\n4. grep TODO/FIXME/HACK/XXX để biết chỗ tác giả đã ghi nhận.\n5. Ghi nhận thiếu test/lint/CI nếu có.\n\nSAU KHẢO SÁT, viết báo cáo Markdown TIẾNG VIỆT theo cấu trúc:\n\n## Tóm tắt dự án\n2–4 dòng: làm gì, tech gì, trạng thái.\n\n## Điểm mạnh hiện tại\n3–6 gạch đầu dòng.\n\n## Gợi ý cải thiện\n5–10 đề xuất, MỖI cái:\n### N. <Tên>\n- **Vấn đề/cơ hội:** quan sát cụ thể (kèm tên_file:dòng nếu được).\n- **Đề xuất:** mô tả tính năng/cải tiến.\n- **Lợi ích:** UX/hiệu năng/độ tin cậy/mở rộng.\n- **Công sức:** S (vài giờ) / M (1–2 ngày) / L (>2 ngày).\n- **Ưu tiên:** P0 / P1 / P2.\n\n## Đề xuất ưu tiên hàng đầu\n1–3 mục P0 nên làm trước, kèm lý do.\n\nQUY TẮC: bám observation từ code thật, KHÔNG gợi ý chung chung, thẳng thắn không nịnh, KHÔNG sửa code, KHÔNG ghi noob.md.`;
+  console.log(c.tool('  ✨ ' + t.improveRunning));
+  await handle(prompt);
+  persist();
+}
+
+/**
+ * /karpathy [path] — bắt noob tự rà soát code theo 4 nguyên tắc Karpathy.
+ * Không có path → soát các file đã đổi trong phiên (model thấy qua FILES CHANGED).
+ */
+export async function runKarpathy(arg, { config, c, t, handle, persist }) {
+  if (!config.apiKey) return console.log(c.tool('  ' + t.notLoggedIn));
+  const target = arg
+    ? `file/đường dẫn: ${arg}`
+    : 'các file bạn đã tạo/sửa trong phiên này (xem mục FILES CHANGED)';
+  const prompt = `Đóng vai reviewer khó tính. Rà soát ${target} theo 4 nguyên tắc code của Karpathy.
+ĐỌC nội dung file thật bằng read_file trước — KHÔNG dựa vào trí nhớ.
+Với MỖI nguyên tắc, cho verdict (✅ đạt / ⚠️ cảnh báo / ❌ vi phạm) + phát hiện cụ thể kèm "tên_file:dòng":
+1. THINK FIRST — giả định ẩn nào chưa nêu? chỗ nào thiếu kiểm chứng?
+2. KEEP IT SIMPLE — over-engineer, abstraction thừa, lồng quá sâu, hàm quá dài?
+3. SURGICAL — thay đổi lạc đề, refactor tiện tay, đổi style/format vô cớ?
+4. VERIFIABLE GOAL — mục tiêu có kiểm chứng được? đã chạy build/test chưa?
+Cuối cùng: tóm tắt + danh sách sửa theo thứ tự ưu tiên. Thẳng thắn, KHÔNG nịnh.`;
+  console.log(c.tool('  ⚖ Karpathy check…'));
+  await handle(prompt);
+  persist();
+}

package/src/repl/permission.js

@@ -0,0 +1,116 @@
+// Permission prompts (y/n/a) cho tool calls, add-root, và workflow agent mode.
+//
+// Tách khỏi src/repl.js (refactor 1.11.4+): 3 hàm này dùng chung pattern
+// "paste-spam protection" — nếu user paste/gõ nhầm tin nhắn lạ (dòng dài > 3 char,
+// không khớp y/n/a) vào đúng lúc prompt hiện, thay vì coi như từ chối, ta XẾP
+// HÀNG tin đó (pending) và hỏi lại. Đây là thủ phạm cũ làm CLI "tự tắt" hoặc
+// quyết định nhầm trước đây.
+//
+// Mỗi hàm:
+//   - tui.setBusy(false) trước prompt (tắt spinner để prompt nổi bật).
+//   - try/finally khôi phục busy=true với label thinking.
+//   - stdin đóng (raw == null) → return 'n' (mặc định an toàn).
+//
+// Caller phải truyền:
+//   - tui: TUI instance (setBusy, ask qua chính TUI hoặc inject `ask` riêng).
+//   - ask: hàm async đọc 1 dòng từ stdin (đã có sẵn trong repl.js).
+//   - pending: mảng tin nhắn xếp hàng dùng chung với REPL loop.
+//   - c: color palette (chalk hex).
+//   - t: i18n strings.
+//   - truncate: helper cắt chuỗi dài.
+
+/**
+ * Hỏi quyền chung cho 1 tool call. Trả về 'y' | 'n' | 'a'.
+ * 'a' = auto-approve mọi lần gọi tool name này trong phiên còn lại.
+ */
+export async function askPermission(name, { tui, ask, pending, c, t, truncate }) {
+  tui.setBusy(false);
+  console.log(
+    c.tool('  ⏸ Cần quyền: ' + name) +
+      c.dim(' — gõ y (đồng ý) / n (từ chối) / a (luôn cho phép)')
+  );
+  try {
+    while (true) {
+      const raw = await ask(
+        c.tool('  cho phép? ') + c.dim('[y] có / [n] không / [a] luôn ' + name + ' › ')
+      );
+      if (raw == null) return 'n';
+      const a = raw.trim().toLowerCase();
+      if (a === '' || a === 'y' || a === 'yes' || a === 'có') return 'y';
+      if (a === 'n' || a === 'no' || a === 'không') return 'n';
+      if (a === 'a' || a === 'always' || a === 'luôn') return 'a';
+      if (raw.trim().length > 3) {
+        pending.push(raw);
+        console.log(c.dim('  ' + t.queued(pending.length, truncate(raw, 60))));
+      }
+      console.log(c.dim('  ' + t.permRetry));
+    }
+  } finally {
+    tui.setBusy(true, t.thinking);
+  }
+}
+
+/**
+ * Hỏi user có muốn add folder ngoài workspace cho 1 tool call cụ thể.
+ * `targetPath` = path tool đang muốn truy cập (để user thấy rõ context).
+ * Trả về 'y' | 'n' | 'a'.
+ */
+export async function askAddRoot(root, targetPath, { tui, ask, pending, c, t, truncate }) {
+  tui.setBusy(false);
+  console.log(c.tool('  ⏸ Cần cấp quyền folder: ') + c.accent(root));
+  console.log(c.dim('    (model muốn truy cập: ' + targetPath + ')'));
+  try {
+    while (true) {
+      const raw = await ask(
+        c.tool('  cho phép? ') +
+          c.dim('[y] thêm vào scope lần này / [a] luôn thêm / [n] từ chối › ')
+      );
+      if (raw == null) return 'n';
+      const a = raw.trim().toLowerCase();
+      if (a === '' || a === 'y' || a === 'yes' || a === 'có') return 'y';
+      if (a === 'n' || a === 'no' || a === 'không') return 'n';
+      if (a === 'a' || a === 'always' || a === 'luôn') return 'a';
+      if (raw.trim().length > 3) {
+        pending.push(raw);
+        console.log(c.dim('  ' + t.queued(pending.length, truncate(raw, 60))));
+      }
+      console.log(c.dim('  → gõ y / n / a'));
+    }
+  } finally {
+    tui.setBusy(true, t.thinking);
+  }
+}
+
+/**
+ * Hỏi user có muốn bật agent mode để chạy /workflow. Chỉ y/n (Enter=yes).
+ * Trả về 'y' | 'n'.
+ */
+export async function askWorkflowAgentMode({ tui, ask, pending, c, t, truncate }) {
+  tui.setBusy(false);
+  console.log(
+    c.tool(
+      '  ' +
+        (t.workflowAgentAskHint ||
+          '🎼 /workflow cần spawn sub-agent — agent mode hiện đang TẮT.')
+    )
+  );
+  try {
+    while (true) {
+      const raw = await ask(
+        c.tool('  bật agent mode và chạy workflow? ') +
+          c.dim('[y] có, bật & chạy / [n] huỷ (gõ /agent rồi chạy lại nếu muốn) › ')
+      );
+      if (raw == null) return 'n';
+      const a = raw.trim().toLowerCase();
+      if (a === '' || a === 'y' || a === 'yes' || a === 'có') return 'y';
+      if (a === 'n' || a === 'no' || a === 'không') return 'n';
+      if (raw.trim().length > 3) {
+        pending.push(raw);
+        console.log(c.dim('  ' + t.queued(pending.length, truncate(raw, 60))));
+      }
+      console.log(c.dim('  → gõ y hoặc n'));
+    }
+  } finally {
+    tui.setBusy(true, t.thinking);
+  }
+}

package/src/repl/state.js

@@ -0,0 +1,33 @@
+// State phiên REPL — factory pure, không side effect.
+//
+// Tách khỏi src/repl.js (refactor): trước đây inline trong startRepl(). Tách ra
+// để (1) test được riêng — pass opts vào, assert shape; (2) thấy ngay shape state
+// đầy đủ thay vì cuộn 50 dòng init.
+//
+// Lưu ý: state chỉ chứa primitive + collection rỗng. Mọi reference động (model,
+// tokenMeter, abort, session) vẫn ở startRepl scope — vì chúng có lifecycle khác
+// state và cần closure binding với tui/api.
+import { findModel, DEFAULT_MODEL } from '../models.js';
+
+/**
+ * @param {Object} opts - CLI flags từ bin/noob.js
+ * @param {Object} config - config singleton (đọc model mặc định + yoloDefault)
+ * @returns {Object} state phiên — mutable, share giữa REPL loop + commands
+ */
+export function createState(opts = {}, config) {
+  return {
+    model: findModel(opts.model) || findModel(config.model) || findModel(DEFAULT_MODEL),
+    mode: 'chat', // chat | merge | search
+    history: [],
+    autoApprove: new Set(),
+    yolo: !!opts.yolo || config.yoloDefault,
+    ultra: false, // /ultra chế độ tự hành đang chạy
+    agentMode: false, // /agent on → cho phép spawn_agent / spawn_agents
+    goal: null, // HARD GOAL set qua /goal — inject vào mọi prompt
+    loop: null, // /loop — {intervalMs, intervalStr, task, timer, ticks, startedAt} | null
+    extraRoots: [], // /add-dir — UX display only; source of truth ở tools.js
+    _longSessionWarned: false, // đã in cảnh báo phiên dài chưa (reset khi /clear)
+    todos: [], // [{text, done}] — todo list parse từ model output, render trên status bar
+    workflowRun: null, // {id, data, path} — active workflow run journal (resume + log)
+  };
+}

package/src/repl/todos.js

@@ -1,38 +1,79 @@
-// Parse danh sách todo từ history hội thoại. Scan các assistant message tìm
-// pattern markdown `- [ ] task` và `- [x] task` (case-insensitive cho dấu x).
-// Pure function: chỉ phụ thuộc input `history`, không closure state.
+// Parse danh sách todo từ history hội thoại.
 //
-// Dedupe: nếu cùng một text xuất hiện nhiều lần (model lặp todo qua các lượt),
-// giữ trạng thái CUỐI cùng — phản ánh state hiện tại của model.
+// Quan trọng: chỉ parse list todo CUỐI cùng — assistant message GẦN NHẤT có
+// ít nhất 1 dòng `- [ ]` hoặc `- [x]` được coi là "todo list hiện tại". Mọi
+// message trước đó bị bỏ qua.
+//
+// Lý do: trước đây scan toàn lịch sử rồi dedupe theo text → todo từ task CŨ
+// vẫn đếm vào progress bar dù model đã chuyển sang task mới. Triệu chứng:
+// bar 5/10 nhưng reply mới nhất chỉ có 3 todo. Cách mới tự nhiên reset khi
+// model viết todo list mới, không bao giờ trộn todo từ 2 task khác nhau.
+//
+// Edge case đã xử lý:
+//   - Code fence ``` (cả với info string như ```md): bỏ qua dòng bên trong,
+//     tránh paste README/snippet có checkbox bị parser bắt nhầm thành todo.
+//   - Cả `[x]` và `[X]` (viết hoa) đều coi là done.
+//   - Multi-line message lặp cùng todo text: giữ trạng thái CUỐI.
+//
+// Pure function: chỉ phụ thuộc input `history`.
 
 /**
  * @typedef {{ text: string, done: boolean }} TodoItem
  */
 
+// Regex tách riêng cho rõ ràng + dễ test. Cả 2 dùng cờ `i` để chấp nhận `[X]`
+// (viết hoa) — markdown checkbox không phân biệt hoa thường trong thực tế.
+const RE_DONE = /^\s*-\s*\[x\]\s+(.+)/i;
+const RE_TODO = /^\s*-\s*\[\s?\]\s+(.+)/i;
+// Code fence: ``` đầu dòng, có thể kèm info string (vd ```js, ```md).
+const RE_FENCE = /^\s*```/;
+
 /**
- * Trích todo list từ history.
- * @param {Array<{role: string, content: any}>} history
+ * Parse các dòng todo trong 1 message content. Trả về [] nếu không có dòng nào.
+ * - Bỏ qua dòng nằm trong code fence (``` ... ```).
+ * - Trong cùng 1 message, nếu cùng text xuất hiện 2 lần (vd model lặp khi
+ *   format), giữ trạng thái CUỐI — phản ánh ý định gần nhất.
+ * @param {string} content
  * @returns {TodoItem[]}
  */
-export function parseTodosFromHistory(history) {
-  const todos = [];
-  for (const m of history) {
-    if (m.role !== 'assistant' || typeof m.content !== 'string') continue;
-    const lines = m.content.split('\n');
-    for (const line of lines) {
-      const doneMatch = line.match(/^[\s]*-\s*\[x\]\s+(.+)/i);
-      if (doneMatch) {
-        todos.push({ text: doneMatch[1].trim(), done: true });
-        continue;
-      }
-      const todoMatch = line.match(/^[\s]*-\s*\[\s?\]\s+(.+)/);
-      if (todoMatch) {
-        todos.push({ text: todoMatch[1].trim(), done: false });
-      }
+function parseTodosFromMessage(content) {
+  const out = [];
+  let inFence = false;
+  for (const line of content.split('\n')) {
+    if (RE_FENCE.test(line)) {
+      inFence = !inFence;
+      continue;
     }
+    if (inFence) continue;
+    const m1 = line.match(RE_DONE);
+    if (m1) {
+      out.push({ text: m1[1].trim(), done: true });
+      continue;
+    }
+    const m2 = line.match(RE_TODO);
+    if (m2) out.push({ text: m2[1].trim(), done: false });
   }
-  // Dedupe: giữ item CUỐI cùng cho mỗi text (model có thể lặp todo qua các lượt).
+  // Dedupe trong cùng message: giữ entry CUỐI cho mỗi text. Map<1 entry rẻ
+  // như không có — không cần micro-opt skip khi out.length<=1.
   const seen = new Map();
-  for (const t of todos) seen.set(t.text, t);
+  for (const it of out) seen.set(it.text, it);
   return [...seen.values()];
 }
+
+/**
+ * Trích todo list từ history. Chỉ trả về todo từ assistant message GẦN NHẤT
+ * chứa ít nhất 1 dòng todo. Mọi message trước đó bị bỏ qua.
+ * Bỏ qua message có content kiểu non-string (vd multimodal array) — chưa hỗ trợ.
+ * @param {Array<{role: string, content: any}>} history
+ * @returns {TodoItem[]}
+ */
+export function parseTodosFromHistory(history) {
+  if (!Array.isArray(history)) return [];
+  for (let i = history.length - 1; i >= 0; i--) {
+    const m = history[i];
+    if (!m || m.role !== 'assistant' || typeof m.content !== 'string') continue;
+    const parsed = parseTodosFromMessage(m.content);
+    if (parsed.length) return parsed;
+  }
+  return [];
+}