@noobdemon/noob-cli 1.8.1 → 1.9.0

package/package.json

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

package/src/agent.js

@@ -107,20 +107,21 @@ function runtimeContext() {
     "# ENVIRONMENT",
     `- OS: ${process.platform} (${os.release()})`,
     `- Shell for run_command: ${isWin ? "Windows PowerShell (powershell.exe)" : "bash"}`,
-    `- Current working directory: ${process.cwd()}`,
+    `- Workspace (cwd): ${process.cwd()}`,
   ];
-  // Extra roots cấp qua /add-dir: model PHẢI biết để chủ động dùng (đọc/list/grep).
-  // Không liệt kê ở đây → model không 'thấy' thư mục đó tồn tại dù tools layer
-  // đã accept path.
+  // Phạm vi truy cập filesystem. Model mặc định CHỈ được chạm cwd + các folder
+  // user đã /add-dir. Nếu cần folder NGOÀI phạm vi → CỨ gọi tool với path tuyệt
+  // đối; repl sẽ tự hỏi user perm, nếu user đồng ý folder được thêm vào scope +
+  // lưu vào `.noob/dirs.json` của project. KHÔNG cần (và KHÔNG nên) yêu cầu user
+  // gõ `/add-dir` thủ công — cứ thử, hệ thống lo phần còn lại.
   try {
     const roots = listRoots();
     const extras = roots.slice(1); // [0] là cwd
-    if (extras.length) {
-      lines.push(
-        `- Extra roots cấp quyền qua /add-dir (tool path nằm trong các thư mục này cũng hợp lệ — dùng path tuyệt đối khi gọi tool):`,
-      );
-      for (const r of extras) lines.push(`  • ${r}`);
-    }
+    lines.push(`- Filesystem scope: workspace + ${extras.length} extra root(s)${extras.length ? ":" : " (chỉ workspace)."}`);
+    for (const r of extras) lines.push(`  • ${r}`);
+    lines.push(
+      `- Nếu cần folder NGOÀI scope: dùng path tuyệt đối trong tool call — repl sẽ hỏi user, nếu duyệt folder tự được thêm + persist theo workspace.`,
+    );
   } catch {}
   if (isWin) {
     lines.push(

package/src/i18n.js

@@ -71,7 +71,7 @@ export const t = {
   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)",
-  cmdAddDir: "/add-dir <path>  thêm thư mục ngoài cwd vào phạm vi tool (không arg = liệt kê)",
+  cmdAddDir: "/add-dir <path>  thêm thư mục ngoài cwd vào phạm vi tool (lưu theo workspace, không arg = liệt kê)",
   cmdClear: "/clear /new    xoá ngữ cảnh (mở phiên mới, phiên cũ vẫn resume được)",
   cmdResume: "/resume [id]   tiếp tục phiên cũ (không id = chọn từ danh sách)",
   cmdSessions: "/sessions      liệt kê các phiên đã lưu",
@@ -89,6 +89,12 @@ export const t = {
   // misc
   yoloOn: "⚠ yolo BẬT — tự động duyệt mọi thao tác sửa file & chạy lệnh",
   yoloOff: "✓ yolo TẮT — sẽ hỏi trước khi sửa file & chạy lệnh",
+
+  // add-dir: auto-prompt khi model tag folder ngoài workspace
+  outOfScopeAdded: (root) => `✓ đã thêm ${root} vào phạm vi (lưu .noob/dirs.json).`,
+  outOfScopeRejected: (root) => `đã từ chối — ${root} không nằm trong phạm vi. Model có thể dùng /add-dir để thêm sau.`,
+  addDirRemoveNeedArg: "Thiếu path. Dùng: /add-dir remove <đường-dẫn>",
+  addDirNotInScope: (p) => `${p} không có trong phạm vi (chỉ cwd + các folder đã /add-dir).`,
   autoYoloWarn: "⚠ yolo tự duyệt MỌI thao tác (sửa file/chạy lệnh) KHÔNG hỏi. Lưu làm mặc định = mỗi lần mở noob đều bật sẵn yolo.",
   autoYoloConfirm: "Chắc chắn lưu yolo làm mặc định? gõ 'y' để xác nhận, phím khác để huỷ › ",
   autoYoloOn: "⚡ Đã LƯU yolo làm mặc định — mọi phiên sau tự bật. Gõ /auto-yolo lần nữa để tắt.",
@@ -151,6 +157,10 @@ export const t = {
   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)",
+  workflowAgentAskHint: "🎼 /workflow cần spawn sub-agent (spawn_agent) — agent mode hiện đang TẮT.",
+  workflowAgentAskPrompt: "  bật agent mode và chạy workflow? [y] có, bật & chạy / [n] huỷ (gõ /agent rồi chạy lại nếu muốn) › ",
+  workflowAgentEnabled: "đã bật agent mode cho workflow này.",
+  workflowAgentDenied: "đã huỷ /workflow — agent mode vẫn TẮT. Gõ /agent rồi chạy lại lệnh nếu muốn.",
   // 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}):`,

package/src/repl.js

@@ -7,7 +7,7 @@ import { runAgent, maybeSummarize } from "./agent.js";
 import { runSubAgent, spawnAgentToolsDoc, MAX_SUBAGENT_DEPTH } from "./subagent.js";
 import { TokenMeter } from "./tokens.js";
 import { stream, usage, ApiError, resetMemoryToken } from "./api.js";
-import { runTool, describe, DESTRUCTIVE, addRoot, listRoots } from "./tools.js";
+import { runTool, describe, DESTRUCTIVE, addRoot, removeRoot, listRoots, OutOfScopeError, nearestExistingDir } from "./tools.js";
 import { MODELS, PROVIDERS, findModel, providerColor, DEFAULT_MODEL } from "./models.js";
 import { c, banner, modelBadge, renderMarkdown, box } from "./ui.js";
 import { config } from "./config.js";
@@ -413,13 +413,44 @@ Thực thi: đọc/tạo file cần thiết bằng tool, viết code production-
     await workflowExecute(arg);
   }
 
+  // Hỏi quyền bật agent mode để chạy workflow. CHỈ chấp nhận y/n (Enter = yes).
+  // Nếu nhận dòng lạ & dài (paste nhầm tin nhắn) → xếp hàng + hỏi lại (y hệt
+  // askPermission / askAddRoot) để user khỏi phải gõ lại /workflow.
+  async function askWorkflowAgentMode() {
+    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"; // stdin đóng thật
+        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);
+    }
+  }
+
   // 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) {
