micro-models-agent 0.32.0 → 0.33.1

package/dist/main.js

@@ -2162,7 +2162,7 @@ var init_defaults = __esm(() => {
   init_config();
   DEFAULTS = {
     version: "2.0.0",
-    model: "qwen3.5-9b",
+    model: "qwen/qwen3.5-9b",
     provider: {
       type: "openai-compat",
       baseUrl: "http://localhost:1234/v1",
@@ -2177,18 +2177,18 @@ var init_defaults = __esm(() => {
     },
     experts: {
       code: {
-        model: "qwen3.5-9b",
+        model: "qwen/qwen3.5-9b",
         tool_tags: ["file", "code", "shell"],
         max_attempts: 3
       },
-      research: { model: "qwen3.5-9b", tool_tags: ["research"], max_attempts: 3 },
+      research: { model: "qwen/qwen3.5-9b", tool_tags: ["research"], max_attempts: 3 },
       browser: {
-        model: "qwen3.5-9b",
+        model: "qwen/qwen3.5-9b",
         tool_tags: ["browser", "vision"],
         max_attempts: 3
       },
       vision: {
-        model: "qwen3.5-9b",
+        model: "qwen/qwen3.5-9b",
         tool_tags: ["browser", "vision", "file"],
         max_attempts: 2
       }
@@ -2458,7 +2458,7 @@ Command: {command}`,
     "plan.step_status": "Step {step}: {status}",
     "plan.no_active": "No active plan",
     "plan.step_not_found": "Step not found",
-    "plan.step_already_done": "Step {step} is already marked done. Stop re-marking it — either continue with the next step or investigate why progress appears stuck.",
+    "plan.step_already_done": "Step {step} is already done — nothing to do. Plan progress:",
     "plan.order_blocked": 'Cannot mark step {step} done: step {first} ("{desc}") is not finished yet. Complete earlier steps first, or mark step {first} status=skipped if it is not needed.',
     "plan.show_header": "Plan status:",
     "plan.show_empty": "(plan has no steps)",
@@ -3035,7 +3035,7 @@ var init_ru = __esm(() => {
     "plan.step_status": "Шаг {step}: {status}",
     "plan.no_active": "Нет активного плана",
     "plan.step_not_found": "Шаг не найден",
-    "plan.step_already_done": "Шаг {step} уже отмечен выполненным. Прекратите повторную отметку — переходите к следующему шагу или выясните, почему прогресс заблокирован.",
+    "plan.step_already_done": "Шаг {step} уже выполнен — ничего делать не нужно. Прогресс плана:",
     "plan.order_blocked": "Нельзя отметить шаг {step} выполненным: шаг {first} («{desc}») ещё не завершён. Сначала завершите предыдущие шаги или отметьте шаг {first} status=skipped, если он не нужен.",
     "plan.show_header": "Статус плана:",
     "plan.show_empty": "(в плане нет шагов)",
@@ -10435,6 +10435,7 @@ ${t("tool.truncated", { tokens: Math.ceil(removedChars / 2) })}`;
     this.abortController = new AbortController;
     let iteration = 0;
     let lastText = "";
+    let lastModelText = "";
     let lastForcedCompactionIteration = -FORCED_COMPACTION_COOLDOWN;
     let hallucinationRetries = 0;
     let lastToolSignature = "";
@@ -10451,6 +10452,7 @@ ${t("tool.truncated", { tokens: Math.ceil(removedChars / 2) })}`;
     let emptyResponseExhausted = false;
     let auditFailed = false;
     let lastAuditSummary = "";
+    let suppressRepetitionRetry = false;
     let repeatedToolCount = 0;
     const MAX_REPEATED_TOOL_CALLS = 2;
     const allToolsForBudget = toolExecutor.getToolDefinitions(this.deps.toolTags);
@@ -10738,9 +10740,12 @@ ${taskReminder}</system-summary>`
 `));
           }
         }
+        suppressRepetitionRetry = false;
         continue;
       }
-      hallucinationDetector.getConfidenceCheck().setPreviousResponse(lastText);
+      hallucinationDetector.getConfidenceCheck().setPreviousResponse(lastModelText);
+      if (textContent)
+        lastModelText = textContent;
       const hallucinationResult = await hallucinationDetector.validate(textContent);
       if (hallucinationResult.status === "block") {
         logger.warn(`Response blocked: ${hallucinationResult.reason}`);
@@ -10772,30 +10777,45 @@ ${warnLine}
           lastText = textContent;
           break;
         }
-        if (hallucinationRetries >= MAX_HALLUCINATION_RETRIES) {
-          logger.warn(`Hallucination retries exhausted (${MAX_HALLUCINATION_RETRIES}), returning error`);
-          return {
-            success: false,
-            text: lastText,
-            error: t("error.response_blocked", {
-              reason: t("hall.max_retries_exhausted")
-            }),
-            iterationCount: iteration
-          };
-        }
-        hallucinationRetries++;
-        logger.warn(`Hallucination retry (${hallucinationRetries}/${MAX_HALLUCINATION_RETRIES}): ${hallucinationResult.reason}`);
-        if (textContent) {
+        if (suppressRepetitionRetry && hallucinationResult.kind === "repetition") {
+          suppressRepetitionRetry = false;
+          logger.warn(`Audit-triggered re-answer repetition — not counted as hallucination retry`);
+          const warnLine = `${t("hall.uncertainty_prefix").trim()} ${hallucinationResult.reason ?? ""}`;
+          if (onMeta) {
+            onMeta(`
+${pc2.yellow(warnLine)}
+`);
+          } else if (onChunk) {
+            onChunk(`
+${warnLine}
+`);
+          }
+        } else {
+          if (hallucinationRetries >= MAX_HALLUCINATION_RETRIES) {
+            logger.warn(`Hallucination retries exhausted (${MAX_HALLUCINATION_RETRIES}), returning error`);
+            return {
+              success: false,
+              text: lastText,
+              error: t("error.response_blocked", {
+                reason: t("hall.max_retries_exhausted")
+              }),
+              iterationCount: iteration
+            };
+          }
+          hallucinationRetries++;
+          logger.warn(`Hallucination retry (${hallucinationRetries}/${MAX_HALLUCINATION_RETRIES}): ${hallucinationResult.reason}`);
+          if (textContent) {
+            contextManager.addMessage({
+              role: "assistant",
+              content: textContent
+            });
+          }
           contextManager.addMessage({
-            role: "assistant",
-            content: textContent
+            role: "user",
+            content: `<system-summary>[Retry context: ${hallucinationResult.reason}. Original task: "${input}". You must either call a needed tool or provide a substantive response. Empty replies are not allowed.]</system-summary>`
           });
+          continue;
         }
-        contextManager.addMessage({
-          role: "user",
-          content: `<system-summary>[Retry context: ${hallucinationResult.reason}. Original task: "${input}". You must either call a needed tool or provide a substantive response. Empty replies are not allowed.]</system-summary>`
-        });
-        continue;
       }
       if (textContent) {
         contextManager.addMessage({ role: "assistant", content: textContent });
@@ -10847,6 +10867,7 @@ ${warnLine}
               auditFailed = true;
               break;
             }
+            suppressRepetitionRetry = true;
             continue;
           }
         }
@@ -11296,13 +11317,18 @@ class ConfidenceCheck {
   }
   validate(response) {
     if (!response || response.length < MIN_CHARS) {
-      return { status: "retry", reason: t("hall.short_response") };
+      return {
+        status: "retry",
+        kind: "short",
+        reason: t("hall.short_response")
+      };
     }
     const wordCount = response.split(/\s+/).filter(Boolean).length;
     const hasStructure = /```|^\s*[-*]\s|^\s*\d+\.\s|<[^>]+>/m.test(response);
     if (wordCount < MIN_WORDS && !hasStructure) {
       return {
         status: "warn",
+        kind: "short",
         reason: t("hall.short_response")
       };
     }
@@ -11311,6 +11337,7 @@ class ConfidenceCheck {
       if (overlap > 0.5) {
         return {
           status: "retry",
+          kind: "repetition",
           reason: t("hall.repetitive", { pct: Math.round(overlap * 100) })
         };
       }
@@ -11322,6 +11349,7 @@ class ConfidenceCheck {
       if (diversity < 0.25) {
         return {
           status: "warn",
+          kind: "diversity",
           reason: t("hall.repetitive", {
             pct: Math.round((1 - diversity) * 100)
           })
@@ -11350,7 +11378,25 @@ function isJsMemberAccess(candidate) {
   const m = lower.match(/^([\w-]+)\./);
   return m !== null && JS_GLOBALS.has(m[1]);
 }
-var JS_GLOBALS;
+function isFilePathLike(s) {
+  const lower = s.toLowerCase();
+  if (TECH_NAMES.has(lower))
+    return false;
+  if (!s.includes("/") && !s.includes("\\") && !/^\w+\.[a-z]{2,4}$/i.test(s))
+    return false;
+  if (isJsMemberAccess(s))
+    return false;
+  const ext = s.split(".").pop()?.toLowerCase() || "";
+  return !NON_FILE_EXTENSIONS.has(ext);
+}
+function extractFileLikeTokens(text) {
+  const matches = text.match(FILE_TOKEN_RE) || [];
+  return [...new Set(matches.filter(isFilePathLike))];
+}
+function stripUrls(text) {
+  return text.replace(/\bhttps?:\/\/[^\s"'<>]+/gi, " ");
+}
+var JS_GLOBALS, NON_FILE_EXTENSIONS, TECH_NAMES, FILE_TOKEN_RE;
 var init_js_identifiers = __esm(() => {
   JS_GLOBALS = new Set([
     "process",
@@ -11408,22 +11454,46 @@ var init_js_identifiers = __esm(() => {
     "deno",
     "node"
   ]);
+  NON_FILE_EXTENSIONS = new Set([
+    "com",
+    "org",
+    "net",
+    "gov",
+    "edu",
+    "io",
+    "dev",
+    "app",
+    "co",
+    "ai",
+    "ru",
+    "de",
+    "fr",
+    "uk",
+    "us",
+    "es",
+    "it",
+    "jp",
+    "cn",
+    "br"
+  ]);
+  TECH_NAMES = new Set([
+    "node.js",
+    "react.js",
+    "vue.js",
+    "next.js",
+    "angular.js",
+    "express.js",
+    "deno.js",
+    "qwik.js",
+    "svelte.js",
+    "jquery.js"
+  ]);
+  FILE_TOKEN_RE = /\b(?:[a-zA-Z]:[\\/])?[\w./\\-]+\.[a-z]{2,6}\b/gi;
 });
 
 // src/modules/hallucination/factual.ts
 import { existsSync as existsSync22, readdirSync as readdirSync5 } from "fs";
 import { resolve as resolve12, isAbsolute as isAbsolute2, join as join13 } from "path";
-function looksLikeFilePath(s) {
-  const lower = s.toLowerCase();
-  if (TECH_NAMES.has(lower))
-    return false;
-  if (!s.includes("/") && !s.includes("\\") && !s.match(/^\w+\.[a-z]{2,4}$/i))
-    return false;
-  if (isJsMemberAccess(s))
-    return false;
-  const ext = s.split(".").pop()?.toLowerCase() || "";
-  return !NON_FILE_EXTENSIONS.has(ext);
-}
 
 class FactualCheck {
   baseDir;
@@ -11522,12 +11592,10 @@ class FactualCheck {
     return count;
   }
   extractFilePaths(text) {
-    const pattern = /\b(?:[a-zA-Z]:[\\/])?[\w./\\-]+\.[a-z]{2,6}\b/gi;
-    const matches = text.match(pattern) || [];
-    return [...new Set(matches)].filter(looksLikeFilePath);
+    return extractFileLikeTokens(stripUrls(text));
   }
 }
-var IGNORED_DIRS, NON_FILE_EXTENSIONS, TECH_NAMES;
+var IGNORED_DIRS;
 var init_factual = __esm(() => {
   init_i18n();
   init_js_identifiers();
@@ -11540,40 +11608,6 @@ var init_factual = __esm(() => {
     ".mma",
     "_testing"
   ]);
-  NON_FILE_EXTENSIONS = new Set([
-    "com",
-    "org",
-    "net",
-    "gov",
-    "edu",
-    "io",
-    "dev",
-    "app",
-    "co",
-    "ai",
-    "ru",
-    "de",
-    "fr",
-    "uk",
-    "us",
-    "es",
-    "it",
-    "jp",
-    "cn",
-    "br"
-  ]);
-  TECH_NAMES = new Set([
-    "node.js",
-    "react.js",
-    "vue.js",
-    "next.js",
-    "angular.js",
-    "express.js",
-    "deno.js",
-    "qwik.js",
-    "svelte.js",
-    "jquery.js"
-  ]);
 });
 
 // src/modules/hallucination/llm-judge.ts
@@ -12433,7 +12467,7 @@ var init_web_fetch = __esm(() => {
   init_security();
   webFetchTool = {
     name: "web_fetch",
-    description: "Fetch a URL and convert its content to markdown. Use for reading documentation, APIs, web pages.",
+    description: 'Fetch a URL and convert its content to markdown. Use for reading documentation, APIs, web pages. This is a plain HTTP request without a browser engine — it does NOT run JavaScript, so JS-rendered single-page apps (weather sites, dashboards, modern SPAs) return empty or near-empty content; use the "browser" tool for those.',
     tags: ["research"],
     parameters: {
       type: "object",
@@ -12519,7 +12553,7 @@ var init_web_browse = __esm(() => {
   init_session_isolation();
   webBrowseTool = {
     name: "web_browse",
-    description: `Fetch and read a web page. Returns the page content as plain text (max ${MAX_PREVIEW_LINES} lines / ${MAX_CHARS2} chars).`,
+    description: `Fetch and read a web page. Returns the page content as plain text (max ${MAX_PREVIEW_LINES} lines / ${MAX_CHARS2} chars). This is a plain HTTP request — it does NOT execute JavaScript, so JS-rendered single-page apps (weather sites, dashboards, modern SPAs) return empty or near-empty content. For such pages use the "browser" tool instead.`,
     tags: ["research"],
     parameters: {
       type: "object",
@@ -14619,6 +14653,7 @@ function createBrowserTool() {
     tags: ["browser", "vision"],
     description: [
       "Control a headless browser. Navigate pages, click elements, type text, scroll, take screenshots.",
+      "Runs a real browser with JavaScript enabled — use it for JS-rendered sites (weather, dashboards, SPAs) where web_fetch/web_browse return empty content.",
       "Each snapshot returns: a numbered list of interactive elements, the visible page text (Content section), browser console messages, and network errors.",
       "Use the Content section to understand what the page says; use element numbers as targets for click/type.",
       "Actions: open (url), click (target), type (target, text), scroll (direction), back, forward, screenshot, snapshot, close, wait (ms)."
@@ -15480,10 +15515,7 @@ class Auditor {
   }
   async audit(plan) {
     const allStepText = plan.steps.map((s) => s.description.replace(/\([^)]*\)/g, " ")).join(" ");
-    const fileMatches = allStepText.match(/\b[\w./-]+\.[a-z]+/gi) || [];
-    const uniqueFiles = [
-      ...new Set(fileMatches.filter((f) => !isJsMemberAccess(f)))
-    ];
+    const uniqueFiles = extractFileLikeTokens(stripUrls(allStepText));
     const missingFiles = [];
     const existingFiles = [];
     for (const filePath of uniqueFiles) {
@@ -16031,11 +16063,15 @@ ${display}`,
             }
             const status = String(args.status || "done");
             if (status === "done" && target.status === "done") {
+              const progress2 = this.tracker.getProgressString();
+              const display2 = this.tracker.toPromptBlock();
               return {
-                success: false,
-                output: t("plan.step_already_done", {
+                success: true,
+                output: `${t("plan.step_already_done", {
                   step: String(stepId)
-                })
+                })}
+${progress2}`,
+                display: display2
               };
             }
             if (status === "done") {
@@ -19295,7 +19331,7 @@ async function runSetup(externalRl) {
     const idx = Math.max(0, Math.min(models.length - 1, (parseInt(choice) || 1) - 1));
     model = models[idx];
   } else {
-    model = await ask(rl, t("setup.model_name"), "qwen3.5-9b");
+    model = await ask(rl, t("setup.model_name"), "qwen/qwen3.5-9b");
   }
   const connected = await withSpinner(t("setup.testing_spinner", { model }), () => testChat(apiBase, apiKey, model));
   if (connected) {
@@ -28583,7 +28619,725 @@ init_bootstrap();
 
 // src/cli/repl.ts
 init_colors();
+import * as readline3 from "readline";
+
+// src/ui/line-editor.ts
+init_string_width();
 import * as readline2 from "readline";
+
+// src/ui/line-math.ts
+init_string_width();
+var ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+function stripAnsi2(s) {
+  return s.replace(ANSI_RE, "");
+}
+function charLen(s) {
+  return Array.from(s).length;
+}
+function wrapLine(line, width) {
+  const w = width > 0 ? width : 80;
+  const chars = Array.from(line);
+  const rows = [];
+  let start = 0;
+  let cells = 0;
+  for (let i = 0;i < chars.length; i++) {
+    const ch = chars[i];
+    if (ch === `
+`) {
+      rows.push({ text: chars.slice(start, i).join(""), charStart: start });
+      start = i + 1;
+      cells = 0;
+      continue;
+    }
+    const cw = stringWidth(ch);
+    if (cells + cw > w && cells > 0) {
+      rows.push({ text: chars.slice(start, i).join(""), charStart: start });
+      start = i;
+      cells = cw;
+    } else {
+      cells += cw;
+    }
+  }
+  rows.push({ text: chars.slice(start).join(""), charStart: start });
+  return rows;
+}
+function buildLayout(lines, width) {
+  const rows = [];
+  for (let b = 0;b < lines.length; b++) {
+    for (const r of wrapLine(lines[b], width)) {
+      rows.push({ bufRow: b, charStart: r.charStart, text: r.text });
+    }
+  }
+  return rows;
+}
+function layoutIndexFor(rows, bufRow, col) {
+  let idx = 0;
+  for (let i = 0;i < rows.length; i++) {
+    if (rows[i].bufRow === bufRow && rows[i].charStart <= col)
+      idx = i;
+  }
+  return idx;
+}
+function visualColAt(rows, idx, col) {
+  const r = rows[idx];
+  const upTo = col - r.charStart;
+  return stringWidth(Array.from(r.text).slice(0, upTo).join(""));
+}
+function charOffsetFor(rows, idx, visualCol) {
+  const r = rows[idx];
+  const chars = Array.from(r.text);
+  let cells = 0;
+  for (let i = 0;i < chars.length; i++) {
+    const cw = stringWidth(chars[i]);
+    if (cells + cw > visualCol)
+      return r.charStart + i;
+    cells += cw;
+  }
+  return r.charStart + chars.length;
+}
+
+// src/ui/line-editor.ts
+class LineEditor {
+  input;
+  output;
+  onKeyInput;
+  promptStr;
+  completer;
+  history;
+  historySize;
+  lines = [""];
+  row = 0;
+  col = 0;
+  historyIndex = -1;
+  stash = null;
+  isDone = false;
+  isPaste = false;
+  lastWasCR = false;
+  questionCb = null;
+  rawMode = false;
+  listeners = {};
+  prevCursorRow = 0;
+  constructor(opts) {
+    this.input = opts.input;
+    this.output = opts.output;
+    this.promptStr = opts.prompt ?? "";
+    this.completer = opts.completer;
+    this.history = opts.history ?? [];
+    this.historySize = opts.historySize ?? 50;
+    if (this.history.length > this.historySize) {
+      this.history = this.history.slice(-this.historySize);
+    }
+    if (this.input.isTTY) {
+      this.rawMode = typeof this.input.setRawMode === "function";
+      if (this.rawMode)
+        this.input.setRawMode(true);
+      this.enableTerminalProtocols();
+      readline2.emitKeypressEvents(this.input);
+      this.input.on("keypress", (str, key) => this.onKey(str, key));
+    } else {
+      this.input.on("data", (buf) => this.onData(buf));
+      this.input.on("end", () => {
+        const last = this.lines.join(`
+`);
+        this.lines = [""];
+        this.row = 0;
+        this.col = 0;
+        if (last)
+          this.emitLine(last);
+        this.emitClose();
+      });
+    }
+  }
+  on(event, listener) {
+    if (event === "line") {
+      this.listeners.line = listener;
+    } else {
+      this.listeners.close = listener;
+    }
+    return this;
+  }
+  setPrompt(prompt) {
+    this.promptStr = prompt;
+    if (this.input.isTTY)
+      this.render();
+  }
+  prompt(_preserveCursor) {
+    if (this.input.isTTY)
+      this.render();
+  }
+  write(s) {
+    this.insertText(s);
+  }
+  reset() {
+    this.lines = [""];
+    this.row = 0;
+    this.col = 0;
+    this.historyIndex = -1;
+    this.stash = null;
+    this.prevCursorRow = 0;
+    if (this.input.isTTY)
+      this.render();
+  }
+  question(query, cb) {
+    this.questionCb = cb;
+    this.promptStr = query;
+    this.lines = [""];
+    this.row = 0;
+    this.col = 0;
+    this.prevCursorRow = 0;
+    if (this.input.isTTY)
+      this.render();
+  }
+  close() {
+    if (this.isDone)
+      return;
+    this.isDone = true;
+    this.disableTerminalProtocols();
+    if (this.rawMode && this.input.setRawMode) {
+      this.input.setRawMode(false);
+    }
+    this.emitClose();
+  }
+  onData(buf) {
+    if (this.isDone)
+      return;
+    let text = buf.toString("utf-8");
+    text = text.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+    const parts = text.split(`
+`);
+    for (let i = 0;i < parts.length; i++) {
+      if (i < parts.length - 1) {
+        this.emitLine(parts[i]);
+        this.lines = [""];
+        this.row = 0;
+        this.col = 0;
+      } else if (parts[i]) {
+        this.emitLine(parts[i]);
+        this.lines = [""];
+        this.row = 0;
+        this.col = 0;
+      }
+    }
+  }
+  onKey(str, key) {
+    if (this.isDone)
+      return;
+    if (this.onKeyInput && this.onKeyInput(str, key))
+      return;
+    const k = key;
+    const name = k?.name ?? "undefined";
+    const seq2 = k?.sequence ?? str ?? "";
+    if (name === "undefined" && /^\x1b\[\d+(?:;\d+)?u$/.test(seq2)) {
+      const m = seq2.match(/^\x1b\[(\d+)(?:;(\d+))?u$/);
+      if (m && Number(m[1]) === 13 && Number(m[2] ?? 0) !== 0) {
+        this.insertNewline();
+      }
+      return;
+    }
+    if (name === "paste-start" || seq2 === "\x1B[200~") {
+      this.isPaste = true;
+      return;
+    }
+    if (name === "paste-end" || seq2 === "\x1B[201~") {
+      this.isPaste = false;
+      this.render();
+      return;
+    }
+    if (this.isPaste) {
+      if (name === "return" || seq2 === "\r" || seq2 === `
+`) {
+        this.insertText(`
+`);
+      } else if (str) {
+        this.insertText(str);
+      }
+      this.render();
+      return;
+    }
+    if (name === "return" && (seq2 === "\x1B\r" || k.meta)) {
+      this.insertNewline();
+      return;
+    }
+    if (name === "undefined" && seq2 === "\x1B\r") {
+      this.insertNewline();
+      return;
+    }
+    if (k?.ctrl && name === "j") {
+      this.insertNewline();
+      return;
+    }
+    if (name === "escape")
+      return;
+    switch (name) {
+      case "return":
+        this.lastWasCR = true;
+        this.submit();
+        return;
+      case "enter":
+        if (this.lastWasCR) {
+          this.lastWasCR = false;
+          return;
+        }
+        this.insertNewline();
+        return;
+      case "backspace":
+        this.lastWasCR = false;
+        this.backspace();
+        return;
+      case "delete":
+        this.lastWasCR = false;
+        this.deleteForward();
+        return;
+      case "left":
+        this.lastWasCR = false;
+        this.moveLeft();
+        return;
+      case "right":
+        this.lastWasCR = false;
+        this.moveRight();
+        return;
+      case "up":
+        this.lastWasCR = false;
+        this.moveUp();
+        return;
+      case "down":
+        this.lastWasCR = false;
+        this.moveDown();
+        return;
+      case "home":
+        this.lastWasCR = false;
+        this.moveHome();
+        return;
+      case "end":
+        this.lastWasCR = false;
+        this.moveEnd();
+        return;
+      case "pageup":
+        this.lastWasCR = false;
+        this.moveToStart();
+        return;
+      case "pagedown":
+        this.lastWasCR = false;
+        this.moveToEnd();
+        return;
+      case "tab":
+        this.lastWasCR = false;
+        this.tabComplete();
+        return;
+    }
+    if (k?.ctrl) {
+      this.lastWasCR = false;
+      switch (name) {
+        case "c":
+          this.ctrlC();
+          return;
+        case "d":
+          this.ctrlD();
+          return;
+        case "a":
+          this.moveHome();
+          return;
+        case "e":
+          this.moveEnd();
+          return;
+        case "u":
+          this.killToStart();
+          return;
+        case "k":
+          this.killToEnd();
+          return;
+        case "w":
+          this.killWordBefore();
+          return;
+        case "l":
+          this.clearScreen();
+          return;
+        default:
+          return;
+      }
+    }
+    if (k?.meta) {
+      this.lastWasCR = false;
+      switch (name) {
+        case "b":
+          this.moveWordLeft();
+          return;
+        case "f":
+          this.moveWordRight();
+          return;
+        case "d":
+          this.killWordAfter();
+          return;
+        default:
+          return;
+      }
+    }
+    if (str && !/^[\u0000-\u001f\u007f]/.test(str)) {
+      this.lastWasCR = false;
+      this.insertText(str);
+    }
+  }
+  submit() {
+    if (this.questionCb) {
+      const cb = this.questionCb;
+      this.questionCb = null;
+      const answer = this.lines.join(`
+`).trim();
+      this.commitFrame();
+      this.output.write(`\r
+`);
+      this.lines = [""];
+      this.row = 0;
+      this.col = 0;
+      this.prevCursorRow = 0;
+      cb(answer);
+      return;
+    }
+    const text = this.lines.join(`
+`);
+    if (text.trim()) {
+      this.history.push(text);
+      if (this.history.length > this.historySize) {
+        this.history = this.history.slice(-this.historySize);
+      }
+    }
+    this.historyIndex = -1;
+    this.stash = null;
+    this.commitFrame();
+    this.output.write(`\r
+`);
+    this.lines = [""];
+    this.row = 0;
+    this.col = 0;
+    this.prevCursorRow = 0;
+    this.emitLine(text);
+  }
+  commitFrame() {
+    const layout = this.layout();
+    const idx = layoutIndexFor(layout, this.row, this.col);
+    const rowsDown = layout.length - 1 - idx;
+    const lastLen = charLen(stripAnsi2(layout[layout.length - 1].text));
+    const out = [];
+    if (rowsDown > 0)
+      out.push(`\x1B[${rowsDown}B`);
+    out.push("\r");
+    if (lastLen > 0)
+      out.push(`\x1B[${lastLen}C`);
+    this.output.write(out.join(""));
+  }
+  ctrlC() {
+    this.lines = [""];
+    this.row = 0;
+    this.col = 0;
+    this.prevCursorRow = 0;
+    this.render();
+    process.emit("SIGINT");
+  }
+  ctrlD() {
+    if (this.lines.length === 1 && this.lines[0] === "") {
+      this.emitClose();
+    } else {
+      this.deleteForward();
+    }
+  }
+  currentChars() {
+    return Array.from(this.lines[this.row]);
+  }
+  setCurrentChars(chars) {
+    this.lines[this.row] = chars.join("");
+  }
+  insertText(text) {
+    const sanitized = text.replace(/\r\n/g, `
+`).replace(/\r/g, "");
+    const chars = this.currentChars();
+    const t2 = Array.from(sanitized);
+    chars.splice(this.col, 0, ...t2);
+    this.setCurrentChars(chars);
+    this.col += t2.length;
+    this.render();
+  }
+  insertNewline() {
+    const chars = this.currentChars();
+    const rest = chars.slice(this.col).join("");
+    this.setCurrentChars(chars.slice(0, this.col));
+    this.lines.splice(this.row + 1, 0, rest);
+    this.row++;
+    this.col = 0;
+    this.render();
+  }
+  backspace() {
+    const chars = this.currentChars();
+    if (this.col > 0) {
+      chars.splice(this.col - 1, 1);
+      this.setCurrentChars(chars);
+      this.col--;
+    } else if (this.row > 0) {
+      const prevLen = charLen(this.lines[this.row - 1]);
+      this.lines[this.row - 1] = this.lines[this.row - 1] + this.lines[this.row];
+      this.lines.splice(this.row, 1);
+      this.row--;
+      this.col = prevLen;
+    }
+    this.render();
+  }
+  deleteForward() {
+    const chars = this.currentChars();
+    if (this.col < chars.length) {
+      chars.splice(this.col, 1);
+      this.setCurrentChars(chars);
+    } else if (this.row < this.lines.length - 1) {
+      this.lines[this.row] = this.lines[this.row] + this.lines[this.row + 1];
+      this.lines.splice(this.row + 1, 1);
+    }
+    this.render();
+  }
+  killToStart() {
+    const chars = this.currentChars();
+    this.setCurrentChars(chars.slice(this.col));
+    this.col = 0;
+    this.render();
+  }
+  killToEnd() {
+    const chars = this.currentChars();
+    this.setCurrentChars(chars.slice(0, this.col));
+    this.render();
+  }
+  killWordBefore() {
+    const chars = this.currentChars();
+    let i = this.col;
+    while (i > 0 && /\s/.test(chars[i - 1]))
+      i--;
+    while (i > 0 && !/\s/.test(chars[i - 1]))
+      i--;
+    chars.splice(i, this.col - i);
+    this.setCurrentChars(chars);
+    this.col = i;
+    this.render();
+  }
+  killWordAfter() {
+    const chars = this.currentChars();
+    const n = chars.length;
+    let i = this.col;
+    while (i < n && /\s/.test(chars[i]))
+      i++;
+    while (i < n && !/\s/.test(chars[i]))
+      i++;
+    chars.splice(this.col, i - this.col);
+    this.setCurrentChars(chars);
+    this.render();
+  }
+  moveLeft() {
+    if (this.col > 0) {
+      this.col--;
+    } else if (this.row > 0) {
+      this.row--;
+      this.col = charLen(this.lines[this.row]);
+    }
+    this.render();
+  }
+  moveRight() {
+    if (this.col < charLen(this.lines[this.row])) {
+      this.col++;
+    } else if (this.row < this.lines.length - 1) {
+      this.row++;
+      this.col = 0;
+    }
+    this.render();
+  }
+  moveUp() {
+    const layout = this.layout();
+    const idx = layoutIndexFor(layout, this.row, this.col);
+    const vcol = visualColAt(layout, idx, this.col);
+    if (idx > 0) {
+      const target = layout[idx - 1];
+      this.row = target.bufRow;
+      this.col = charOffsetFor(layout, idx - 1, vcol);
+      this.render();
+    } else {
+      this.historyPrev();
+    }
+  }
+  moveDown() {
+    const layout = this.layout();
+    const idx = layoutIndexFor(layout, this.row, this.col);
+    const vcol = visualColAt(layout, idx, this.col);
+    if (idx < layout.length - 1) {
+      const target = layout[idx + 1];
+      this.row = target.bufRow;
+      this.col = charOffsetFor(layout, idx + 1, vcol);
+      this.render();
+    } else {
+      this.historyNext();
+    }
+  }
+  moveHome() {
+    this.col = 0;
+    this.render();
+  }
+  moveEnd() {
+    this.col = charLen(this.lines[this.row]);
+    this.render();
+  }
+  moveToStart() {
+    this.row = 0;
+    this.col = 0;
+    this.render();
+  }
+  moveToEnd() {
+    this.row = this.lines.length - 1;
+    this.col = charLen(this.lines[this.row]);
+    this.render();
+  }
+  moveWordLeft() {
+    const chars = this.currentChars();
+    let i = this.col;
+    while (i > 0 && /\s/.test(chars[i - 1]))
+      i--;
+    while (i > 0 && !/\s/.test(chars[i - 1]))
+      i--;
+    this.col = i;
+    this.render();
+  }
+  moveWordRight() {
+    const chars = this.currentChars();
+    const n = chars.length;
+    let i = this.col;
+    while (i < n && !/\s/.test(chars[i]))
+      i++;
+    while (i < n && /\s/.test(chars[i]))
+      i++;
+    this.col = i;
+    this.render();
+  }
+  historyPrev() {
+    if (this.history.length === 0)
+      return;
+    if (this.historyIndex === -1) {
+      this.stash = {
+        lines: this.lines.slice(),
+        row: this.row,
+        col: this.col
+      };
+      this.historyIndex = 0;
+    } else if (this.historyIndex < this.history.length - 1) {
+      this.historyIndex++;
+    } else {
+      return;
+    }
+    this.applyHistoryEntry();
+  }
+  historyNext() {
+    if (this.historyIndex === -1)
+      return;
+    if (this.historyIndex > 0) {
+      this.historyIndex--;
+      this.applyHistoryEntry();
+    } else if (this.stash) {
+      this.lines = this.stash.lines.slice();
+      this.row = this.stash.row;
+      this.col = this.stash.col;
+      this.historyIndex = -1;
+      this.stash = null;
+      this.render();
+    }
+  }
+  applyHistoryEntry() {
+    const entry = this.history[this.history.length - 1 - this.historyIndex];
+    this.lines = entry.split(`
+`);
+    if (this.lines.length === 0)
+      this.lines = [""];
+    this.row = this.lines.length - 1;
+    this.col = charLen(this.lines[this.row]);
+    this.render();
+  }
+  tabComplete() {
+    if (!this.completer)
+      return;
+    const line = this.lines[this.row];
+    const [matches, partial] = this.completer(line);
+    if (matches.length === 0) {
+      this.output.write("\x07");
+      return;
+    }
+    if (matches.length === 1) {
+      const from = line.lastIndexOf(partial);
+      const head = line.slice(0, from);
+      const tail = line.slice(from + partial.length);
+      this.lines[this.row] = head + matches[0] + tail;
+      this.col = charLen(head) + charLen(matches[0]);
+      this.render();
+      return;
+    }
+    const lines = matches.map((m) => "  " + m);
+    this.output.write(`\r
+` + lines.join(`\r
+`) + `\r
+`);
+    this.output.write(`\x1B[${lines.length + 1}A`);
+    this.render();
+  }
+  clearScreen() {
+    this.output.write("\x1B[2J\x1B[H");
+    this.prevCursorRow = 0;
+    this.render();
+  }
+  columns() {
+    return this.output.columns || 80;
+  }
+  layout() {
+    return buildLayout(this.lines, this.columns());
+  }
+  render() {
+    if (!this.input.isTTY || this.isDone)
+      return;
+    const layout = this.layout();
+    const promptWidth = stringWidth(stripAnsi2(this.promptStr));
+    const idx = layoutIndexFor(layout, this.row, this.col);
+    const vcol = visualColAt(layout, idx, this.col);
+    const rowsAfter = layout.length - idx - 1;
+    const ccol = (idx === 0 ? promptWidth : 0) + vcol;
+    const out = [];
+    if (this.prevCursorRow > 0)
+      out.push(`\x1B[${this.prevCursorRow}A`);
+    out.push("\r");
+    for (let i = 0;i < layout.length; i++) {
+      out.push("\x1B[2K");
+      if (i === 0)
+        out.push(this.promptStr);
+      out.push(layout[i].text);
+      if (i < layout.length - 1)
+        out.push(`\r
+`);
+    }
+    out.push("\x1B[J");
+    if (rowsAfter > 0)
+      out.push(`\x1B[${rowsAfter}A`);
+    out.push("\r");
+    if (ccol > 0)
+      out.push(`\x1B[${ccol}C`);
+    this.prevCursorRow = idx;
+    this.output.write(out.join(""));
+  }
+  enableTerminalProtocols() {
+    this.output.write("\x1B[?2004h");
+    this.output.write("\x1B[>1u");
+  }
+  disableTerminalProtocols() {
+    this.output.write("\x1B[?2004l");
+    this.output.write("\x1B[<u");
+  }
+  emitLine(line) {
+    this.listeners.line?.(line);
+  }
+  emitClose() {
+    this.listeners.close?.();
+  }
+}
+
+// src/cli/repl.ts
 import { existsSync as existsSync45, readFileSync as readFileSync31, writeFileSync as writeFileSync16 } from "fs";
 import { join as join40, dirname as dirname13 } from "path";
 import { homedir as homedir17 } from "os";
@@ -28885,14 +29639,6 @@ class FormattingStream {
     return result;
   }
 }
-function formatMarkdown(text) {
-  const lines = [];
-  const stream = new FormattingStream((l) => lines.push(l));
-  stream.write(text);
-  stream.flush();
-  return lines.join(`
-`);
-}
 
 // src/ui/renderer.ts
 init_spinner();
@@ -29145,6 +29891,7 @@ class Repl {
   baseDir;
   noAgentsMd;
   pendingClipboardImage = null;
+  exitOnClose = false;
   rl;
   agent;
   config;
@@ -29152,9 +29899,10 @@ class Repl {
   skillsModule;
   pluginManager;
   logger;
-  constructor(agent, config, sessionManager, skillsModule, pluginManager, configDir, baseDir, noAgentsMd, logger) {
+  constructor(agent, config, sessionManager, skillsModule, pluginManager, configDir, baseDir, noAgentsMd, logger, exitOnClose) {
     this.agent = agent;
     this.config = config;
+    this.exitOnClose = exitOnClose === true;
     this.sessionManager = sessionManager;
     this.skillsModule = skillsModule;
     this.pluginManager = pluginManager;
@@ -29164,7 +29912,19 @@ class Repl {
     this.noAgentsMd = noAgentsMd === true;
     this.historyPath = join40(homedir17(), ".mma", "repl-history");
     this.loadHistory();
-    this.rl = readline2.createInterface({
+    this.rl = process.stdin.isTTY ? new LineEditor({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: pc2.cyan("> "),
+      history: this.history,
+      historySize: this.maxHistory,
+      completer: (line) => {
+        const [matches, partial] = this.completer.complete(line);
+        if (matches.length > 0)
+          return [matches, partial];
+        return [[], line];
+      }
+    }) : readline3.createInterface({
       input: process.stdin,
       output: process.stdout,
       prompt: pc2.cyan("> "),
@@ -29281,46 +30041,22 @@ class Repl {
     });
     this.rl.on("close", () => {
       this.running = false;
+      this.saveHistory();
+      this.agent.shutdown();
+      if (this.exitOnClose)
+        process.exit(0);
     });
-    if (process.stdin.isTTY) {
-      readline2.emitKeypressEvents(process.stdin);
-      process.stdin.on("keypress", async (str, key) => {
-        if (key.name === "escape") {
-          const escBytes = key.sequence ? (key.sequence.match(/\x1b/g) || []).length : 1;
-          const now = Date.now();
-          const withinWindow = now - this.lastEscTime < this.doubleEscDelay;
-          this.lastEscTime = now;
-          if (escBytes >= 2 || withinWindow) {
-            this.lastEscTime = 0;
-            if (this.agentRunning) {
-              process.stdout.write(pc2.yellow(`
-${t("repl.interrupt")}
-`));
-              this.agent.shutdown();
-            }
-          }
-          return;
-        }
-        if (key.ctrl && key.name === "v" && !this.agentRunning) {
-          try {
-            const { readClipboardImage: readClipboardImage2, bufferToDataUrl: bufferToDataUrl2 } = await Promise.resolve().then(() => (init_image_utils(), exports_image_utils));
-            const clipBuf = await readClipboardImage2();
-            if (clipBuf) {
-              const { dataUrl } = await bufferToDataUrl2(clipBuf);
-              this.pendingClipboardImage = dataUrl;
-              const sizeKb = Math.round(dataUrl.length * 3 / 4 / 1024);
-              console.log(pc2.green(`
-${t("image.attached", { source: "clipboard", size: `${sizeKb} KB` })}`));
-              this.rl.prompt();
-            } else {
-              console.log(pc2.yellow(`
-${t("image.clipboard_empty")}`));
-              this.rl.prompt();
-            }
-          } catch {}
-        }
+    if (this.exitOnClose && !process.stdin.isTTY) {
+      process.stdin.on("end", () => {
+        this.running = false;
+        this.saveHistory();
+        this.agent.shutdown();
+        process.exit(0);
       });
     }
+    if (this.rl instanceof LineEditor) {
+      this.rl.onKeyInput = (str, key) => this.handleSpecialKey(str, key);
+    }
     let forceExitTimer = null;
     process.on("SIGINT", () => {
       if (this.agentRunning) {
@@ -29336,6 +30072,51 @@ ${t("image.clipboard_empty")}`));
       }
     });
   }
+  handleSpecialKey(str, key) {
+    if (key.name === "escape") {
+      const escBytes = key.sequence ? (key.sequence.match(/\x1b/g) || []).length : 1;
+      const now = Date.now();
+      const withinWindow = now - this.lastEscTime < this.doubleEscDelay;
+      this.lastEscTime = now;
+      if (escBytes >= 2 || withinWindow) {
+        this.lastEscTime = 0;
+        if (this.agentRunning) {
+          process.stdout.write(pc2.yellow(`
+${t("repl.interrupt")}
+`));
+          this.agent.shutdown();
+        }
+      }
+      return true;
+    }
+    if (key.ctrl && key.name === "v" && !this.agentRunning) {
+      this.pasteClipboardImage();
+      return true;
+    }
+    return false;
+  }
+  async pasteClipboardImage() {
+    try {
+      const { readClipboardImage: readClipboardImage2, bufferToDataUrl: bufferToDataUrl2 } = await Promise.resolve().then(() => (init_image_utils(), exports_image_utils));
+      const clipBuf = await readClipboardImage2();
+      if (clipBuf) {
+        const { dataUrl } = await bufferToDataUrl2(clipBuf);
+        this.pendingClipboardImage = dataUrl;
+        const sizeKb = Math.round(dataUrl.length * 3 / 4 / 1024);
+        console.log(pc2.green(`
+${t("image.attached", { source: "clipboard", size: `${sizeKb} KB` })}`));
+        if (this.rl instanceof LineEditor)
+          this.rl.reset();
+        this.rl.prompt();
+      } else {
+        console.log(pc2.yellow(`
+${t("image.clipboard_empty")}`));
+        if (this.rl instanceof LineEditor)
+          this.rl.reset();
+        this.rl.prompt();
+      }
+    } catch {}
+  }
   isMultiLineInput(line) {
     if (line.endsWith("\\"))
       return true;
@@ -29361,6 +30142,8 @@ ${t("image.clipboard_empty")}`));
         this.pendingClipboardImage = null;
       }
       this.logger?.logREPL("user", input);
+      if (this.rl instanceof LineEditor)
+        this.rl.reset();
       process.stdout.write(`
 ` + pc2.green(t("repl.agent")));
       const renderer = new Renderer({
@@ -29552,6 +30335,21 @@ ${t("image.clipboard_empty")}`));
   }
 }
 
+// src/cli/run-result.ts
+init_i18n();
+init_colors();
+function printRunResult(result, flush) {
+  flush();
+  if (result.success) {
+    if (!result.text) {
+      console.log(pc2.yellow(t("cli.no_output")));
+    }
+    return 0;
+  }
+  console.error(`${t("error.prefix")}${result.error}`);
+  return 1;
+}
+
 // src/cli/main.ts
 init_setup();
 init_config2();
@@ -29784,18 +30582,9 @@ async function main() {
       }
     });
     renderer.flush();
-    if (result.success) {
-      if (!result.text) {
-        console.log(pc2.yellow(t("cli.no_output")));
-      }
-    } else {
-      console.error(`${t("error.prefix")}${result.error}`);
-      if (result.text) {
-        console.log(formatMarkdown(result.text));
-      }
-      process.exit(1);
-    }
+    const exitCode = printRunResult(result, () => renderer.flush());
     agent.shutdown();
+    process.exit(exitCode);
   } else {
     const configPath = join41(homedir18(), ".mma", "config.json");
     if (!existsSync46(configPath)) {
@@ -29858,7 +30647,7 @@ async function main() {
       logger
     } = await bootstrap(undefined, projectDir, noAgentsMd, exitOnComplete);
     startAutoUpdate(config);
-    const repl = new Repl(agent, config, sessionManager, skillsModule, pluginManager, configDir, baseDir, noAgentsMd, logger);
+    const repl = new Repl(agent, config, sessionManager, skillsModule, pluginManager, configDir, baseDir, noAgentsMd, logger, true);
     repl.start();
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "micro-models-agent",
-  "version": "0.32.0",
+  "version": "0.33.1",
   "description": "Micro Models Agent (MMA) — LLM agent harness for small models (Qwen3.5-9B, 32K-64K context)",
   "type": "module",
   "bin": {