@noobdemon/noob-cli 1.1.2 → 1.2.0

package/package.json

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

package/src/agent.js

@@ -177,8 +177,13 @@ export function parseToolCall(text) {
  * @param {(msg:string)=>void} opts.onStatus      thinking/streaming status
  * @returns {Promise<string>} the final assistant answer (no tool block)
  */
-export async function runAgent({ history, model, signal, onTool, onStatus, onDelta }) {
+export async function runAgent({ history, model, signal, onTool, onStatus, onDelta, onSteer }) {
   for (let step = 0; step < MAX_STEPS; step++) {
+    // Steering: tin nhắn người dùng gõ GIỮA CHỪNG được chèn vào hội thoại TRƯỚC
+    // lần gọi model kế tiếp → model thấy và điều chỉnh ngay trong cùng task.
+    const steer = onSteer?.() || [];
+    for (const msg of steer) history.push({ role: "user", content: msg });
+
     const prompt = buildPrompt(history);
     onStatus?.("thinking");
     onDelta?.({ type: "step-start" });

package/src/i18n.js

@@ -13,6 +13,9 @@ export const t = {
   denied: "đã từ chối",
   queued: (n, txt) => `⏎ đã xếp hàng [${n}] · gửi khi model xong: ${txt}`,
   queueCleared: (n) => `(đã xoá ${n} tin đang xếp hàng)`,
+  steerHint: "💬 Gõ + Enter bất cứ lúc nào để chèn ý cho AI giữa chừng (không ngắt task đang chạy).",
+  steerWillInject: (txt) => `💬 sẽ chèn cho AI ở bước tới: ${txt}`,
+  steerInject: (txt) => `💬 đã chèn cho AI: ${txt}`,
   permRetry: "→ gõ y (đồng ý) · n (từ chối) · a (luôn cho phép)",
 
   // auth

package/src/repl.js

@@ -1,7 +1,6 @@
-import readline from "node:readline";
 import process from "node:process";
-import ora from "ora";
 import chalk from "chalk";
+import { createTui } from "./tui.js";
 import { runAgent } from "./agent.js";
 import { stream, usage, ApiError } from "./api.js";
 import { runTool, describe, DESTRUCTIVE } from "./tools.js";
@@ -40,97 +39,35 @@ export async function startRepl(opts = {}) {
   // nguyên reader đang chờ (người dùng chỉ thấy prompt hiện lại). Chỉ dừng thật
   // khi: /exit, Ctrl+C hai lần, hoặc EOF thật (stdin piped đã cạn / 'close' dồn
   // dập nghĩa là stdin đã mất).
-  let rl;
-  let closed = false; // đã ngừng đọc vĩnh viễn
-  let exiting = false; // ta chủ động thoát (/exit, Ctrl+C ×2)
-  let lastPrompt = ""; // áp lại sau khi dựng lại interface
-  // Hàng đợi tin nhắn (giống Claude Code): khi model đang chạy, gõ thêm câu hỏi
-  // → xếp vào `pending`; xong turn, main loop tự lấy câu kế tiếp gửi lên. CHỈ
-  // main loop tiêu thụ `pending`. Câu trả lời permission đi qua `waiter` riêng,
-  // nên tin xếp hàng KHÔNG bị nhầm thành câu trả lời "cho phép?".
-  const pending = [];
-  let waiter = null; // resolver đang chờ một dòng tươi (prompt / permission)
-  let closeAt = 0;
-
-  function deliver(line) {
-    if (waiter) {
-      const w = waiter;
-      waiter = null;
-      w(line);
-      return;
-    }
-    // Không ai đang hỏi → đây là tin xếp hàng cho lượt kế tiếp.
-    pending.push(line);
-    if (process.stdin.isTTY) console.log(c.dim("  " + t.queued(pending.length, truncate(line, 60))));
-  }
-  function endInput() {
-    closed = true;
-    if (waiter) {
-      const w = waiter;
-      waiter = null;
-      w(null);
-    }
-  }
-  function buildRl() {
-    const r = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: "" });
-    r.on("line", deliver);
-    r.on("close", () => {
-      if (exiting) return endInput(); // ta chủ động thoát
-      // EOF THẬT: stdin đã end/destroy (Ctrl+Z trên Windows, Ctrl+D trên *nix),
-      // hoặc stdin không phải TTY (piped) đã đọc hết. Chỉ lúc đó mới dừng.
-      if (!process.stdin.isTTY || process.stdin.readableEnded || process.stdin.destroyed) {
-        return endInput();
-      }
-      // 'close' BẤT THƯỜNG trên một TTY còn sống (tranh chấp console khi
-      // paste/đa dòng, tiến trình con, v.v.) → KHÔNG BAO GIỜ thoát. Dựng lại
-      // interface và hiện lại prompt; reader đang chờ vẫn được giữ nguyên. Nếu
-      // close dồn dập thì hoãn 50ms để khỏi quay CPU — nhưng vẫn sống.
-      const now = Date.now();
-      const fast = now - closeAt < 50;
-      closeAt = now;
-      const rebuild = () => {
-        rl = buildRl();
-        if (lastPrompt) {
-          rl.setPrompt(lastPrompt);
-          rl.prompt();
-        }
-      };
-      if (fast) setTimeout(rebuild, 50);
-      else rebuild();
-    });
-    return r;
-  }
-  rl = buildRl();
+  let closed = false;
+  let exiting = false;
+  const pending = []; // hàng đợi tin nhắn (steering giữa task / lượt mới)
+
+  // Toàn bộ I/O qua `tui`: thanh nhập ghim đáy, output cuộn trên, paste nhiều
+  // dòng → "[pasted N lines]" nhưng gửi đủ. Không phải TTY / NOOB_TUI=0 → dumb
+  // mode = đọc dòng thường (an toàn pipe/CI/terminal lạ).
+  const tui = createTui({
+    onLine: (line) => {
+      // Submit khi KHÔNG có read() đang chờ = tin xếp hàng. Đang chạy task → sẽ
+      // CHÈN cho AI ở bước kế tiếp (steering); rảnh → gửi như lượt mới.
+      pending.push(line);
+      tui.print(abort ? c.user("  " + t.steerWillInject(truncate(line, 60))) : c.dim("  " + t.queued(pending.length, truncate(line, 60))));
+    },
+    onInterrupt: () => interrupt(),
+    onEOF: () => {
+      closed = true;
+    },
+    onShiftTab: () => {
+      state.yolo = !state.yolo;
+      tui.print(state.yolo ? c.err("  " + t.yoloOn) : c.ok("  " + t.yoloOff));
+      tui.setPrompt(promptStr(false));
+    },
+  });
 
-  function nextLine() {
-    if (closed) return Promise.resolve(null);
-    return new Promise((res) => (waiter = res));
-  }
-  // Dòng "tươi": dùng cho prompt chính VÀ cho permission. KHÔNG đụng tới
-  // `pending` (hàng đợi tin nhắn) — chỉ main loop mới rút từ `pending`.
+  // Dòng "tươi" cho prompt chính VÀ permission. KHÔNG đụng `pending`.
   function ask(prompt) {
     if (closed) return Promise.resolve(null);
-    lastPrompt = prompt;
-    rl.setPrompt(prompt);
-    rl.prompt();
-    return nextLine();
-  }
-
-  // Shift+Tab — bật/tắt yolo nhanh (best-effort; gắn vào stdin nên sống qua mọi
-  // lần dựng lại rl; bọc try/catch để không bao giờ làm hỏng input).
-  if (process.stdin.isTTY) {
-    try {
-      readline.emitKeypressEvents(process.stdin);
-      process.stdin.on("keypress", (_str, key) => {
-        if (!key || key.name !== "tab" || !key.shift) return;
-        state.yolo = !state.yolo;
-        console.log(state.yolo ? c.err("  " + t.yoloOn) : c.ok("  " + t.yoloOff));
-        rl.setPrompt(promptStr(false)); // cập nhật dòng trạng thái ngay lập tức
-        rl.prompt(true);
-      });
-    } catch {
-      /* không có Shift+Tab cũng được — vẫn dùng /yolo */
-    }
+    return tui.read(prompt);
   }
 
   // NOOB_DEBUG=1: vạch trần đường thoát thật sự (xác nhận/loại bỏ giả thuyết
@@ -143,7 +80,19 @@ export async function startRepl(opts = {}) {
 
   let abort = null; // active turn controller
   let sigintArmed = false;
-  process.on("SIGINT", () => {
+  let sigintTimer = null;
+  let lastInterrupt = 0;
+
+  // Ctrl+C — một đường xử lý duy nhất, gọi từ 3 nguồn (xem bên dưới) vì readline
+  // ở chế độ terminal/raw NUỐT SIGINT của process trên Windows. Debounce 80ms để
+  // gộp các nguồn trùng nhau thành MỘT lần nhấn.
+  //   • đang chạy task  → 1 lần = NGỪNG task (không thoát)
+  //   • đang rảnh       → 1 lần = đếm 1.5s; thêm 1 lần trong 1.5s = THOÁT CLI
+  function interrupt() {
+    const now = Date.now();
+    if (now - lastInterrupt < 80) return; // gộp SIGINT + 'SIGINT' của rl + keypress
+    lastInterrupt = now;
+
     if (abort) {
       abort.abort();
       abort = null;
@@ -153,17 +102,34 @@ export async function startRepl(opts = {}) {
         console.log(c.dim("  " + t.queueCleared(n)));
       }
       console.log(c.err("\n  ✗ " + t.interrupted));
-      return; // the main loop will redraw the prompt
+      sigintArmed = false;
+      if (sigintTimer) {
+        clearTimeout(sigintTimer);
+        sigintTimer = null;
+      }
+      if (!closed) tui.setPrompt(promptStr(false));
+      return;
     }
+
     if (sigintArmed) {
+      // lần 2 trong cửa sổ 1.5s → thoát
+      if (sigintTimer) clearTimeout(sigintTimer);
+      exiting = true;
+      persist();
       console.log(c.dim("\n  " + t.bye));
+      tui.close(); // khôi phục terminal (raw mode/paste/stdout) trước khi thoát
       process.exit(0);
     }
+    // lần 1 → vũ trang, đếm 1.5s
     sigintArmed = true;
     console.log(c.dim("\n  " + t.pressAgainToExit));
-    setTimeout(() => (sigintArmed = false), 2000);
-    rl.prompt(true);
-  });
+    sigintTimer = setTimeout(() => {
+      sigintArmed = false;
+      sigintTimer = null;
+    }, 1500);
+    if (!closed) tui.setPrompt(promptStr(false));
+  }
+  process.on("SIGINT", interrupt);
 
   // Đừng để một lỗi bất ngờ làm "tự động tắt" CLI. Nguyên nhân hay gặp:
   // tiến trình cập nhật nền (spawn npm) phát sự kiện 'error' không ai bắt,
@@ -172,11 +138,11 @@ export async function startRepl(opts = {}) {
   process.on("uncaughtException", (err) => {
     if (abort) { abort.abort(); abort = null; }
     console.log(c.err("\n  ✗ lỗi: " + (err?.message || err)));
-    if (!closed) rl.prompt(true);
+    if (!closed) tui.setPrompt(promptStr(false));
   });
   process.on("unhandledRejection", (err) => {
     console.log(c.err("\n  ✗ lỗi nền: " + (err?.message || err)));
-    if (!closed) rl.prompt(true);
+    if (!closed) tui.setPrompt(promptStr(false));
   });
 
   // ── phiên (session): lưu lịch sử + resume giống Claude Code ───────────────
@@ -260,6 +226,7 @@ Cuối cùng: tóm tắt + danh sách sửa theo thứ tự ưu tiên. Thẳng t
     persist();
   }
 
+  tui.start();
   banner();
   printStatus(state);
   if (!config.apiKey) console.log("\n" + c.tool("  " + t.notLoggedIn) + "\n");
@@ -310,9 +277,8 @@ Cuối cùng: tóm tắt + danh sách sửa theo thứ tự ưu tiên. Thẳng t
     if (pending.length) {
       // Có tin xếp hàng → tự gửi câu kế tiếp (không chờ gõ).
       input = (pending.shift() ?? "").trim();
-      if (process.stdin.isTTY && input) console.log(promptStr() + input);
     } else {
-      const raw = await ask(promptStr());
+      const raw = await ask(promptStr(false));
       if (raw == null) break; // stdin fully closed and drained
       input = raw.trim();
     }
@@ -333,7 +299,7 @@ Cuối cùng: tóm tắt + danh sách sửa theo thứ tự ưu tiên. Thẳng t
     }
   }
   exiting = true;
-  rl.close();
+  tui.close();
   process.exit(0);
 
   // ── turn handler ─────────────────────────────────────────────────────────
@@ -343,27 +309,22 @@ Cuối cùng: tóm tắt + danh sách sửa theo thứ tự ưu tiên. Thẳng t
       return;
     }
     abort = new AbortController();
-    // discardStdin:false — TỐI QUAN TRỌNG. Mặc định ora chiếm stdin (raw mode +
-    // pause) để "nuốt" input khi quay. Trên Windows nó KHÔNG khôi phục sạch khi
-    // stop → stdin chết → prompt "cho phép?" hiện ra rồi event loop cạn → CLI tự
-    // out; và Ctrl+C không thành SIGINT (phải spam mới thoát). Tắt hẳn để ora
-    // đừng đụng stdin — readline tự quản.
-    const spinner = ora({ color: "magenta", spinner: "dots", discardStdin: false });
+    // spinner: status hiển thị qua tui (thanh dưới), tui tự animate khung xoay
     const t0 = Date.now();
     let timer = null;
     const tick = (label) => {
       const elapsed = ((Date.now() - t0) / 1000).toFixed(0);
-      spinner.text = c.dim(`${label}… ${elapsed}s`);
+      tui.status(c.dim(`${label}… ${elapsed}s`));
     };
     const stopSpin = () => {
       if (timer) {
         clearInterval(timer);
         timer = null;
       }
-      if (spinner.isSpinning) spinner.stop();
+      tui.status(null);
     };
     const startSpin = (label) => {
-      if (!spinner.isSpinning) spinner.start();
+      // (tui hiện status khi tick gọi)
       if (!timer) timer = setInterval(() => tick(label), 200);
     };
 
@@ -378,7 +339,7 @@ Cuối cùng: tóm tắt + danh sách sửa theo thứ tự ưu tiên. Thẳng t
           message: text,
           signal: abort.signal,
           onStatus: (s) => {
-            if (!printer.started) spinner.text = c.dim("  " + s);
+            if (!printer.started) tui.status(c.dim("  " + s));
           },
           onDelta: (d) => {
             stopSpin();
@@ -392,6 +353,10 @@ Cuối cùng: tóm tắt + danh sách sửa theo thứ tự ưu tiên. Thẳng t
       }
 
       state.history.push({ role: "user", content: text });
+      if (process.stdin.isTTY && !state.steerHintShown) {
+        console.log(c.dim("  " + t.steerHint));
+        state.steerHintShown = true;
+      }
       startSpin(t.thinking);
       let printer = null;
 
@@ -400,6 +365,14 @@ Cuối cùng: tóm tắt + danh sách sửa theo thứ tự ưu tiên. Thẳng t
         model: state.model.id,
         signal: abort.signal,
         onStatus: () => tick(t.thinking),
+        onSteer: () => {
+          if (!pending.length) return [];
+          const msgs = pending.splice(0);
+          stopSpin(); // in sạch dòng chèn rồi cho spinner chạy lại
+          for (const msg of msgs) console.log(c.user("  " + t.steerInject(truncate(msg, 70))));
+          startSpin(t.thinking);
+          return msgs;
+        },
         onDelta: (ev) => {
           if (ev.type === "step-start") {
             printer = makeStreamPrinter(state.model.name, providerColor(state.model.provider));
@@ -450,14 +423,14 @@ Cuối cùng: tóm tắt + danh sách sửa theo thứ tự ưu tiên. Thẳng t
       }
     }
 
-    const sp = ora({ text: c.dim("  " + t.running), color: "yellow", discardStdin: false }).start();
+    tui.status(c.dim("  " + t.running));
     try {
       const result = await runTool(name, input);
-      sp.stop();
+      tui.status(null);
       console.log(c.ok("  ✓ ") + c.dim(firstLine(result)));
       return { allow: true, result };
     } catch (err) {
-      sp.stop();
+      tui.status(null);
       console.log(c.err("  ✗ " + err.message));
       return { allow: true, result: "ERROR: " + err.message };
     }
@@ -537,7 +510,7 @@ Cuối cùng: tóm tắt + danh sách sửa theo thứ tự ưu tiên. Thẳng t
         persist(); // giữ lại phiên cũ trên đĩa
         state.history = [];
         startFresh(); // phiên mới (phiên cũ vẫn resume được)
-        console.clear();
+        if (!tui.tty) console.clear();
         banner();
         printStatus(state);
         console.log(c.dim("  " + t.ctxCleared + "\n"));
@@ -592,14 +565,14 @@ Cuối cùng: tóm tắt + danh sách sửa theo thứ tự ưu tiên. Thẳng t
 
   async function showUsage() {
     if (!config.apiKey) return console.log(c.tool("  " + t.notLoggedIn));
-    const sp = ora({ text: c.dim("  ..."), color: "magenta", discardStdin: false }).start();
+    tui.status(c.dim("  ..."));
     try {
       const u = await usage();
-      sp.stop();
+      tui.status(null);
       if (!u.ok) return printError(new ApiError(t.errInvalidKey, { code: u.error }));
       printUsage(u);
     } catch (err) {
-      sp.stop();
+      tui.status(null);
       printError(err);
     }
   }

package/src/tui.js

@@ -0,0 +1,312 @@
+// Bộ render kiểu TUI: thanh nhập GHIM ở đáy, output cuộn phía trên, không nhấp
+// nháy. Hỗ trợ paste nhiều dòng → hiện "[pasted N lines]" nhưng GỬI toàn bộ nội
+// dung. Hoạt động bằng cách "vá" process.stdout.write: mọi output (console.log,
+// stream token, box…) tự được commit phía TRÊN thanh nhập — nên repl gần như
+// không phải đổi chỗ in.
+//
+// Bật/tắt: TTY thật → chế độ giàu; không phải TTY hoặc NOOB_TUI=0 → chế độ "dumb"
+// (đọc dòng đơn giản, in thẳng) để khỏi vỡ ở terminal lạ / pipe / CI.
+import readline from "node:readline";
+import { c } from "./ui.js";
+
+const ESC = "\x1b";
+const ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+const visLen = (s) => s.replace(ANSI_RE, "").length;
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+export function createTui({ onLine, onInterrupt, onEOF, onShiftTab } = {}) {
+  const tty = !!(process.stdout.isTTY && process.stdin.isTTY) && process.env.NOOB_TUI !== "0";
+  const cols = () => process.stdout.columns || 80;
+
+  // ── chế độ DUMB (không TTY / tắt TUI): readline thường ───────────────────
+  if (!tty) {
+    let rl = null;
+    let waiter = null;
+    const queue = [];
+    let closed = false;
+    const build = () => {
+      const r = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: "" });
+      r.on("line", (line) => {
+        if (waiter) {
+          const w = waiter;
+          waiter = null;
+          w(line);
+        } else if (onLine) onLine(line);
+        else queue.push(line);
+      });
+      r.on("close", () => {
+        closed = true;
+        if (waiter) {
+          const w = waiter;
+          waiter = null;
+          w(null);
+        }
+        onEOF?.();
+      });
+      return r;
+    };
+    return {
+      tty: false,
+      start() {
+        rl = build();
+        process.on("SIGINT", () => onInterrupt?.());
+      },
+      print() {},
+      status() {},
+      setPrompt() {},
+      read() {
+        if (queue.length) return Promise.resolve(queue.shift());
+        if (closed) return Promise.resolve(null);
+        return new Promise((res) => (waiter = res));
+      },
+      close() {
+        try {
+          rl?.close();
+        } catch {}
+      },
+    };
+  }
+
+  // ── chế độ GIÀU (TTY) ─────────────────────────────────────────────────────
+  const realWrite = process.stdout.write.bind(process.stdout);
+  const w = (s) => realWrite(s);
+
+  let liveOut = ""; // dòng output dở dang (chưa có '\n') hiện ngay trên thanh
+  let statusText = null; // text spinner khi đang nghĩ
+  let frame = 0;
+  let frameTimer = null;
+  let prevRows = 0;
+  let drawn = false;
+
+  let promptLabel = "";
+  let parts = []; // input: {type:'text',value} | {type:'paste',value,lines}
+  let waiter = null;
+  const queue = [];
+
+  // ----- input → chuỗi đầy đủ + bản hiển thị (paste = chip) -----
+  const fullText = () => parts.map((p) => p.value).join("");
+  const dispPlain = () => parts.map((p) => (p.type === "paste" ? `[pasted ${p.lines} lines]` : p.value)).join("");
+  const dispColored = () =>
+    parts.map((p) => (p.type === "paste" ? c.dim(`[pasted ${p.lines} lines]`) : p.value)).join("");
+
+  function renderBar() {
+    const budget = Math.max(4, cols() - visLen(promptLabel) - 1);
+    const plain = dispPlain();
+    if (plain.length <= budget) return promptLabel + dispColored();
+    return promptLabel + "…" + plain.slice(plain.length - (budget - 1)); // giữ đuôi (chỗ đang gõ)
+  }
+  function topRow() {
+    if (liveOut) return liveOut.slice(0, cols());
+    if (statusText) return c.dim(FRAMES[frame % FRAMES.length] + " ") + statusText;
+    return null;
+  }
+  function rows() {
+    const r = [];
+    const top = topRow();
+    if (top !== null) r.push(top);
+    r.push(renderBar());
+    return r;
+  }
+  function eraseSeq() {
+    if (!drawn) return "\r";
+    return "\r" + (prevRows > 1 ? `${ESC}[${prevRows - 1}A` : "") + `${ESC}[J`;
+  }
+  function draw() {
+    const rs = rows();
+    w(`${ESC}[?25l` + eraseSeq() + rs.join("\n") + `${ESC}[?25h`);
+    prevRows = rs.length;
+    drawn = true;
+  }
+  // In khối text VĨNH VIỄN phía trên thanh, rồi vẽ lại thanh.
+  function commit(block) {
+    const rs = rows();
+    let s = `${ESC}[?25l` + eraseSeq();
+    s += block;
+    if (!block.endsWith("\n")) s += "\n";
+    s += rs.join("\n") + `${ESC}[?25h`;
+    w(s);
+    prevRows = rs.length;
+    drawn = true;
+  }
+
+  // Mọi stdout đi qua đây: tách dòng hoàn chỉnh → commit; phần dở → liveOut.
+  function feedOutput(text) {
+    let buf = liveOut + text;
+    let nl;
+    const done = [];
+    while ((nl = buf.indexOf("\n")) !== -1) {
+      done.push(buf.slice(0, nl));
+      buf = buf.slice(nl + 1);
+    }
+    liveOut = buf;
+    if (done.length) commit(done.join("\n"));
+    else draw();
+  }
+
+  // ----- bàn phím: paste (bracketed) + heuristic chunk nhiều dòng -----
+  function pushText(str) {
+    if (!str) return;
+    const last = parts[parts.length - 1];
+    if (last && last.type === "text") last.value += str;
+    else parts.push({ type: "text", value: str });
+  }
+  function pushPaste(content) {
+    const lines = content.split("\n").length;
+    if (lines >= 2) parts.push({ type: "paste", value: content, lines });
+    else pushText(content); // paste 1 dòng = gõ thẳng
+  }
+  function backspace() {
+    const last = parts[parts.length - 1];
+    if (!last) return;
+    if (last.type === "paste") parts.pop();
+    else {
+      last.value = [...last.value].slice(0, -1).join("");
+      if (!last.value) parts.pop();
+    }
+  }
+  function submit() {
+    const full = fullText();
+    const echo = promptLabel + dispColored();
+    parts = [];
+    commit(echo); // hiện lại dòng đã gõ (paste = chip) vào scrollback
+    draw();
+    if (waiter) {
+      const wr = waiter;
+      waiter = null;
+      wr(full);
+    } else if (onLine) onLine(full);
+    else queue.push(full);
+  }
+
+  let carry = "";
+  let inPaste = false;
+  let pasteAcc = "";
+  function feedKeys(data) {
+    let s = carry + data;
+    carry = "";
+    let i = 0;
+    while (i < s.length) {
+      if (inPaste) {
+        const end = s.indexOf(`${ESC}[201~`, i);
+        if (end === -1) {
+          // giữ lại tối đa 5 ký tự cuối phòng marker bị cắt ngang chunk
+          let safe = s.length;
+          for (let k = 1; k <= 5; k++) if (`${ESC}[201~`.startsWith(s.slice(s.length - k))) { safe = s.length - k; break; }
+          pasteAcc += s.slice(i, safe);
+          carry = s.slice(safe);
+          return;
+        }
+        pasteAcc += s.slice(i, end);
+        inPaste = false;
+        pushPaste(pasteAcc.replace(/\r\n/g, "\n").replace(/\r/g, "\n"));
+        pasteAcc = "";
+        i = end + 6;
+        draw();
+        continue;
+      }
+      const rest = s.slice(i);
+      if (`${ESC}[200~`.startsWith(rest) && rest.length < 6) { carry = rest; return; } // marker dở
+      if (rest.startsWith(`${ESC}[200~`)) { inPaste = true; pasteAcc = ""; i += 6; continue; }
+      const ch = s[i];
+      if (ch === ESC) {
+        // esc seq (mũi tên…) — bỏ qua ở v1
+        const m = rest.match(/^\x1b\[[0-9;]*[A-Za-z~]/) || rest.match(/^\x1bO[A-Za-z]/);
+        if (m) { i += m[0].length; continue; }
+        if (rest.length < 3) { carry = rest; return; } // esc dở
+        i += 1;
+        continue;
+      }
+      if (ch === "\r" || ch === "\n") {
+        submit();
+        if (ch === "\r" && s[i + 1] === "\n") i++; // nuốt \n của \r\n
+        i++;
+        continue;
+      }
+      if (ch === "\x7f" || ch === "\b") { backspace(); draw(); i++; continue; }
+      if (ch === "\x03") { onInterrupt?.(); i++; continue; } // Ctrl+C
+      if (ch === "\x15") { parts = []; draw(); i++; continue; } // Ctrl+U xoá dòng
+      if (ch === "\x04") { if (!fullText()) onEOF?.(); i++; continue; } // Ctrl+D
+      if (ch === "\t") { i++; continue; } // tab thường — bỏ (shift+tab xử lý qua keypress)
+      if (ch < " ") { i++; continue; } // control khác — bỏ
+      // ký tự in được (kể cả UTF-8 vì stdin đã setEncoding utf8)
+      pushText(ch);
+      draw();
+      i++;
+    }
+  }
+
+  function onData(data) {
+    // Heuristic fallback cho terminal KHÔNG hỗ trợ bracketed-paste: một lần gõ
+    // tay không bao giờ tạo ra "xuống dòng GIỮA chuỗi". Vậy nếu cả cục có một
+    // newline KHÔNG nằm cuối (tức còn nội dung sau nó) → đó là PASTE nhiều dòng.
+    if (!inPaste && !data.includes(`${ESC}[200~`)) {
+      const norm = data.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+      const firstNl = norm.indexOf("\n");
+      if (firstNl !== -1 && firstNl < norm.length - 1 && data.length > 1) {
+        const body = norm.endsWith("\n") ? norm.slice(0, -1) : norm; // bỏ 1 newline đuôi
+        pushPaste(body); // ≥2 dòng → chip; KHÔNG auto-submit (người dùng Enter để gửi)
+        draw();
+        return;
+      }
+    }
+    feedKeys(data);
+  }
+
+  return {
+    tty: true,
+    start() {
+      process.stdin.setEncoding("utf8");
+      if (process.stdin.setRawMode) process.stdin.setRawMode(true);
+      process.stdin.resume();
+      w(`${ESC}[?2004h`); // bật bracketed paste
+      process.stdin.on("data", onData);
+      // shift+tab: dùng keypress decoder song song (chỉ để bắt phím này)
+      try {
+        readline.emitKeypressEvents(process.stdin);
+        process.stdin.on("keypress", (_s, key) => {
+          if (key && key.name === "tab" && key.shift) onShiftTab?.();
+        });
+      } catch {}
+      // vá stdout: mọi output → commit phía trên thanh
+      process.stdout.write = (chunk, enc, cb) => {
+        feedOutput(typeof chunk === "string" ? chunk : chunk.toString(typeof enc === "string" ? enc : "utf8"));
+        if (typeof enc === "function") enc();
+        else if (typeof cb === "function") cb();
+        return true;
+      };
+      frameTimer = setInterval(() => {
+        if (statusText && !liveOut) {
+          frame++;
+          draw();
+        }
+      }, 90);
+      draw();
+    },
+    print(s = "") {
+      feedOutput(s.endsWith("\n") ? s : s + "\n");
+    },
+    status(text) {
+      statusText = text || null;
+      draw();
+    },
+    setPrompt(label) {
+      promptLabel = label || "";
+      draw();
+    },
+    read(label) {
+      if (label != null) promptLabel = label;
+      if (queue.length) return Promise.resolve(queue.shift());
+      draw();
+      return new Promise((res) => (waiter = res));
+    },
+    close() {
+      try {
+        if (frameTimer) clearInterval(frameTimer);
+        process.stdout.write = realWrite;
+        w(`${ESC}[?2004l${ESC}[?25h\n`);
+        if (process.stdin.setRawMode) process.stdin.setRawMode(false);
+        process.stdin.pause();
+      } catch {}
+    },
+  };
+}