+      // Đừng tự bật — workflow cần spawn_agent, đây là quyền nặng (sub-agent chạy
+      // tool độc lập). Hỏi 1 lần, user chọn y thì bật & chạy, n thì huỷ sạch +
+      // gợi ý /agent. Tránh buộc user gõ lại /workflow sau khi /agent.
+      const choice = await askWorkflowAgentMode();
+      if (choice !== "y") {
+        return console.log(c.dim("  " + (t.workflowAgentDenied || "đã huỷ /workflow — agent mode vẫn TẮT. Gõ /agent rồi chạy lại lệnh nếu muốn.")));
+      }
       state.agent = true;
-      console.log(c.tool("  " + (t.workflowAgentAutoOn || "agent mode tự bật cho /workflow")));
+      console.log(c.tool("  ✓ " + (t.workflowAgentEnabled || "đã bật agent mode cho workflow này.")));
     }
     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.
 
@@ -1197,6 +1228,16 @@ NGUYÊN TẮC:
       }
     }
 
+    return await execToolCore(name, input, { retried: false });
+  }
+
+  // Phần thân tool (tách riêng để retry khi user vừa approve thêm extra root).
+  // Flow OutOfScopeError: tool ném → repl hỏi user "add folder X? [y/n/a]" → nếu
+  // y/a: addRoot + persist (đã làm trong addRoot) + state.extraRoots sync + chạy
+  // lại tool. Nếu n: trả lỗi cho model như cũ. Auto-prompt CHỈ chạy khi path là
+  // tuyệt đối + có suggestedRoot hợp lệ (folder tồn tại) — tương đối escape cwd
+  // thường là model tính sai, để model tự sửa.
+  async function execToolCore(name, input, { retried }) {
     tui.status(c.dim("  " + t.running));
     try {
       const result = await runTool(name, input, { signal: abort?.signal });
@@ -1205,11 +1246,55 @@ NGUYÊN TẮC:
       return { allow: true, result };
     } catch (err) {
       tui.status(null);
+      if (err instanceof OutOfScopeError && !retried && err.suggestedRoot) {
+        const root = err.suggestedRoot;
+        const a = await askAddRoot(root, err.path);
+        if (a === "n") {
+          console.log(c.err("  " + t.outOfScopeRejected(root)));
+          return { allow: true, result: "ERROR: " + err.message };
+        }
+        try {
+          addRoot(root);
+          if (!state.extraRoots.includes(root)) state.extraRoots.push(root);
+          if (a === "a") state.autoApprove.add("add-root");
+          console.log(c.ok("  " + t.outOfScopeAdded(root)));
+        } catch (e) {
+          console.log(c.err("  ✗ " + (e?.message || String(e))));
+          return { allow: true, result: "ERROR: " + err.message };
+        }
+        return await execToolCore(name, input, { retried: true });
+      }
       console.log(c.err("  ✗ " + err.message));
       return { allow: true, result: "ERROR: " + err.message };
     }
   }
 
