@noobdemon/noob-cli 1.1.4 → 1.4.0

package/bin/noob.js

@@ -7,12 +7,13 @@ import { t } from "../src/i18n.js";
 import { checkLatest, runUpdate, CURRENT } from "../src/update.js";
 
 const argv = process.argv.slice(2);
-const opts = { yolo: false, model: undefined, prompt: undefined, continue: false, resume: false };
+const opts = { yolo: false, ultra: false, model: undefined, prompt: undefined, continue: false, resume: false };
 const positional = [];
 
 for (let i = 0; i < argv.length; i++) {
   const a = argv[i];
   if (a === "--yolo" || a === "-y") opts.yolo = true;
+  else if (a === "--ultra" || a === "-u") opts.ultra = true;
   else if (a === "--insecure-tls") process.env.NOOB_INSECURE_TLS = "1";
   else if (a === "--model" || a === "-m") opts.model = argv[++i];
   else if (a === "--continue" || a === "-c") opts.continue = true;
@@ -93,6 +94,7 @@ Cách dùng:
 Tuỳ chọn:
   -m, --model <id>    chọn mô hình (vd: gateway-claude-opus-4-7)
   -y, --yolo          tự động duyệt sửa file & chạy lệnh (cẩn thận)
+  -u, --ultra         tự hành: tự nghĩ & tự làm nhiệm vụ tới khi xong (kèm "yêu cầu")
   -c, --continue      tiếp tục phiên gần nhất (resume)
   -r, --resume[=id]   chọn phiên để tiếp tục (không id = hiện danh sách)
       --insecure-tls  tắt kiểm tra TLS (chỉ cho mạng có proxy chặn TLS)

package/package.json

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

package/src/agent.js

@@ -1,5 +1,6 @@
 import os from "node:os";
 import { stream } from "./api.js";
+import { loadMemory } from "./memory.js";
 import { t } from "./i18n.js";
 
 export const SYSTEM = `You are noob, an agentic coding assistant in the spirit of Claude Code. You help with software engineering tasks by reading and editing files and running commands in the user's current working directory.
@@ -34,6 +35,13 @@ Available tools:
 - JSON in the tool block must be valid: escape newlines as \\n inside string values.
 - LANGUAGE: Always write your prose answers to the user in Vietnamese (tiếng Việt), unless the user explicitly writes in another language. Keep code, file paths, commands, and tool JSON unchanged.
 
+# Self-memory (noob.md)
+- The project root may hold \`noob.md\` — YOUR long-term memory. Its current contents are injected below under "PROJECT MEMORY". Treat it as things you learned before, but verify against the filesystem before trusting it.
+- When you learn something durable and reusable — build/test/run commands, project conventions, architecture, user preferences, or progress on a long task — persist it: create \`noob.md\` with write_file if missing, otherwise edit_file to add/update. One fact per bullet, concise.
+- Structure noob.md as two sections: \`## Rules\` (proven conventions you MUST follow — treat them as binding) and \`## Notes\` (observations not yet proven). Put new learnings under Notes.
+- Self-improve loop: when a Note has proven true / recurred ~2–3 times, PROMOTE it into Rules and delete the duplicate Note. Keep noob.md bounded (~200 lines) — prune stale or contradicted entries, don't only append.
+- Do NOT put transient chatter or secrets in noob.md.
+
 # Coding principles (Karpathy) — apply to EVERY code change
 1. THINK FIRST: state the key assumptions before you code. If a requirement is ambiguous or a step is hard to reverse, ask ONE sharp question instead of guessing.
 2. KEEP IT SIMPLE: write the simplest thing that works. No speculative abstractions, no extra flags/config/layers "for later". Prefer deleting code to adding it.
@@ -130,10 +138,23 @@ function filesLedger(history) {
   );
 }
 
+// Chèn bộ nhớ noob.md (nếu có) vào prompt — đây là phần "tự học" mà noob đọc
+// lại mỗi lượt. Không có file → nhắc model tự tạo khi rút ra điều đáng nhớ.
+function memoryBlock() {
+  const mem = loadMemory();
+  if (!mem)
+    return "# PROJECT MEMORY (noob.md)\n(Chưa có noob.md trong thư mục này. Khi rút ra điều đáng nhớ lâu dài — lệnh build/test/run, quy ước, kiến trúc, sở thích người dùng, tiến độ — hãy TẠO noob.md bằng write_file và ghi vào đó.)";
+  return (
+    "# PROJECT MEMORY (noob.md — điều bạn đã tự học trước đó; xác minh với filesystem trước khi tin tuyệt đối)\n" +
+    mem +
+    "\n(Học thêm điều đáng nhớ → cập nhật noob.md bằng edit_file/write_file.)"
+  );
+}
+
 // The proxy is stateless, so we serialize the whole transcript into one prompt.
 function buildPrompt(history) {
   const msgs = compact(history, MAX_PROMPT_CHARS);
-  const parts = [SYSTEM, "", runtimeContext(), "", filesLedger(history), "", "=".repeat(60), "# CONVERSATION", ""];
+  const parts = [SYSTEM, "", runtimeContext(), "", memoryBlock(), "", filesLedger(history), "", "=".repeat(60), "# CONVERSATION", ""];
   for (const m of msgs) {
     if (m.role === "user") parts.push(`## USER\n${m.content}`);
     else if (m.role === "assistant") parts.push(`## ASSISTANT\n${m.content}`);

package/src/i18n.js

@@ -58,6 +58,9 @@ export const t = {
   cmdChat: "/chat          quay lại chế độ chat thường",
   cmdYolo: "/yolo          bật/tắt tự duyệt (hoặc nhấn Shift+Tab)",
   cmdKarpathy: "/karpathy [path]  rà soát code theo 4 nguyên tắc Karpathy (/kc)",
+  cmdUltra: "/ultra <mục tiêu>  tự hành: noob tự nghĩ & tự làm nhiệm vụ tới khi xong (/u)",
+  cmdLearn: "/learn [ghi chú]  chưng cất bài học của phiên vào noob.md",
+  cmdMemory: "/memory          xem bộ nhớ noob.md (/mem)",
   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",
@@ -90,6 +93,17 @@ export const t = {
   maxSteps: "_(đã dừng: chạm giới hạn số bước tool)_",
   toolDenied: "Người dùng từ chối thao tác này. Hãy đổi cách làm hoặc hỏi lại.",
 
+  // ultra (tự hành / self-quest) + bộ nhớ noob.md
+  ultraOn: "Ultra: BẬT — noob tự lập kế hoạch & tự làm tới khi xong (Ctrl+C để dừng).",
+  ultraDone: "Ultra: đã hoàn thành mục tiêu.",
+  ultraStopped: "Ultra: đã dừng.",
+  ultraMax: "Ultra: chạm giới hạn số vòng — dừng để bạn kiểm tra & ra lệnh tiếp.",
+  ultraNeedGoal: "Cần mục tiêu. Dùng: /ultra <mô tả mục tiêu>",
+  ultraQuest: (n) => `tự nghĩ nhiệm vụ kế tiếp (vòng ${n})…`,
+  learning: "đang chưng cất bài học vào noob.md…",
+  memoryEmpty: (p) => `Chưa có noob.md. noob sẽ tự tạo ở: ${p}`,
+  memoryStat: (n) => `  ·  ${n} dòng / ~200`,
+
   // sessions (lưu lịch sử + resume)
   sessionResumed: (id) => `Đã khôi phục phiên ${id}`,
   sessionNonePrev: "Chưa có phiên nào trước đó — bắt đầu phiên mới.",

package/src/memory.js

@@ -0,0 +1,21 @@
+// Bộ nhớ lâu dài của noob: file `noob.md` ở thư mục gốc dự án (giống CLAUDE.md /
+// AGENTS.md). noob TỰ tạo & TỰ cập nhật nó qua write_file/edit_file để học và
+// nhớ giữa các phiên. Runtime chỉ ĐỌC để chèn vào prompt — không tự ghi đè.
+import fs from "node:fs";
+import path from "node:path";
+
+const FILE = "noob.md";
+
+export function memoryPath() {
+  return path.resolve(process.cwd(), FILE);
+}
+
+/** Nội dung noob.md hiện tại, hoặc null nếu chưa có / rỗng. */
+export function loadMemory() {
+  try {
+    const txt = fs.readFileSync(memoryPath(), "utf8").trim();
+    return txt || null;
+  } catch {
+    return null;
+  }
+}

package/src/repl.js

@@ -1,17 +1,50 @@
-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";
 import { MODELS, PROVIDERS, findModel, providerColor, DEFAULT_MODEL } from "./models.js";
 import { c, banner, modelBadge, renderMarkdown, box } from "./ui.js";
 import { config } from "./config.js";
+import { loadMemory, memoryPath } from "./memory.js";
 import { t } from "./i18n.js";
 import { checkLatest, runUpdate, CURRENT } from "./update.js";
 import * as sessions from "./sessions.js";
 
+// Lệnh dùng cho autocomplete. Gõ "/l" → lọc các lệnh có "l" (login, logout,
+// clear, models, yolo…); ↑/↓ chọn, Tab điền, Enter chạy mục đang sáng.
+const SLASH = [
+  { name: "/help", desc: "danh sách lệnh" },
+  { name: "/model", desc: "đổi mô hình" },
+  { name: "/models", desc: "liệt kê mô hình" },
+  { name: "/merge", desc: "bật/tắt Merge AI" },
+  { name: "/search", desc: "bật/tắt tìm web" },
+  { name: "/chat", desc: "chế độ chat thường" },
+  { name: "/yolo", desc: "bật/tắt tự duyệt" },
+  { name: "/karpathy", desc: "rà soát code (Karpathy)" },
+  { name: "/ultra", desc: "tự hành: tự nghĩ & làm nhiệm vụ" },
+  { name: "/learn", desc: "chưng cất bài học vào noob.md" },
+  { name: "/memory", desc: "xem bộ nhớ noob.md" },
+  { name: "/login", desc: "đăng nhập bằng API key" },
+  { name: "/logout", desc: "đăng xuất" },
+  { name: "/usage", desc: "xem hạn mức key" },
+  { name: "/update", desc: "cập nhật noob" },
+  { name: "/clear", desc: "xoá ngữ cảnh / phiên mới" },
+  { name: "/resume", desc: "tiếp tục phiên cũ" },
+  { name: "/continue", desc: "tiếp tục phiên gần nhất" },
+  { name: "/sessions", desc: "liệt kê phiên đã lưu" },
+  { name: "/cwd", desc: "thư mục hiện tại" },
+  { name: "/status", desc: "trạng thái" },
+  { name: "/version", desc: "phiên bản" },
+  { name: "/exit", desc: "thoát" },
+];
+function completeSlash(text) {
+  if (!text.startsWith("/") || /\s/.test(text)) return []; // chỉ gợi ý khi đang gõ tên lệnh
+  const q = text.slice(1).toLowerCase();
+  return SLASH.filter((cmd) => cmd.name.slice(1).toLowerCase().includes(q));
+}
+
 export async function startRepl(opts = {}) {
   const state = {
     model: findModel(opts.model) || findModel(config.model) || findModel(DEFAULT_MODEL),
@@ -19,6 +52,7 @@ export async function startRepl(opts = {}) {
     history: [],
     autoApprove: new Set(),
     yolo: !!opts.yolo,
+    ultra: false, // chế độ tự hành (self-quest) đang chạy?
   };
 
   // Prompt = dòng trạng thái sống. Luôn phản ánh yolo + version theo thời gian
@@ -40,106 +74,36 @@ 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 → tin xếp hàng. Nếu đang chạy task → sẽ CHÈN cho AI ở
-    // bước kế tiếp (steering). Nếu rảnh → gửi như lượt mới khi tới phiên.
-    pending.push(line);
-    if (process.stdin.isTTY)
-      console.log(abort ? c.user("  " + t.steerWillInject(truncate(line, 60))) : 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);
-    // readline ở chế độ terminal phát 'SIGINT' của RIÊNG nó (không cho process
-    // SIGINT chạy) — nối vào cùng một handler. interrupt() được hoist nên gọi
-    // được dù khai báo phía dưới.
-    r.on("SIGINT", () => interrupt());
-    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));
+    },
+    completer: completeSlash,
+  });
 
