u-foo 2.3.13 → 2.3.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "2.3.13",
+  "version": "2.3.15",
   "description": "Multi-Agent Workspace Protocol. Just add u. claude → uclaude, codex → ucodex.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://ufoo.dev",

package/src/chat/agentViewController.js

@@ -32,6 +32,7 @@ function createAgentViewController(options = {}) {
     connectAgentInput = () => {},
     disconnectAgentInput = () => {},
     sendRaw = () => {},
+    sendBusMessage = () => {},
     sendResize = () => {},
     requestScreenSnapshot = () => {},
   } = options;
@@ -47,6 +48,9 @@ function createAgentViewController(options = {}) {
   let agentBarVisible = false;
   let detachedChildren = null;
   let agentInputSuppressUntil = 0;
+  let busInputValue = "";
+  let busInputCursor = 0;
+  let busLogLines = [];
   const originalRender = screen.render.bind(screen);
   let renderFrozen = false;
 
@@ -63,6 +67,139 @@ function createAgentViewController(options = {}) {
     return processStdout.columns || 80;
   }
 
+  function stripAnsi(text = "") {
+    return String(text || "").replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "")
+      .replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "");
+  }
+
+  function clamp(value, min, max) {
+    const normalized = Number.isFinite(value) ? Math.floor(value) : min;
+    return Math.max(min, Math.min(max, normalized));
+  }
+
+  function fitText(text = "", width = 1) {
+    const normalizedWidth = Math.max(1, width);
+    const clean = stripAnsi(String(text || "")).replace(/\r/g, "");
+    if (clean.length <= normalizedWidth) {
+      return clean + " ".repeat(normalizedWidth - clean.length);
+    }
+    if (normalizedWidth <= 1) return clean.slice(0, normalizedWidth);
+    return clean.slice(0, normalizedWidth - 1) + "…";
+  }
+
+  function boxTop(title = "", width = 80) {
+    const inner = Math.max(1, width - 2);
+    const label = title ? ` ${title} ` : "";
+    const safe = stripAnsi(label).slice(0, inner);
+    return `┌${safe}${"─".repeat(Math.max(0, inner - safe.length))}┐`;
+  }
+
+  function boxBottom(width = 80) {
+    return `└${"─".repeat(Math.max(1, width - 2))}┘`;
+  }
+
+  function boxMiddle(text = "", width = 80) {
+    const inner = Math.max(1, width - 2);
+    return `│${fitText(text, inner)}│`;
+  }
+
+  function wrapTextLine(text = "", width = 80) {
+    const inner = Math.max(1, width);
+    const clean = stripAnsi(String(text || ""));
+    if (!clean) return [""];
+    const lines = [];
+    let rest = clean;
+    while (rest.length > inner) {
+      lines.push(rest.slice(0, inner));
+      rest = rest.slice(inner);
+    }
+    lines.push(rest);
+    return lines;
+  }
+
+  function getWrappedBusLogLines(width = 80) {
+    const inner = Math.max(1, width - 2);
+    const wrapped = [];
+    for (const line of busLogLines) {
+      wrapped.push(...wrapTextLine(line, inner));
+    }
+    return wrapped;
+  }
+
+  function writeAt(row, content = "") {
+    processStdout.write(`\x1b[${row};1H\x1b[2K${content}`);
+  }
+
+  function resetBusView(agentId) {
+    busInputValue = "";
+    busInputCursor = 0;
+    const label = getAgentLabel(agentId);
+    busLogLines = [
+      `ufoo internal · ${label}`,
+      "Enter 发送 · Esc 返回 · ↓ agent bar",
+      "",
+    ];
+  }
+
+  function appendBusLog(text = "") {
+    const clean = stripAnsi(String(text || "")).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    if (busLogLines.length === 0) busLogLines.push("");
+    for (const char of clean) {
+      if (char === "\n") {
+        busLogLines.push("");
+      } else {
+        busLogLines[busLogLines.length - 1] += char;
+      }
+    }
+    if (busLogLines.length > 1000) {
+      busLogLines = busLogLines.slice(-1000);
+    }
+  }
+
+  function getBusInputViewport(width) {
+    const inner = Math.max(1, width - 4);
+    const value = String(busInputValue || "").replace(/\n/g, "⏎");
+    let start = 0;
+    if (busInputCursor >= inner) {
+      start = busInputCursor - inner + 1;
+    }
+    return {
+      text: value.slice(start, start + inner),
+      cursorCol: Math.max(0, busInputCursor - start),
+    };
+  }
+
+  function renderBusView() {
+    if (currentView !== "agent" || !agentViewUsesBus) return;
+    const rows = getRows();
+    const cols = getCols();
+    const width = Math.max(20, cols);
+    const inputTop = Math.max(4, rows - 3);
+    const logTop = 1;
+    const logBottom = Math.max(logTop + 1, inputTop - 1);
+    const logContentTop = logTop + 1;
+    const logContentBottom = logBottom - 1;
+    const logContentHeight = Math.max(1, logContentBottom - logContentTop + 1);
+    const label = getAgentLabel(viewingAgent);
+
+    processStdout.write("\x1b[?25l");
+    writeAt(logTop, boxTop(`ufoo internal · ${label}`, width));
+    const visibleLines = getWrappedBusLogLines(width).slice(-logContentHeight);
+    for (let i = 0; i < logContentHeight; i += 1) {
+      writeAt(logContentTop + i, boxMiddle(visibleLines[i] || "", width));
+    }
+    writeAt(logBottom, boxBottom(width));
+
+    writeAt(inputTop, boxTop("message", width));
+    const viewport = getBusInputViewport(width);
+    writeAt(inputTop + 1, boxMiddle(`> ${viewport.text}`, width));
+    writeAt(inputTop + 2, boxBottom(width));
+
+    renderAgentDashboard();
+    const cursorCol = clamp(4 + viewport.cursorCol, 1, width);
+    processStdout.write(`\x1b[${inputTop + 1};${cursorCol}H\x1b[?25h`);
+  }
+
   function renderAgentDashboard() {
     if (!agentBarVisible && getFocusMode() !== "dashboard") return;
     const rows = getRows();
@@ -127,8 +264,8 @@ function createAgentViewController(options = {}) {
     agentInputSuppressUntil = now() + 300;
     agentViewUsesBus = Boolean(options.useBus);
     if (agentViewUsesBus) {
-      const label = getAgentLabel(agentId);
-      processStdout.write(`ufoo internal · ${label}\r\n\r\n> `);
+      resetBusView(agentId);
+      renderBusView();
     } else {
       const sockPath = getInjectSockPath(agentId);
       connectAgentOutput(sockPath);
@@ -153,6 +290,9 @@ function createAgentViewController(options = {}) {
     agentViewUsesBus = false;
     agentOutputSuppressed = false;
     agentBarVisible = false;
+    busInputValue = "";
+    busInputCursor = 0;
+    busLogLines = [];
 
     currentView = "main";
     viewingAgent = null;
@@ -199,6 +339,117 @@ function createAgentViewController(options = {}) {
     agentOutputSuppressed = true;
   }
 
+  function insertBusInput(text = "") {
+    const value = String(text || "");
+    if (!value) return;
+    busInputValue = busInputValue.slice(0, busInputCursor) + value + busInputValue.slice(busInputCursor);
+    busInputCursor += value.length;
+    renderBusView();
+  }
+
+  function deleteBusInputBeforeCursor() {
+    if (busInputCursor <= 0) return;
+    busInputValue = busInputValue.slice(0, busInputCursor - 1) + busInputValue.slice(busInputCursor);
+    busInputCursor -= 1;
+    renderBusView();
+  }
+
+  function clearBusInput() {
+    busInputValue = "";
+    busInputCursor = 0;
+    renderBusView();
+  }
+
+  function submitBusInput() {
+    const text = String(busInputValue || "").trim();
+    if (!text) {
+      renderBusView();
+      return;
+    }
+    appendBusLog(`> ${text}\n`);
+    busInputValue = "";
+    busInputCursor = 0;
+    sendBusMessage(viewingAgent, text);
+    renderBusView();
+  }
+
+  function handleBusAgentKey(ch, key = {}) {
+    if (currentView !== "agent" || !agentViewUsesBus) return false;
+    const keyName = key && key.name;
+
+    if (keyName === "down") return false;
+
+    if (keyName === "escape") {
+      exitAgentView();
+      return true;
+    }
+    if (keyName === "return" || keyName === "enter") {
+      if (key && (key.shift || key.meta)) {
+        insertBusInput("\n");
+      } else {
+        submitBusInput();
+      }
+      return true;
+    }
+    if (key && key.ctrl && keyName === "u") {
+      clearBusInput();
+      return true;
+    }
+    if (key && key.ctrl && keyName === "a") {
+      busInputCursor = 0;
+      renderBusView();
+      return true;
+    }
+    if (key && key.ctrl && keyName === "e") {
+      busInputCursor = busInputValue.length;
+      renderBusView();
+      return true;
+    }
+    if (keyName === "left") {
+      busInputCursor = Math.max(0, busInputCursor - 1);
+      renderBusView();
+      return true;
+    }
+    if (keyName === "right") {
+      busInputCursor = Math.min(busInputValue.length, busInputCursor + 1);
+      renderBusView();
+      return true;
+    }
+    if (keyName === "home") {
+      busInputCursor = 0;
+      renderBusView();
+      return true;
+    }
+    if (keyName === "end") {
+      busInputCursor = busInputValue.length;
+      renderBusView();
+      return true;
+    }
+    if (keyName === "backspace") {
+      deleteBusInputBeforeCursor();
+      return true;
+    }
+    if (keyName === "delete") {
+      if (busInputCursor < busInputValue.length) {
+        busInputValue = busInputValue.slice(0, busInputCursor) + busInputValue.slice(busInputCursor + 1);
+        renderBusView();
+      }
+      return true;
+    }
+    if (ch && ch.length > 1 && (!keyName || keyName.length !== 1)) {
+      insertBusInput(ch.replace(/\r\n/g, "\n").replace(/\r/g, "\n"));
+      return true;
+    }
+    const insertChar = (ch && ch.length === 1)
+      ? ch
+      : (keyName && keyName.length === 1 ? keyName : "");
+    if (insertChar && !/^[\x00-\x08\x0b-\x0c\x0e-\x1f\x7f]$/.test(insertChar)) {
+      insertBusInput(insertChar);
+      return true;
+    }
+    return true;
+  }
+
   function sendRawToAgent(data) {
     sendRaw(data);
   }
@@ -219,6 +470,11 @@ function createAgentViewController(options = {}) {
     const cleaned = text
       .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "")
       .replace(/\x1b\[(?:[?>=]?[0-9]*c|[?]?6n|5n)/g, "");
+    if (agentViewUsesBus) {
+      appendBusLog(cleaned);
+      renderBusView();
+      return;
+    }
     if (cleaned) processStdout.write(cleaned);
     if (agentBarVisible) {
       const rows = getRows();
@@ -244,7 +500,11 @@ function createAgentViewController(options = {}) {
     const cols = getCols();
     processStdout.write(`\x1b[1;${rows - 1}r`);
     sendResize(cols, Math.max(1, rows - 1));
-    renderAgentDashboard();
+    if (agentViewUsesBus) {
+      renderBusView();
+    } else {
+      renderAgentDashboard();
+    }
     return true;
   }
 
@@ -270,6 +530,9 @@ function createAgentViewController(options = {}) {
 
   function setAgentOutputSuppressed(value) {
     agentOutputSuppressed = Boolean(value);
+    if (!agentOutputSuppressed && agentViewUsesBus) {
+      renderBusView();
+    }
   }
 
   function isAgentBarVisible() {
@@ -295,6 +558,7 @@ function createAgentViewController(options = {}) {
     writeToAgentTerm,
     placeAgentCursor,
     handleResizeInAgentView,
+    handleBusAgentKey,
   };
 }
 

package/src/chat/index.js

@@ -1565,6 +1565,16 @@ async function runChat(projectRoot, options = {}) {
     sendRaw: (data) => {
       sendRawWithCapabilities(data);
     },
+    sendBusMessage: (target, message) => {
+      if (!target || !message) return;
+      send({
+        type: IPC_REQUEST_TYPES.BUS_SEND,
+        target,
+        message,
+        injection_mode: "immediate",
+        source: "chat-internal-agent-view",
+      });
+    },
     sendResize: (cols, rows) => {
       sendResizeWithCapabilities(cols, rows);
     },
@@ -2026,6 +2036,9 @@ async function runChat(projectRoot, options = {}) {
       if (key && key.ctrl && key.name === "c") {
         return; // handled by screen.key(["C-c"])
       }
+      if (agentViewController && agentViewController.handleBusAgentKey(ch, key)) {
+        return;
+      }
       // Down arrow: enter agents bar (same pattern as normal chat dashboard)
       if (key && key.name === "down") {
         enterAgentDashboardMode();

package/src/chat/inputListenerController.js

@@ -59,6 +59,82 @@ function createInputListenerController(options = {}) {
     }
   }
 
+  function clampCursorPos(pos = 0, value = "") {
+    const text = String(value || "");
+    const normalized = Number.isFinite(pos) ? Math.floor(pos) : 0;
+    return Math.max(0, Math.min(text.length, normalized));
+  }
+
+  function refreshAfterEdit(textarea) {
+    resizeInput();
+    ensureInputCursorVisible();
+    updateCursor(textarea);
+    updateDraftFromInput();
+
+    if (textarea && shouldShowCompletion(textarea.value)) {
+      completionController.show(textarea.value);
+    } else {
+      completionController.hide();
+    }
+
+    render(textarea);
+  }
+
+  function replaceInputRange(textarea, start, end, replacement = "") {
+    if (!textarea) return;
+    const value = String(textarea.value || "");
+    const safeStart = clampCursorPos(start, value);
+    const safeEnd = clampCursorPos(end, value);
+    const from = Math.min(safeStart, safeEnd);
+    const to = Math.max(safeStart, safeEnd);
+    const insert = String(replacement || "");
+    textarea.value = value.slice(0, from) + insert + value.slice(to);
+    setCursorPos(from + insert.length);
+    resetPreferredCol();
+    refreshAfterEdit(textarea);
+  }
+
+  function deleteWordBefore(textarea) {
+    const value = String((textarea && textarea.value) || "");
+    const cursorPos = clampCursorPos(getCursorPos(), value);
+    if (cursorPos <= 0) return;
+    const before = value.slice(0, cursorPos);
+    const match = before.match(/\s*\S+\s*$/);
+    const start = match ? cursorPos - match[0].length : Math.max(0, cursorPos - 1);
+    replaceInputRange(textarea, start, cursorPos, "");
+  }
+
+  function moveCursorByWord(textarea, direction = "forward") {
+    const value = String((textarea && textarea.value) || "");
+    const cursorPos = clampCursorPos(getCursorPos(), value);
+    if (direction === "backward") {
+      const before = value.slice(0, cursorPos);
+      const trimmedEnd = before.search(/\S\s*$/) >= 0 ? before.replace(/\s+$/, "") : before;
+      const match = trimmedEnd.match(/\S+$/);
+      return match ? trimmedEnd.length - match[0].length : 0;
+    }
+    const after = value.slice(cursorPos);
+    const match = after.match(/^\s*\S+/);
+    return match ? Math.min(value.length, cursorPos + match[0].length) : value.length;
+  }
+
+  function moveCursorToVisualBoundary(textarea, boundary = "start") {
+    const width = getWrapWidth();
+    const value = String((textarea && textarea.value) || "");
+    if (width <= 0) return boundary === "end" ? value.length : 0;
+    const cursorPos = clampCursorPos(getCursorPos(), value);
+    const { row } = getCursorRowCol(value, cursorPos, width);
+    const targetCol = boundary === "end" ? width : 0;
+    return getCursorPosForRowCol(value, row, targetCol, width);
+  }
+
+  function setCursorAndRender(textarea, nextPos) {
+    setCursorPos(clampCursorPos(nextPos, (textarea && textarea.value) || ""));
+    ensureInputCursorVisible();
+    updateCursor(textarea);
+    render(textarea);
+  }
+
   function handleKey(ch, key = {}, textarea) {
     const keyName = key && key.name;
 
@@ -136,8 +212,12 @@ function createInputListenerController(options = {}) {
     }
 
     if (keyName === "return" || keyName === "enter") {
-      if (key && key.shift) {
+      const value = String((textarea && textarea.value) || "");
+      const cursorPos = clampCursorPos(getCursorPos(), value);
+      if (key && (key.shift || key.meta)) {
         insertTextAtCursor("\n");
+      } else if (cursorPos > 0 && value[cursorPos - 1] === "\\") {
+        replaceInputRange(textarea, cursorPos - 1, cursorPos, "\n");
       } else {
         resetPreferredCol();
         if (textarea && typeof textarea._done === "function") {
@@ -147,6 +227,87 @@ function createInputListenerController(options = {}) {
       return;
     }
 
+    if (key && key.ctrl) {
+      if (keyName === "a") {
+        setCursorAndRender(textarea, moveCursorToVisualBoundary(textarea, "start"));
+        resetPreferredCol();
+        return;
+      }
+      if (keyName === "e") {
+        setCursorAndRender(textarea, moveCursorToVisualBoundary(textarea, "end"));
+        resetPreferredCol();
+        return;
+      }
+      if (keyName === "b") {
+        const cursorPos = getCursorPos();
+        if (cursorPos > 0) setCursorAndRender(textarea, cursorPos - 1);
+        resetPreferredCol();
+        return;
+      }
+      if (keyName === "f") {
+        const cursorPos = getCursorPos();
+        const value = String((textarea && textarea.value) || "");
+        if (cursorPos < value.length) setCursorAndRender(textarea, cursorPos + 1);
+        resetPreferredCol();
+        return;
+      }
+      if (keyName === "d") {
+        const cursorPos = getCursorPos();
+        const value = String((textarea && textarea.value) || "");
+        if (cursorPos < value.length) replaceInputRange(textarea, cursorPos, cursorPos + 1, "");
+        return;
+      }
+      if (keyName === "h") {
+        const cursorPos = getCursorPos();
+        if (cursorPos > 0) replaceInputRange(textarea, cursorPos - 1, cursorPos, "");
+        return;
+      }
+      if (keyName === "k") {
+        const cursorPos = getCursorPos();
+        const value = String((textarea && textarea.value) || "");
+        const target = moveCursorToVisualBoundary(textarea, "end");
+        if (target === cursorPos && value[cursorPos] === "\n") {
+          replaceInputRange(textarea, cursorPos, cursorPos + 1, "");
+        } else {
+          replaceInputRange(textarea, cursorPos, target, "");
+        }
+        return;
+      }
+      if (keyName === "u") {
+        const cursorPos = getCursorPos();
+        const value = String((textarea && textarea.value) || "");
+        const target = moveCursorToVisualBoundary(textarea, "start");
+        if (target === cursorPos && value[cursorPos - 1] === "\n") {
+          replaceInputRange(textarea, cursorPos - 1, cursorPos, "");
+        } else {
+          replaceInputRange(textarea, target, cursorPos, "");
+        }
+        return;
+      }
+      if (keyName === "w") {
+        deleteWordBefore(textarea);
+        return;
+      }
+    }
+
+    if (key && key.meta) {
+      if (keyName === "b") {
+        setCursorAndRender(textarea, moveCursorByWord(textarea, "backward"));
+        resetPreferredCol();
+        return;
+      }
+      if (keyName === "f") {
+        setCursorAndRender(textarea, moveCursorByWord(textarea, "forward"));
+        resetPreferredCol();
+        return;
+      }
+      if (keyName === "d") {
+        const cursorPos = getCursorPos();
+        replaceInputRange(textarea, cursorPos, moveCursorByWord(textarea, "forward"), "");
+        return;
+      }
+    }
+
     if (keyName === "left") {
       const cursorPos = getCursorPos();
       if (cursorPos > 0) setCursorPos(cursorPos - 1);
@@ -170,20 +331,14 @@ function createInputListenerController(options = {}) {
     }
 
     if (keyName === "home") {
-      setCursorPos(0);
+      setCursorAndRender(textarea, moveCursorToVisualBoundary(textarea, "start"));
       resetPreferredCol();
-      ensureInputCursorVisible();
-      updateCursor(textarea);
-      render(textarea);
       return;
     }
 
     if (keyName === "end") {
-      setCursorPos((textarea && textarea.value ? textarea.value.length : 0));
+      setCursorAndRender(textarea, moveCursorToVisualBoundary(textarea, "end"));
       resetPreferredCol();
-      ensureInputCursorVisible();
-      updateCursor(textarea);
-      render(textarea);
       return;
     }
 
@@ -192,17 +347,6 @@ function createInputListenerController(options = {}) {
         completionController.jumpToLast();
         return;
       }
-      if (historyUp()) {
-        completionController.hide();
-        return;
-      }
-    }
-
-    if (keyName === "down") {
-      if (historyDown()) {
-        completionController.hide();
-        return;
-      }
     }
 
     if (keyName === "up" || keyName === "down") {
@@ -220,11 +364,34 @@ function createInputListenerController(options = {}) {
 
       const cursorPos = getCursorPos();
       const value = (textarea && textarea.value) || "";
+      if (!value) {
+        if (keyName === "up") {
+          if (historyUp()) completionController.hide();
+          return;
+        }
+        if (historyDown()) {
+          completionController.hide();
+          return;
+        }
+        enterDashboardMode();
+        return;
+      }
       const { row, col } = getCursorRowCol(value, cursorPos, innerWidth);
       if (getPreferredCol() === null) setPreferredCol(col);
       const totalRows = countLines(value, innerWidth);
 
+      if (keyName === "up" && row <= 0) {
+        if (historyUp()) {
+          completionController.hide();
+        }
+        return;
+      }
+
       if (keyName === "down" && row >= totalRows - 1) {
+        if (historyDown()) {
+          completionController.hide();
+          return;
+        }
         enterDashboardMode();
         return;
       }
@@ -261,21 +428,11 @@ function createInputListenerController(options = {}) {
     if (keyName === "backspace") {
       const cursorPos = getCursorPos();
       if (cursorPos > 0 && textarea) {
-        textarea.value = textarea.value.slice(0, cursorPos - 1) + textarea.value.slice(cursorPos);
-        setCursorPos(cursorPos - 1);
-        resetPreferredCol();
-        resizeInput();
-        ensureInputCursorVisible();
-        updateCursor(textarea);
-        updateDraftFromInput();
-
-        if (shouldShowCompletion(textarea.value)) {
-          completionController.show(textarea.value);
+        if (key && (key.ctrl || key.meta)) {
+          deleteWordBefore(textarea);
         } else {
-          completionController.hide();
+          replaceInputRange(textarea, cursorPos - 1, cursorPos, "");
         }
-
-        render(textarea);
       }
       return;
     }
@@ -283,13 +440,11 @@ function createInputListenerController(options = {}) {
     if (keyName === "delete") {
       const cursorPos = getCursorPos();
       if (textarea && cursorPos < textarea.value.length) {
-        textarea.value = textarea.value.slice(0, cursorPos) + textarea.value.slice(cursorPos + 1);
-        resetPreferredCol();
-        resizeInput();
-        ensureInputCursorVisible();
-        updateCursor(textarea);
-        render(textarea);
-        updateDraftFromInput();
+        if (key && key.meta) {
+          replaceInputRange(textarea, cursorPos, moveCursorToVisualBoundary(textarea, "end"), "");
+        } else {
+          replaceInputRange(textarea, cursorPos, cursorPos + 1, "");
+        }
       }
       return;
     }
@@ -300,21 +455,8 @@ function createInputListenerController(options = {}) {
 
     if (insertChar && !/^[\x00-\x08\x0b-\x0c\x0e-\x1f\x7f]$/.test(insertChar) && textarea) {
       const cursorPos = getCursorPos();
-      textarea.value = textarea.value.slice(0, cursorPos) + insertChar + textarea.value.slice(cursorPos);
-      setCursorPos(cursorPos + 1);
       normalizeCommandPrefix();
-      resetPreferredCol();
-      resizeInput();
-      updateCursor(textarea);
-      updateDraftFromInput();
-
-      if (shouldShowCompletion(textarea.value)) {
-        completionController.show(textarea.value);
-      } else if (completionController.isActive()) {
-        completionController.hide();
-      }
-
-      render(textarea);
+      replaceInputRange(textarea, cursorPos, cursorPos, insertChar);
     }
   }
 

package/src/chat/layout.js

@@ -4,6 +4,8 @@ function createChatLayout(options = {}) {
     currentInputHeight = 4,
     dashboardHeight = 1,
     version = "unknown",
+    logBorder = false,
+    logScrollbar = false,
   } = options;
   const normalizedDashboardHeight = Number.isFinite(dashboardHeight) && dashboardHeight > 0
     ? Math.floor(dashboardHeight)
@@ -32,24 +34,38 @@ function createChatLayout(options = {}) {
     }
   }
 
-  // Log area (no border for cleaner look)
+  // Log area
   const logBox = blessed.log({
     parent: screen,
     top: 0,
     left: 0,
     width: "100%",
     height: `100%-${reservedBottomLines}`, // Will be adjusted dynamically
+    border: logBorder ? { type: "line" } : null,
     tags: true,
     scrollable: true,
     alwaysScroll: true,
     scrollback: 10000,
-    scrollbar: null,
+    scrollbar: logScrollbar
+      ? {
+        ch: " ",
+        track: { bg: "black" },
+        style: { bg: "gray" },
+      }
+      : null,
     keys: true,
     vi: true,
     // Mouse handled globally (toggleable) to keep copy working
     mouse: false,
     // Ensure proper wrapping and width calculation
     wrap: true,
+    padding: logBorder ? { left: 1, right: 1 } : undefined,
+    style: logBorder
+      ? {
+        border: { fg: "gray" },
+        scrollbar: { bg: "gray" },
+      }
+      : undefined,
   });
 
   // Status line just above input

package/src/code/tui.js

@@ -293,6 +293,111 @@ function moveCursorHorizontally(cursorPos = 0, inputValue = "", direction = "rig
   return Math.min(max, pos + 1);
 }
 
+function clampCursorPos(cursorPos = 0, inputValue = "") {
+  const text = String(inputValue || "");
+  const pos = Number.isFinite(cursorPos) ? Math.floor(cursorPos) : 0;
+  return Math.max(0, Math.min(text.length, pos));
+}
+
+function findLogicalLineStart(inputValue = "", cursorPos = 0) {
+  const text = String(inputValue || "");
+  const pos = clampCursorPos(cursorPos, text);
+  const prevNewline = text.lastIndexOf("\n", Math.max(0, pos - 1));
+  return prevNewline === -1 ? 0 : prevNewline + 1;
+}
+
+function findLogicalLineEnd(inputValue = "", cursorPos = 0) {
+  const text = String(inputValue || "");
+  const pos = clampCursorPos(cursorPos, text);
+  const nextNewline = text.indexOf("\n", pos);
+  return nextNewline === -1 ? text.length : nextNewline;
+}
+
+function moveCursorToVisualLineBoundary({
+  cursorPos = 0,
+  inputValue = "",
+  width = 80,
+  boundary = "start",
+  strWidth,
+} = {}) {
+  const inputMath = require("../chat/inputMath");
+  const text = String(inputValue || "");
+  const normalizedWidth = Number.isFinite(width) ? Math.max(1, Math.floor(width)) : 1;
+  const pos = clampCursorPos(cursorPos, text);
+  const { row } = inputMath.getCursorRowCol(text, pos, normalizedWidth, strWidth);
+  if (boundary === "end") {
+    return inputMath.getCursorPosForRowCol(text, row, normalizedWidth, normalizedWidth, strWidth);
+  }
+  return inputMath.getCursorPosForRowCol(text, row, 0, normalizedWidth, strWidth);
+}
+
+function moveCursorVertically({
+  cursorPos = 0,
+  inputValue = "",
+  width = 80,
+  direction = "down",
+  preferredCol = null,
+  strWidth,
+} = {}) {
+  const inputMath = require("../chat/inputMath");
+  const text = String(inputValue || "");
+  const normalizedWidth = Number.isFinite(width) ? Math.max(1, Math.floor(width)) : 1;
+  const pos = clampCursorPos(cursorPos, text);
+  const { row, col } = inputMath.getCursorRowCol(text, pos, normalizedWidth, strWidth);
+  const totalRows = inputMath.countLines(text, normalizedWidth, strWidth);
+  const targetCol = Number.isFinite(preferredCol) ? preferredCol : col;
+
+  if (direction === "up") {
+    if (row <= 0) {
+      return { moved: false, nextCursorPos: pos, preferredCol: targetCol, boundary: "top" };
+    }
+    return {
+      moved: true,
+      nextCursorPos: inputMath.getCursorPosForRowCol(text, row - 1, targetCol, normalizedWidth, strWidth),
+      preferredCol: targetCol,
+      boundary: "",
+    };
+  }
+
+  if (row >= totalRows - 1) {
+    return { moved: false, nextCursorPos: pos, preferredCol: targetCol, boundary: "bottom" };
+  }
+  return {
+    moved: true,
+    nextCursorPos: inputMath.getCursorPosForRowCol(text, row + 1, targetCol, normalizedWidth, strWidth),
+    preferredCol: targetCol,
+    boundary: "",
+  };
+}
+
+function deleteWordBeforeCursor(inputValue = "", cursorPos = 0) {
+  const text = String(inputValue || "");
+  const pos = clampCursorPos(cursorPos, text);
+  if (pos <= 0) return { value: text, cursorPos: pos };
+  const before = text.slice(0, pos);
+  const after = text.slice(pos);
+  const match = before.match(/\s*\S+\s*$/);
+  const start = match ? pos - match[0].length : Math.max(0, pos - 1);
+  return {
+    value: before.slice(0, start) + after,
+    cursorPos: start,
+  };
+}
+
+function moveCursorByWord(inputValue = "", cursorPos = 0, direction = "forward") {
+  const text = String(inputValue || "");
+  const pos = clampCursorPos(cursorPos, text);
+  if (direction === "backward") {
+    const before = text.slice(0, pos);
+    const trimmedEnd = before.search(/\S\s*$/) >= 0 ? before.replace(/\s+$/, "") : before;
+    const match = trimmedEnd.match(/\S+$/);
+    return match ? trimmedEnd.length - match[0].length : 0;
+  }
+  const after = text.slice(pos);
+  const match = after.match(/^\s*\S+/);
+  return match ? Math.min(text.length, pos + match[0].length) : text.length;
+}
+
 function resolveHistoryDownTransition({
   inputHistory = [],
   historyIndex = 0,
@@ -499,6 +604,11 @@ function runUcodeTui({
     let lastMergedToolGroup = null;
     let toolMergeId = 0;
     let cursorPos = 0;
+    let preferredCol = null;
+    let currentInputHeight = 4;
+    const MIN_INPUT_CONTENT_HEIGHT = 1;
+    const MAX_INPUT_CONTENT_HEIGHT = 8;
+    const DASHBOARD_HEIGHT = 1;
     let autoBusTimer = null;
     let autoBusQueued = false;
     let autoBusError = "";
@@ -510,12 +620,15 @@ function runUcodeTui({
       statusLine,
       completionPanel,
       dashboard,
+      inputTopLine,
       promptBox,
       input,
     } = createChatLayout({
       blessed,
       currentInputHeight: 4,
       version: UCODE_VERSION,
+      logBorder: true,
+      logScrollbar: true,
     });
 
     if (completionPanel && typeof completionPanel.hide === "function") {
@@ -555,6 +668,7 @@ function runUcodeTui({
       promptBox.width = Math.max(2, plain.length + 1);
       input.left = promptBox.width;
       input.width = `100%-${promptBox.width}`;
+      resizeInput();
     };
 
     // --- Cursor position helpers (mirrors chat inputListenerController) ---
@@ -565,6 +679,10 @@ function runUcodeTui({
 
     const getWrapWidth = () => inputMath.getWrapWidth(input, getInnerWidth());
 
+    const resetPreferredCol = () => {
+      preferredCol = null;
+    };
+
     const ensureInputCursorVisible = () => {
       const innerWidth = getWrapWidth();
       if (innerWidth <= 0) return;
@@ -583,6 +701,105 @@ function runUcodeTui({
       }
     };
 
+    const resizeInput = () => {
+      const innerWidth = getWrapWidth();
+      if (innerWidth <= 0) return;
+      const totalRows = inputMath.countLines(input.value || "", innerWidth, (v) => input.strWidth(v));
+      const contentHeight = Math.min(
+        MAX_INPUT_CONTENT_HEIGHT,
+        Math.max(MIN_INPUT_CONTENT_HEIGHT, totalRows)
+      );
+      const targetHeight = contentHeight + DASHBOARD_HEIGHT + 2;
+      if (targetHeight !== currentInputHeight) {
+        currentInputHeight = targetHeight;
+        input.height = contentHeight;
+        promptBox.height = contentHeight;
+        if (inputTopLine) inputTopLine.bottom = currentInputHeight - 1;
+      }
+      statusLine.bottom = currentInputHeight;
+      logBox.height = Math.max(1, screen.height - currentInputHeight - 1);
+      ensureInputCursorVisible();
+    };
+
+    const renderInput = () => {
+      resizeInput();
+      ensureInputCursorVisible();
+      input._updateCursor();
+      screen.render();
+    };
+
+    const setCursor = (nextPos) => {
+      cursorPos = clampCursorPos(nextPos, input.value || "");
+      ensureInputCursorVisible();
+      input._updateCursor();
+      screen.render();
+    };
+
+    const setInputValue = (value) => {
+      input.setValue(value || "");
+      cursorPos = (value || "").length;
+      resetPreferredCol();
+      renderInput();
+    };
+
+    const replaceInputRange = (start, end, replacement = "") => {
+      const value = input.value || "";
+      const safeStart = clampCursorPos(start, value);
+      const safeEnd = clampCursorPos(end, value);
+      const from = Math.min(safeStart, safeEnd);
+      const to = Math.max(safeStart, safeEnd);
+      input.value = value.slice(0, from) + String(replacement || "") + value.slice(to);
+      cursorPos = from + String(replacement || "").length;
+      resetPreferredCol();
+      renderInput();
+    };
+
+    const insertTextAtCursor = (text = "") => {
+      const normalized = inputMath.normalizePaste(text);
+      if (!normalized) return;
+      replaceInputRange(cursorPos, cursorPos, normalized);
+    };
+
+    const deleteBeforeCursor = () => {
+      if (cursorPos <= 0) return;
+      replaceInputRange(cursorPos - 1, cursorPos, "");
+    };
+
+    const deleteAtCursor = () => {
+      const value = input.value || "";
+      if (cursorPos >= value.length) return;
+      replaceInputRange(cursorPos, cursorPos + 1, "");
+    };
+
+    const deleteToBoundary = (boundary) => {
+      const value = input.value || "";
+      const innerWidth = getWrapWidth();
+      const target = boundary === "end"
+        ? moveCursorToVisualLineBoundary({
+          cursorPos,
+          inputValue: value,
+          width: innerWidth,
+          boundary: "end",
+          strWidth: (v) => input.strWidth(v),
+        })
+        : moveCursorToVisualLineBoundary({
+          cursorPos,
+          inputValue: value,
+          width: innerWidth,
+          boundary: "start",
+          strWidth: (v) => input.strWidth(v),
+        });
+      if (target === cursorPos && boundary === "end" && value[cursorPos] === "\n") {
+        replaceInputRange(cursorPos, cursorPos + 1, "");
+        return;
+      }
+      if (target === cursorPos && boundary === "start" && value[cursorPos - 1] === "\n") {
+        replaceInputRange(cursorPos - 1, cursorPos, "");
+        return;
+      }
+      replaceInputRange(Math.min(cursorPos, target), Math.max(cursorPos, target), "");
+    };
+
     // Override _updateCursor to use our tracked cursorPos
     input._updateCursor = function () {
       if (this.screen.focused !== this) return;
@@ -603,8 +820,8 @@ function runUcodeTui({
     };
 
     // Override _listener to support cursor-aware editing
-    const origDone = input._done ? input._done.bind(input) : null;
     let lastKeyRef = null;
+    let skipSubmitKeyRef = null;
     input._listener = function (ch, key) {
       const keyName = key && key.name;
 
@@ -614,69 +831,161 @@ function runUcodeTui({
       if (key && key === lastKeyRef) return;
       lastKeyRef = key || null;
 
-      // Let enter/return/escape pass through to blessed key handlers
-      if (keyName === "return" || keyName === "enter" || keyName === "escape") return;
+      if (keyName === "escape") return;
+
+      if (keyName === "return" || keyName === "enter") {
+        const value = this.value || "";
+        if (key && (key.shift || key.meta)) {
+          insertTextAtCursor("\n");
+          skipSubmitKeyRef = key || true;
+          return;
+        }
+        if (cursorPos > 0 && value[cursorPos - 1] === "\\") {
+          replaceInputRange(cursorPos - 1, cursorPos, "\n");
+          skipSubmitKeyRef = key || true;
+          return;
+        }
+        return;
+      }
 
       // Arrow keys handled by input.key() handlers below
       if (keyName === "left" || keyName === "right" || keyName === "up" || keyName === "down") return;
 
+      if (key && key.ctrl) {
+        if (keyName === "a") {
+          setCursor(moveCursorToVisualLineBoundary({
+            cursorPos,
+            inputValue: this.value || "",
+            width: getWrapWidth(),
+            boundary: "start",
+            strWidth: (v) => this.strWidth(v),
+          }));
+          resetPreferredCol();
+          return;
+        }
+        if (keyName === "e") {
+          setCursor(moveCursorToVisualLineBoundary({
+            cursorPos,
+            inputValue: this.value || "",
+            width: getWrapWidth(),
+            boundary: "end",
+            strWidth: (v) => this.strWidth(v),
+          }));
+          resetPreferredCol();
+          return;
+        }
+        if (keyName === "b") {
+          setCursor(moveCursorHorizontally(cursorPos, this.value || "", "left"));
+          resetPreferredCol();
+          return;
+        }
+        if (keyName === "f") {
+          setCursor(moveCursorHorizontally(cursorPos, this.value || "", "right"));
+          resetPreferredCol();
+          return;
+        }
+        if (keyName === "d") {
+          deleteAtCursor();
+          return;
+        }
+        if (keyName === "h") {
+          deleteBeforeCursor();
+          return;
+        }
+        if (keyName === "k") {
+          deleteToBoundary("end");
+          return;
+        }
+        if (keyName === "u") {
+          deleteToBoundary("start");
+          return;
+        }
+        if (keyName === "w") {
+          const next = deleteWordBeforeCursor(this.value || "", cursorPos);
+          this.value = next.value;
+          cursorPos = next.cursorPos;
+          resetPreferredCol();
+          renderInput();
+          return;
+        }
+      }
+
+      if (key && key.meta) {
+        if (keyName === "b") {
+          setCursor(moveCursorByWord(this.value || "", cursorPos, "backward"));
+          resetPreferredCol();
+          return;
+        }
+        if (keyName === "f") {
+          setCursor(moveCursorByWord(this.value || "", cursorPos, "forward"));
+          resetPreferredCol();
+          return;
+        }
+        if (keyName === "d") {
+          const end = moveCursorByWord(this.value || "", cursorPos, "forward");
+          replaceInputRange(cursorPos, end, "");
+          return;
+        }
+      }
+
       if (keyName === "backspace") {
-        if (cursorPos > 0 && this.value) {
-          this.value = this.value.slice(0, cursorPos - 1) + this.value.slice(cursorPos);
-          cursorPos -= 1;
-          ensureInputCursorVisible();
-          this._updateCursor();
-          this.screen.render();
+        if (key && (key.meta || key.ctrl)) {
+          const next = deleteWordBeforeCursor(this.value || "", cursorPos);
+          this.value = next.value;
+          cursorPos = next.cursorPos;
+          resetPreferredCol();
+          renderInput();
+        } else {
+          deleteBeforeCursor();
         }
         return;
       }
 
       if (keyName === "delete") {
-        if (this.value && cursorPos < this.value.length) {
-          this.value = this.value.slice(0, cursorPos) + this.value.slice(cursorPos + 1);
-          ensureInputCursorVisible();
-          this._updateCursor();
-          this.screen.render();
+        if (key && key.meta) {
+          deleteToBoundary("end");
+        } else {
+          deleteAtCursor();
         }
         return;
       }
 
       if (keyName === "home") {
-        cursorPos = 0;
-        ensureInputCursorVisible();
-        this._updateCursor();
-        this.screen.render();
+        setCursor(moveCursorToVisualLineBoundary({
+          cursorPos,
+          inputValue: this.value || "",
+          width: getWrapWidth(),
+          boundary: "start",
+          strWidth: (v) => this.strWidth(v),
+        }));
+        resetPreferredCol();
         return;
       }
 
       if (keyName === "end") {
-        cursorPos = (this.value || "").length;
-        ensureInputCursorVisible();
-        this._updateCursor();
-        this.screen.render();
+        setCursor(moveCursorToVisualLineBoundary({
+          cursorPos,
+          inputValue: this.value || "",
+          width: getWrapWidth(),
+          boundary: "end",
+          strWidth: (v) => this.strWidth(v),
+        }));
+        resetPreferredCol();
+        return;
+      }
+
+      if (ch && ch.length > 1 && (!keyName || keyName.length !== 1)) {
+        insertTextAtCursor(ch);
         return;
       }
 
       // Normal character insertion at cursor position
       const insertChar = (ch && ch.length === 1) ? ch : (keyName && keyName.length === 1 ? keyName : null);
       if (insertChar && !/^[\x00-\x08\x0b-\x0c\x0e-\x1f\x7f]$/.test(insertChar)) {
-        this.value = (this.value || "").slice(0, cursorPos) + insertChar + (this.value || "").slice(cursorPos);
-        cursorPos += 1;
-        ensureInputCursorVisible();
-        this._updateCursor();
-        this.screen.render();
+        insertTextAtCursor(insertChar);
       }
     };
 
-    // Helper to set input value and reset cursor to end
-    const setInputValue = (value) => {
-      input.setValue(value || "");
-      cursorPos = (value || "").length;
-      ensureInputCursorVisible();
-      input._updateCursor();
-      screen.render();
-    };
-
     const renderDashboard = () => {
       let hint = "No target agents";
       if (activeAgents.length > 0) {
@@ -922,7 +1231,7 @@ function runUcodeTui({
         statusInterval = null;
       }
       if (!message) {
-        statusLine.setContent(escapeBlessed(`UCODE · Ready${getBackgroundSuffix()}`));
+        statusLine.setContent(escapeBlessed(`UCODE · Ready · Enter send · Shift/Alt+Enter newline · PgUp/PgDn log · Ctrl+O tools${getBackgroundSuffix()}`));
         screen.render();
         return;
       }
@@ -1321,6 +1630,8 @@ function runUcodeTui({
       const trimmed = raw.trim();
       input.setValue("");
       cursorPos = 0;
+      resetPreferredCol();
+      resizeInput();
       screen.render();
       agentSelectionMode = false;
 
@@ -1345,7 +1656,11 @@ function runUcodeTui({
         });
     };
 
-    input.key(["enter"], () => {
+    input.key(["enter"], (ch, key) => {
+      if (skipSubmitKeyRef && (!key || skipSubmitKeyRef === key || skipSubmitKeyRef === true)) {
+        skipSubmitKeyRef = null;
+        return false;
+      }
       submitInput(input.getValue());
       return false;
     });
@@ -1355,7 +1670,6 @@ function runUcodeTui({
         agentSelectionMode,
         inputValue: currentValue,
       })) {
-        const previousTarget = targetAgent;
         targetAgent = null;
         selectedAgentIndex = -1;
         agentSelectionMode = false;
@@ -1365,12 +1679,43 @@ function runUcodeTui({
         input.focus();
         return false;
       }
-      if (inputHistory.length === 0) return;
+      if (currentValue) {
+        const move = moveCursorVertically({
+          cursorPos,
+          inputValue: currentValue,
+          width: getWrapWidth(),
+          direction: "up",
+          preferredCol,
+          strWidth: (v) => input.strWidth(v),
+        });
+        preferredCol = move.preferredCol;
+        if (move.moved) {
+          setCursor(move.nextCursorPos);
+          return false;
+        }
+      }
+      if (inputHistory.length === 0) return false;
       historyIndex = Math.max(0, historyIndex - 1);
       setInputValue(inputHistory[historyIndex] || "");
+      return false;
     });
     input.key(["down"], () => {
       const currentValue = input.getValue();
+      if (currentValue) {
+        const move = moveCursorVertically({
+          cursorPos,
+          inputValue: currentValue,
+          width: getWrapWidth(),
+          direction: "down",
+          preferredCol,
+          strWidth: (v) => input.strWidth(v),
+        });
+        preferredCol = move.preferredCol;
+        if (move.moved) {
+          setCursor(move.nextCursorPos);
+          return false;
+        }
+      }
       const historyTransition = resolveHistoryDownTransition({
         inputHistory,
         historyIndex,
@@ -1428,10 +1773,8 @@ function runUcodeTui({
       }
       const next = moveCursorHorizontally(cursorPos, currentValue, "left");
       if (next !== cursorPos) {
-        cursorPos = next;
-        ensureInputCursorVisible();
-        input._updateCursor();
-        screen.render();
+        setCursor(next);
+        resetPreferredCol();
       }
       return false;
     });
@@ -1450,10 +1793,8 @@ function runUcodeTui({
       }
       const next = moveCursorHorizontally(cursorPos, currentValue, "right");
       if (next !== cursorPos) {
-        cursorPos = next;
-        ensureInputCursorVisible();
-        input._updateCursor();
-        screen.render();
+        setCursor(next);
+        resetPreferredCol();
       }
       return false;
     });
@@ -1496,6 +1837,14 @@ function runUcodeTui({
       }
       screen.render();
     });
+    screen.key(["pageup"], () => {
+      logBox.scroll(-Math.max(1, Math.floor((logBox.height || 10) / 2)));
+      screen.render();
+    });
+    screen.key(["pagedown"], () => {
+      logBox.scroll(Math.max(1, Math.floor((logBox.height || 10) / 2)));
+      screen.render();
+    });
     input.key(["escape"], () => {
       if (pendingTask && pendingTask.abortController && !pendingTask.abortController.signal.aborted) {
         try {
@@ -1510,11 +1859,10 @@ function runUcodeTui({
         });
         return false;
       }
-      const previousTarget = targetAgent;
       targetAgent = null;
       selectedAgentIndex = -1;
       agentSelectionMode = false;
-      input.setValue("");
+      setInputValue("");
       setPrompt();
       renderDashboard();
       // Target selection cleared - removed redundant log
@@ -1573,6 +1921,13 @@ module.exports = {
   cycleAgentSelectionIndex,
   shouldClearAgentSelectionOnUp,
   moveCursorHorizontally,
+  clampCursorPos,
+  findLogicalLineStart,
+  findLogicalLineEnd,
+  moveCursorToVisualLineBoundary,
+  moveCursorVertically,
+  deleteWordBeforeCursor,
+  moveCursorByWord,
   resolveHistoryDownTransition,
   filterSelectableAgents,
   stripLeakedEscapeTags,