+  // Hỏi user có muốn cấp quyền folder ngoài workspace cho tool call hiện tại
+  // hay không. Trả về "y" | "n" | "a" (luôn). y = chỉ lần này; a = auto-approve
+  // mọi add-root trong phiên. Cùng style retry với askPermission (lạc → queue).
+  async function askAddRoot(root, targetPath) {
+    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);
+    }
+  }
+
   // Đọc câu trả lời cho phép một cách CHẮC CHẮN. Chỉ chấp nhận y/n/a (hoặc
   // Enter = đồng ý). Nếu nhận một dòng lạ & dài — gần như chắc là một tin nhắn
   // bị paste/gõ nhầm vào đúng lúc prompt hiện ra (đây là thủ phạm làm hỏng &
@@ -1407,6 +1492,22 @@ NGUYÊN TẮC:
         break;
       case "adddir":
       case "add-dir": {
+        // /add-dir remove|rm <path> — gỡ khỏi scope (xóa cả trong file persist).
+        if (/^(remove|rm)\b/i.test(arg)) {
+          const target = arg.replace(/^(remove|rm)\s*/i, "").trim();
+          if (!target) {
+            console.log(c.err("  " + t.addDirRemoveNeedArg));
+            break;
+          }
+          const full = path.resolve(process.cwd(), target);
+          if (removeRoot(full)) {
+            state.extraRoots = state.extraRoots.filter((r) => r !== full);
+            console.log(c.ok("  ✓ ") + c.dim("đã gỡ khỏi phạm vi: ") + full);
+          } else {
+            console.log(c.err("  " + t.addDirNotInScope(full)));
+          }
+          break;
+        }
         if (!arg) {
           // Không arg → liệt kê roots hiện tại (cwd + các thư mục đã /add-dir).
           const roots = listRoots();
@@ -1415,13 +1516,14 @@ NGUYÊN TẮC:
             const isCwd = r === process.cwd();
             console.log("  " + (isCwd ? c.accent("• ") : c.ok("+ ")) + r + (isCwd ? c.dim("  (cwd)") : ""));
           }
-          console.log(c.dim("  Dùng: /add-dir <đường-dẫn>"));
+          console.log(c.dim("  Dùng: /add-dir <đường-dẫn>  hoặc  /add-dir remove <đường-dẫn>"));
           break;
         }
         try {
           const full = addRoot(path.resolve(process.cwd(), arg));
           if (!state.extraRoots.includes(full)) state.extraRoots.push(full);
           console.log(c.ok("  ✓ ") + c.dim("đã thêm vào phạm vi: ") + full);
+          console.log(c.dim("    (đã lưu vào .noob/dirs.json — lần sau mở lại tự động áp dụng)"));
         } catch (e) {
           console.log(c.err("  ✗ ") + (e?.message || String(e)));
         }

package/src/tools.js

@@ -6,9 +6,78 @@ import { spawn } from "node:child_process";
 const MAX_OUT = 30000; // hard cap on any tool result fed back to the model
 const cwd = () => process.cwd();
 
-// Các thư mục ngoài cwd được user cấp quyền qua /add-dir. Path tool sẽ chấp
-// nhận nếu nó nằm trong cwd HOẶC trong một extra root. Source of truth ở đây.
+// Các thư mục ngoài cwd được user cấp quyền qua /add-dir (hoặc auto-prompt khi
+// model tag folder lạ). Path tool sẽ chấp nhận nếu nằm trong cwd HOẶC một extra
+// root. Source of truth ở đây; persisted per-workspace tại `<cwd>/.noob/dirs.json`
+// để lần sau mở lại project không phải /add-dir lại từ đầu.
 const extraRoots = new Set();