-  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) return;
-        // Ctrl+C dạng phím thô — ở raw mode, Ctrl+C KHÔNG tự thành SIGINT nữa.
-        if (key.ctrl && key.name === "c") return interrupt();
-        if (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
@@ -168,6 +132,10 @@ export async function startRepl(opts = {}) {
     if (abort) {
       abort.abort();
       abort = null;
+      if (state.ultra) {
+        state.ultra = false; // Ctrl+C cũng dừng vòng tự hành, không chỉ lượt hiện tại
+        console.log(c.tool("  " + t.ultraStopped));
+      }
       if (pending.length) {
         const n = pending.length;
         pending.length = 0; // ngắt lượt → xoá luôn tin đang xếp hàng
@@ -179,7 +147,7 @@ export async function startRepl(opts = {}) {
         clearTimeout(sigintTimer);
         sigintTimer = null;
       }
-      if (!closed) rl.prompt(true);
+      if (!closed) tui.setPrompt(promptStr(false));
       return;
     }
 
@@ -189,6 +157,7 @@ export async function startRepl(opts = {}) {
       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
@@ -198,7 +167,7 @@ export async function startRepl(opts = {}) {
       sigintArmed = false;
       sigintTimer = null;
     }, 1500);
-    if (!closed) rl.prompt(true);
+    if (!closed) tui.setPrompt(promptStr(false));
   }
   process.on("SIGINT", interrupt);
 
@@ -209,11 +178,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 ───────────────
@@ -297,6 +266,73 @@ Cuối cùng: tóm tắt + danh sách sửa theo thứ tự ưu tiên. Thẳng t
     persist();
   }
 
+  // ── ULTRA: chế độ tự hành (self-quest) ────────────────────────────────────
+  // noob tự lập kế hoạch, TỰ chọn nhiệm vụ con kế tiếp, tự thực hiện & tự kiểm
+  // chứng — lặp tới khi model phát token ULTRA_DONE, chạm giới hạn vòng, hoặc
+  // người dùng Ctrl+C. Mỗi vòng là một lượt agent đầy đủ (dùng lại handle()).
+  const ULTRA_DONE = "<<ULTRA_DONE>>";
+  const MAX_QUESTS = 40;
+  const ultraStart = (goal) => `# CHẾ ĐỘ ULTRA (tự hành)
+Mục tiêu tổng: ${goal}
+
+Bạn sẽ TỰ lập kế hoạch và TỰ thực hiện từng bước tới khi hoàn thành, KHÔNG chờ người dùng xác nhận giữa chừng.
+- Mỗi lượt: chọn nhiệm vụ con hợp lý kế tiếp, làm nó bằng tool (đọc/sửa file, chạy lệnh).
+- Sau khi làm, tự kiểm chứng (build/test) khi hợp lý.
+- Ghi tiến độ + điều học được vào noob.md để không quên giữa các bước.
+- Khi và CHỈ KHI toàn bộ mục tiêu đã xong và đã kiểm chứng, kết thúc câu trả lời bằng đúng token ${ULTRA_DONE}.
+- Gặp việc nguy hiểm/không thể đảo ngược hoặc thật sự bí → DỪNG, hỏi 1 câu rõ ràng (đừng phát ${ULTRA_DONE}).
+Bắt đầu bằng kế hoạch ngắn (3–7 gạch đầu dòng) rồi làm bước đầu tiên.`;
+  const ultraContinue = (goal) => `Tiếp tục chế độ ULTRA — mục tiêu: ${goal}
+Tự đánh giá còn thiếu gì, chọn nhiệm vụ con kế tiếp và làm tiếp bằng tool. Cập nhật noob.md nếu học được điều mới.
+Khi toàn bộ mục tiêu đã xong và đã kiểm chứng, kết thúc bằng token ${ULTRA_DONE}.`;
+
+  async function runUltra(goal) {
+    if (!config.apiKey) return console.log(c.tool("  " + t.notLoggedIn));
+    if (!goal) return console.log(c.err("  " + t.ultraNeedGoal));
+    state.mode = "chat"; // tự hành chỉ chạy ở chế độ agent
+    state.ultra = true;
+    console.log(c.accent("  🚀 " + t.ultraOn));
+    let answer = await handle(ultraStart(goal));
+    persist();
+    let i = 0;
+    while (state.ultra && i < MAX_QUESTS) {
+      if (!answer) break; // lượt bị ngắt/ lỗi → dừng tự hành, đừng quay vô ích
+      if (answer.includes(ULTRA_DONE)) {
+        console.log(c.ok("  ✓ " + t.ultraDone));
+        break;
+      }
+      i++;
+      console.log(c.accent("  ↻ " + t.ultraQuest(i)));
+      answer = await handle(ultraContinue(goal));
+      persist();
+    }
+    if (state.ultra && i >= MAX_QUESTS) console.log(c.tool("  " + t.ultraMax));
+    state.ultra = false;
+  }
+
+  // /learn [ghi chú] — bắt noob chưng cất điều đáng nhớ của phiên vào noob.md.
+  async function runLearn(arg) {
+    if (!config.apiKey) return console.log(c.tool("  " + t.notLoggedIn));
+    const note = arg ? `Người dùng nhấn mạnh cần nhớ: "${arg}"\n` : "";
+    const prompt = `${note}Hãy CHƯNG CẤT những điều đáng nhớ lâu dài từ phiên này và cập nhật noob.md ở thư mục gốc dự án.
+- Đọc noob.md hiện có trước (chưa có thì tạo bằng write_file). noob.md có 2 mục: "## Rules" (quy ước đã chốt — bắt buộc tuân theo) và "## Notes" (quan sát chưa chốt).
+- Ghi cái mới vào Notes: lệnh build/test/run, quy ước code, kiến trúc, sở thích người dùng, quyết định quan trọng, việc còn dang dở.
+- Note nào đã đúng/lặp lại ~2–3 lần → CHUYỂN lên Rules và xoá Note trùng (vòng tự cải thiện).
+- Mỗi ý 1 gạch đầu dòng, ngắn gọn, đúng sự thật. Giữ noob.md gọn (~200 dòng): cắt mục cũ/sai, đừng chỉ thêm.
+- Chỉ ghi qua tool (write_file/edit_file). Xong thì tóm tắt ngắn bạn đã thêm/sửa/chuyển gì.`;
+    console.log(c.tool("  🧠 " + t.learning));
+    await handle(prompt);
+    persist();
+  }
+
+  function showMemory() {
+    const mem = loadMemory();
+    if (!mem) return console.log(c.dim("  " + t.memoryEmpty(memoryPath())));
+    console.log(box(mem.length > 1800 ? mem.slice(0, 1800) + "\n…" : mem, "noob.md", "#10b981"));
+    console.log(c.dim("  " + memoryPath() + t.memoryStat(mem.split("\n").length)));
+  }
+
+  tui.start();
   banner();
   printStatus(state);
   if (!config.apiKey) console.log("\n" + c.tool("  " + t.notLoggedIn) + "\n");
@@ -337,8 +373,11 @@ Cuối cùng: tóm tắt + danh sách sửa theo thứ tự ưu tiên. Thẳng t
 
   if (opts.prompt) {
     console.log(c.user(t.promptYou) + c.dim("› ") + opts.prompt);
-    await handle(opts.prompt);
-    persist();
+    if (opts.ultra) await runUltra(opts.prompt);
+    else {
+      await handle(opts.prompt);
+      persist();
+    }
   }
 
   // Main loop — runs until /exit, double Ctrl+C, or EOF. Never exits after a task.
@@ -347,9 +386,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();
     }
@@ -370,7 +408,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 ─────────────────────────────────────────────────────────
@@ -380,27 +418,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);
     };
 
@@ -415,7 +448,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();
@@ -473,6 +506,7 @@ Cuối cùng: tóm tắt + danh sách sửa theo thứ tự ưu tiên. Thẳng t
       // Lượt cuối không stream ra gì (vd model suy luận trả 1 cục) → in fallback.
       if ((!printer || !printer.started) && answer?.trim())
         printAnswer(answer, state.model.name, providerColor(state.model.provider));
+      return answer; // vòng ULTRA cần text này để dò token hoàn thành
     } catch (err) {
       stopSpin();
       if (err.name === "AbortError") return;
@@ -499,14 +533,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 };
     }
@@ -568,6 +602,17 @@ Cuối cùng: tóm tắt + danh sách sửa theo thứ tự ưu tiên. Thẳng t
       case "kc":
         await runKarpathy(arg);
         break;
+      case "ultra":
+      case "u":
+        await runUltra(arg);
+        break;
+      case "learn":
+        await runLearn(arg);
+        break;
+      case "memory":
+      case "mem":
+        showMemory();
+        break;
       case "login":
         doLogin(arg);
         break;
@@ -586,7 +631,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"));
@@ -641,14 +686,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);
     }
   }