+
+// Lỗi đặc biệt: path nằm ngoài cả cwd lẫn extraRoots. repl.js bắt riêng để HỎI
+// user perm thay vì trả thẳng cho model → UX mượt hơn (user không phải tự gõ
+// /add-dir). `suggestedRoot` = thư mục gần nhất tồn tại để add vào scope.
+export class OutOfScopeError extends Error {
+  constructor(p, suggestedRoot) {
+    super(`path nằm ngoài phạm vi (cwd + /add-dir): ${p}`);
+    this.name = "OutOfScopeError";
+    this.code = "OUT_OF_SCOPE";
+    this.path = p;
+    this.suggestedRoot = suggestedRoot;
+  }
+}
+
+// Tìm thư mục gần nhất TỒN TẠI để thêm vào extraRoots khi user approve.
+// - Nếu p là folder có thật → trả p.
+// - Nếu p là file có thật → trả parent folder.
+// - Nếu p không tồn tại → walk lên tới khi gặp folder có thật (thường là tổ tiên
+//   đã /add-dir trước đó, hoặc 1 ancestor mà user định cấp quyền). Trả null
+//   nếu đi tới filesystem root mà vẫn không có gì tồn tại.
+export function nearestExistingDir(p) {
+  if (!p) return null;
+  let cur = path.resolve(p);
+  while (true) {
+    try {
+      const st = fssync.statSync(cur);
+      if (st.isDirectory()) return cur;
+      return path.dirname(cur);
+    } catch {
+      const parent = path.dirname(cur);
+      if (parent === cur) return null;
+      cur = parent;
+    }
+  }
+}
+
+// Persist per-workspace. File `<cwd>/.noob/dirs.json` chứa mảng path tuyệt đối.
+// Lưu NGAY khi addRoot được gọi (cả /add-dir lẫn auto-prompt path), nên user
+// không phải /add-dir lại mỗi lần mở project. Nếu read-only hoặc permission
+// deny → âm thầm bỏ qua (addRoot vẫn áp dụng cho phiên hiện tại).
+const WORKSPACE_DIRS_FILE = () => path.join(cwd(), ".noob", "dirs.json");
+function loadWorkspaceRoots() {
+  try {
+    const raw = fssync.readFileSync(WORKSPACE_DIRS_FILE(), "utf8");
+    const arr = JSON.parse(raw);
+    if (!Array.isArray(arr)) return;
+    for (const r of arr) {
+      if (typeof r !== "string") continue;
+      const full = path.resolve(r);
+      try {
+        if (fssync.statSync(full).isDirectory()) extraRoots.add(full);
+      } catch {}
+    }
+  } catch {}
+}
+function saveWorkspaceRoots() {
+  try {
+    const file = WORKSPACE_DIRS_FILE();
+    fssync.mkdirSync(path.dirname(file), { recursive: true });
+    fssync.writeFileSync(file, JSON.stringify([...extraRoots], null, 2), "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+loadWorkspaceRoots();
+
 export function addRoot(p) {
   if (!p) throw new Error("thiếu path");
   const full = path.resolve(p);
@@ -16,8 +85,17 @@ export function addRoot(p) {
   try { st = fssync.statSync(full); } catch { throw new Error("không tồn tại: " + p); }
   if (!st.isDirectory()) throw new Error("không phải thư mục: " + p);
   extraRoots.add(full);
+  saveWorkspaceRoots(); // persist per-workspace — lần sau mở project auto-load
   return full;
 }
+export function removeRoot(p) {
+  const full = path.resolve(p);
+  if (extraRoots.delete(full)) {
+    saveWorkspaceRoots();
+    return true;
+  }
+  return false;
+}
 export function listRoots() {
   return [cwd(), ...extraRoots];
 }
@@ -30,21 +108,22 @@ function within(root, full) {
 const abs = (p) => {
   if (!p) return cwd();
   // Path tuyệt đối: chấp nhận nếu nằm trong cwd hoặc một extra root, không thì
-  // ném lỗi rõ ràng (tools dưới sẽ propagate cho LLM).
+  // ném OutOfScopeError để repl có thể catch riêng + hỏi user perm.
   if (path.isAbsolute(p)) {
     const full = path.resolve(p);
     if (within(cwd(), full)) return full;
     for (const r of extraRoots) if (within(r, full)) return full;
-    throw new Error("path nằm ngoài phạm vi (cwd + /add-dir): " + p);
+    throw new OutOfScopeError(p, nearestExistingDir(p));
   }
-  // Tương đối: ưu tiên cwd; nếu thoát cwd thì thử từng extra root.
+  // Tương đối: ưu tiên cwd; nếu thoát cwd thì thử từng extra root. Tương đối
+  // escape cwd thường là model tính sai — KHÔNG auto-prompt, chỉ trả lỗi rõ.
   const full = path.resolve(cwd(), p);
   if (within(cwd(), full)) return full;
   for (const r of extraRoots) {
     const fr = path.resolve(r, p);
     if (within(r, fr)) return fr;
   }
-  throw new Error("path nằm ngoài phạm vi (cwd + /add-dir): " + p);
+  throw new OutOfScopeError(p, nearestExistingDir(p));
 };
 const rel = (p) => path.relative(cwd(), p) || ".";
 // Tên rút gọn để hiển thị: nếu path thuộc cwd → relative cwd; nếu thuộc một

package/src/tui.js

@@ -27,42 +27,50 @@ function findVisPos(text, targetVis) {
   }
   return i;
 }
-// Soft-wrap `text` thành tối đa `maxLines` dòng, sao cho mỗi dòng có độ rộng
-// VISUAL ≤ `width`. Ưu tiên cắt tại khoảng trắng gần cuối (word boundary); nếu
-// không có space hợp lý → hard-slice theo visual position. Nếu text gốc có
-// ANSI escape thì MỌI dòng output (kể cả dòng cuối "vừa khít") đều kết thúc
-// bằng `\x1b[0m` reset — chống "chảy máu" màu khi status bar có dim/accent.
-// Nếu vẫn còn dư → dòng cuối thêm "…".
+// Soft-wrap `text` thành các dòng có độ rộng VISUAL ≤ `width`. Ưu tiên cắt tại
+// khoảng trắng gần cuối (word boundary); không có space hợp lý → hard-slice
+// theo visual position. Nếu text gốc có ANSI escape thì MỌI dòng output (kể cả
+// dòng cuối "vừa khít") đều kết thúc bằng `\x1b[0m` reset — chống "chảy máu"
+// màu khi status bar có dim/accent.
+//
+// Tail-follow: sau khi wrap TOÀN BỘ, chỉ trả về `maxLines` dòng CUỐI. Hành vi
+// này biến dòng topRow thành "page" cuối cùng của stream — khi AI phát sinh
+// thêm text mới, page tự dịch xuống theo cursor (giống `tail -f`), user luôn
+// thấy đúng phần đang được viết thay vì các dòng đầu tiên. Nếu wrap nhiều hơn
+// `maxLines` dòng → dòng đầu page thêm "…" phía trước (và cắt 1 ký tự cuối để
+// giữ nguyên độ rộng terminal, tránh re-wrap) để báo "có nội dung bị ẩn trên".
 function wrapText(text, width, maxLines) {
   if (!text) return [""];
   const hasAnsi = /\x1b/.test(text);
   const RESET = "\x1b[0m";
   const close = (line) => (hasAnsi ? line + RESET : line);
   if (visLen(text) <= width) return [close(text)];
+  // Wrap toàn bộ (không dừng ở maxLines) — cần đầy đủ để biết "page" hiện tại
+  // nằm ở đâu trong tổng stream.
   const lines = [];
   let remaining = text;
-  while (remaining && lines.length < maxLines) {
+  while (remaining) {
     if (visLen(remaining) <= width) {
-      lines.push(close(remaining));
+      lines.push(remaining);
       remaining = "";
       break;
     }
-    // Cắt tại vị trí visual = width. Sau đó thử lùi về space gần nhất (trong
-    // khoảng 30–100% width) để tránh cắt giữa từ.
     let cutPos = findVisPos(remaining, width);
     const slice = remaining.slice(0, cutPos);
     const lastSpace = slice.lastIndexOf(" ");
     if (lastSpace > width * 0.3) cutPos = lastSpace;
-    lines.push(close(remaining.slice(0, cutPos).trimEnd()));
+    lines.push(remaining.slice(0, cutPos).trimEnd());
     remaining = remaining.slice(cutPos).trimStart();
   }
-  if (remaining && lines.length) {
-    const last = lines.length - 1;
-    const lastLine = lines[last];
-    const body = lastLine.endsWith(RESET) ? lastLine.slice(0, -RESET.length) : lastLine;
-    lines[last] = (body.length ? body.slice(0, -1) : "") + "…" + (hasAnsi ? RESET : "");
+  if (lines.length > maxLines) {
+    const visible = lines.slice(-maxLines).map(close);
+    const first = visible[0];
+    const body = first.endsWith(RESET) ? first.slice(0, -RESET.length) : first;
+    const trimmed = body.length ? body.slice(0, -1) : "";
+    visible[0] = "…" + trimmed + (hasAnsi ? RESET : "");
+    return visible;
   }
-  return lines;
+  return lines.map(close);
 }
 const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];