@@ -791,6 +836,9 @@ function printHelp() {
         "  " + t.cmdChat,
         "  " + t.cmdYolo,
         "  " + t.cmdKarpathy,
+        "  " + t.cmdUltra,
+        "  " + t.cmdLearn,
+        "  " + t.cmdMemory,
         "  " + t.cmdLogin,
         "  " + t.cmdLogout,
         "  " + t.cmdUsage,

package/src/tui.js

@@ -0,0 +1,347 @@
+// 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, completer } = {}) {
+  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 = [];
+
+  // ----- autocomplete: gợi ý lệnh hiện phía trên thanh nhập -----
+  let menu = []; // [{name, desc}] khớp với những gì đang gõ
+  let menuIdx = 0; // mục đang chọn (mũi tên ↑/↓), Tab để điền
+  function refreshMenu() {
+    menu = completer ? completer(fullText()) || [] : [];
+    menuIdx = 0;
+  }
+
+  // ----- 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 menuRows() {
+    if (!menu.length) return [];
+    const MAXV = 8; // cửa sổ cuộn quanh mục đang chọn
+    let start = 0;
+    if (menu.length > MAXV) start = Math.min(Math.max(0, menuIdx - 3), menu.length - MAXV);
+    return menu.slice(start, start + MAXV).map((m, k) => {
+      const sel = start + k === menuIdx;
+      const budget = Math.max(0, cols() - 4 - m.name.length); // 2 (mũi) + 2 (cách)
+      let desc = m.desc || "";
+      if (desc.length > budget) desc = desc.slice(0, Math.max(0, budget - 1)) + "…";
+      return (sel ? c.accent("❯ ") : "  ") + (sel ? c.user(m.name) : m.name) + (desc ? c.dim("  " + desc) : "");
+    });
+  }
+  function rows() {
+    const r = [];
+    const top = topRow();
+    if (top !== null) r.push(top);
+    for (const mr of menuRows()) r.push(mr);
+    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 = [];
+    menu = [];
+    menuIdx = 0;
+    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) {
+        // Shift+Tab = CSI Z (\x1b[Z). Bắt TRỰC TIẾP ở đây cho chắc — decoder
+        // keypress song song trước đây không nổ trên một số terminal Windows.
+        if (rest.startsWith(`${ESC}[Z`)) { onShiftTab?.(); i += 3; continue; }
+        // Mũi tên ↑/↓ điều hướng menu gợi ý lệnh (↑=A, ↓=B). ←/→ (C/D) nuốt.
+        const arrow = rest.match(/^\x1b(?:\[|O)([ABCD])/);
+        if (arrow) {
+          if (menu.length && (arrow[1] === "A" || arrow[1] === "B")) {
+            menuIdx = arrow[1] === "A" ? (menuIdx - 1 + menu.length) % menu.length : (menuIdx + 1) % menu.length;
+            draw();
+          }
+          i += arrow[0].length;
+          continue;
+        }
+        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") {
+        if (menu.length) parts = [{ type: "text", value: menu[menuIdx].name }]; // Enter chọn mục đang sáng
+        submit();
+        if (ch === "\r" && s[i + 1] === "\n") i++; // nuốt \n của \r\n
+        i++;
+        continue;
+      }
+      if (ch === "\x7f" || ch === "\b") { backspace(); refreshMenu(); draw(); i++; continue; }
+      if (ch === "\x03") { onInterrupt?.(); i++; continue; } // Ctrl+C
+      if (ch === "\x15") { parts = []; refreshMenu(); draw(); i++; continue; } // Ctrl+U xoá dòng
+      if (ch === "\x04") { if (!fullText()) onEOF?.(); i++; continue; } // Ctrl+D
+      if (ch === "\t") { // Tab điền lệnh đang chọn + dấu cách (để gõ tham số), đóng menu
+        if (menu.length) { parts = [{ type: "text", value: menu[menuIdx].name + " " }]; menu = []; draw(); }
+        i++;
+        continue;
+      }
+      if (ch < " ") { i++; continue; } // control khác — bỏ
+      // ký tự in được (kể cả UTF-8 vì stdin đã setEncoding utf8)
+      pushText(ch);
+      refreshMenu();
+      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 (\x1b[Z) + mũi tên xử lý trong feedKeys
+      // 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 {}
+    },
+  };
+}