@phren/agent 0.1.2 → 0.1.4

package/dist/tui.js

@@ -9,63 +9,22 @@ import { handleCommand } from "./commands.js";
 import { renderMarkdown } from "./multi/markdown.js";
 import { decodeDiffPayload, renderInlineDiff, DIFF_MARKER } from "./multi/diff-renderer.js";
 import * as os from "os";
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { execSync } from "node:child_process";
 import { loadInputMode, saveInputMode, savePermissionMode } from "./settings.js";
 import { createRequire } from "node:module";
+import { ESC, s, cols, stripAnsi, PERMISSION_COLORS, PERMISSION_ICONS, PERMISSION_LABELS, nextPermissionMode, permTag, formatToolInput, renderToolCall, } from "./tui/index.js";
+import { enterMenuMode as enterMenu, exitMenuMode as exitMenu, handleMenuKeypress as handleMenuKey, } from "./tui/index.js";
 const _require = createRequire(import.meta.url);
 const AGENT_VERSION = _require("../package.json").version;
-// ── ANSI helpers ─────────────────────────────────────────────────────────────
-const ESC = "\x1b[";
-const s = {
-    reset: `${ESC}0m`,
-    bold: (t) => `${ESC}1m${t}${ESC}0m`,
-    dim: (t) => `${ESC}2m${t}${ESC}0m`,
-    italic: (t) => `${ESC}3m${t}${ESC}0m`,
-    cyan: (t) => `${ESC}36m${t}${ESC}0m`,
-    green: (t) => `${ESC}32m${t}${ESC}0m`,
-    yellow: (t) => `${ESC}33m${t}${ESC}0m`,
-    red: (t) => `${ESC}31m${t}${ESC}0m`,
-    blue: (t) => `${ESC}34m${t}${ESC}0m`,
-    magenta: (t) => `${ESC}35m${t}${ESC}0m`,
-    gray: (t) => `${ESC}90m${t}${ESC}0m`,
-    invert: (t) => `${ESC}7m${t}${ESC}0m`,
-    // Gradient-style brand text
-    brand: (t) => `${ESC}1;35m${t}${ESC}0m`,
-};
-function cols() {
-    return process.stdout.columns || 80;
-}
-// ── Permission mode helpers ─────────────────────────────────────────────────
-const PERMISSION_MODES = ["suggest", "auto-confirm", "full-auto"];
-function nextPermissionMode(current) {
-    const idx = PERMISSION_MODES.indexOf(current);
-    return PERMISSION_MODES[(idx + 1) % PERMISSION_MODES.length];
-}
-const PERMISSION_LABELS = {
-    "suggest": "suggest",
-    "auto-confirm": "auto",
-    "full-auto": "full-auto",
-};
-const PERMISSION_ICONS = {
-    "suggest": "○",
-    "auto-confirm": "◐",
-    "full-auto": "●",
-};
-const PERMISSION_COLORS = {
-    "suggest": s.cyan,
-    "auto-confirm": s.green,
-    "full-auto": s.yellow,
-};
-function permTag(mode) {
-    return PERMISSION_COLORS[mode](`${PERMISSION_ICONS[mode]} ${mode}`);
-}
 // ── Status bar ───────────────────────────────────────────────────────────────
 function renderStatusBar(provider, project, turns, cost, permMode, agentCount) {
     const modeLabel = permMode ? PERMISSION_LABELS[permMode] : "";
     const agentTag = agentCount && agentCount > 0 ? ` A${agentCount}` : "";
-    // Left: brand + provider + project
+    // Left: brand + provider (skip project if it matches "phren" to avoid "phren · codex · phren")
     const parts = [" ◆ phren", provider];
-    if (project)
+    if (project && project !== "phren")
         parts.push(project);
     const left = parts.join(" · ");
     // Right: mode + agents + cost + turns
@@ -82,72 +41,19 @@ function renderStatusBar(provider, project, turns, cost, permMode, agentCount) {
     const pad = Math.max(0, w - left.length - right.length);
     return s.invert(left + " ".repeat(pad) + right);
 }
-function stripAnsi(t) {
-    return t.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "");
-}
-// ── Tool call rendering ──────────────────────────────────────────────────────
-const COMPACT_LINES = 3;
-function formatDuration(ms) {
-    if (ms < 1000)
-        return `${ms}ms`;
-    if (ms < 60_000)
-        return `${(ms / 1000).toFixed(1)}s`;
-    const mins = Math.floor(ms / 60_000);
-    const secs = Math.round((ms % 60_000) / 1000);
-    return `${mins}m ${secs}s`;
-}
-function formatToolInput(name, input) {
-    switch (name) {
-        case "read_file":
-        case "write_file":
-        case "edit_file": return input.file_path ?? "";
-        case "shell": return (input.command ?? "").slice(0, 60);
-        case "glob": return input.pattern ?? "";
-        case "grep": return `/${input.pattern ?? ""}/ ${input.path ?? ""}`;
-        case "git_commit": return (input.message ?? "").slice(0, 50);
-        case "phren_search": return input.query ?? "";
-        case "phren_add_finding": return (input.finding ?? "").slice(0, 50);
-        default: return JSON.stringify(input).slice(0, 60);
-    }
-}
-function renderToolCall(name, input, output, isError, durationMs) {
-    const preview = formatToolInput(name, input);
-    const dur = formatDuration(durationMs);
-    const icon = isError ? s.red("✗") : s.green("→");
-    const header = `  ${icon} ${s.bold(name)} ${s.gray(preview)}  ${s.dim(dur)}`;
-    // Compact: show first 3 lines only, with overflow count
-    const allLines = output.split("\n").filter(Boolean);
-    if (allLines.length === 0)
-        return header;
-    const shown = allLines.slice(0, COMPACT_LINES);
-    const body = shown.map((l) => s.dim(`    ${l.slice(0, cols() - 6)}`)).join("\n");
-    const overflow = allLines.length - COMPACT_LINES;
-    const more = overflow > 0 ? `\n${s.dim(`    ... +${overflow} lines`)}` : "";
-    return `${header}\n${body}${more}`;
-}
-// ── Menu mode helpers ────────────────────────────────────────────────────────
-let menuMod = null;
-async function loadMenuModule() {
-    if (!menuMod) {
-        try {
-            menuMod = await import("@phren/cli/shell/render-api");
-        }
-        catch {
-            menuMod = null;
-        }
-    }
-    return menuMod;
-}
 // ── Main TUI ─────────────────────────────────────────────────────────────────
 export async function startTui(config, spawner) {
     const contextLimit = config.provider.contextWindow ?? 200_000;
     const session = createSession(contextLimit);
     const w = process.stdout;
     const isTTY = process.stdout.isTTY;
+    const startTime = Date.now();
     let inputMode = loadInputMode();
     let pendingInput = null;
+    const steerQueue = [];
     let running = false;
     let inputLine = "";
+    let cursorPos = 0;
     let costStr = "";
     // ── Dual-mode state ─────────────────────────────────────────────────────
     let tuiMode = "chat";
@@ -165,61 +71,79 @@ export async function startTui(config, spawner) {
     const inputHistory = [];
     let historyIndex = -1;
     let savedInput = "";
-    // ── Menu rendering ─────────────────────────────────────────────────────
-    async function renderMenu() {
-        const mod = await loadMenuModule();
-        if (!mod || !config.phrenCtx)
-            return;
-        const result = await mod.renderMenuFrame(config.phrenCtx.phrenPath, config.phrenCtx.profile, menuState);
-        menuListCount = result.listCount;
-        // Full-screen write: single write to avoid flicker
-        w.write(`${ESC}?25l${ESC}H${ESC}2J${result.output}${ESC}?25h`);
-    }
-    function enterMenuMode() {
-        if (!config.phrenCtx) {
-            w.write(s.yellow("  phren not configured — menu unavailable\n"));
-            return;
-        }
-        tuiMode = "menu";
-        menuState.project = config.phrenCtx.project ?? menuState.project;
-        w.write("\x1b[?1049h"); // enter alternate screen
-        renderMenu();
-    }
-    function exitMenuMode() {
-        tuiMode = "chat";
-        menuFilterActive = false;
-        menuFilterBuf = "";
-        w.write("\x1b[?1049l"); // leave alternate screen (restores chat)
-        statusBar();
-        prompt(true); // skip newline — alt screen restore already positioned cursor
+    // ── Menu context bridge ─────────────────────────────────────────────────
+    function getMenuCtx() {
+        return {
+            phrenCtx: config.phrenCtx ? {
+                phrenPath: config.phrenCtx.phrenPath,
+                profile: config.phrenCtx.profile,
+                project: config.phrenCtx.project ?? undefined,
+            } : undefined,
+            w,
+            menuState,
+            menuListCount,
+            menuFilterActive,
+            menuFilterBuf,
+            onExit: () => {
+                tuiMode = "chat";
+                statusBar();
+                prompt();
+            },
+            onStateChange: (st, lc, fa, fb) => {
+                menuState = st;
+                menuListCount = lc;
+                menuFilterActive = fa;
+                menuFilterBuf = fb;
+            },
+        };
     }
     // Print status bar
     function statusBar() {
-        if (!isTTY)
-            return;
-        const bar = renderStatusBar(config.provider.name, config.phrenCtx?.project ?? null, session.turns, costStr, config.registry.permissionConfig.mode, spawner?.listAgents().length);
-        w.write(`${ESC}s${ESC}H${bar}${ESC}u`); // save cursor, move to top, print, restore
+        // Intentionally empty — no top status bar. Info is in the bottom prompt area.
     }
-    // Print prompt — bordered input bar at bottom
+    // Print prompt — inline input bar (written at current cursor position)
     let bashMode = false;
-    function prompt(skipNewline = false) {
+    // Track how many lines the bottom bar occupies so we can clear it on submit
+    const PROMPT_LINES = 4; // separator, input, separator, permissions
+    function prompt() {
         if (!isTTY)
             return;
         const mode = config.registry.permissionConfig.mode;
         const color = PERMISSION_COLORS[mode];
         const icon = PERMISSION_ICONS[mode];
-        const rows = process.stdout.rows || 24;
         const c = cols();
-        if (!skipNewline)
-            w.write("\n");
-        const sepLine = s.dim("─".repeat(c));
-        const permLine = `  ${color(`${icon} ${PERMISSION_LABELS[mode]} permissions`)} ${s.dim("(shift+tab to cycle)")}`;
-        w.write(`${ESC}${rows - 2};1H${ESC}2K${sepLine}`);
-        w.write(`${ESC}${rows - 1};1H${ESC}2K${permLine}`);
-        w.write(`${ESC}${rows};1H${ESC}2K${bashMode ? `${s.yellow("!")} ` : `${color(icon)} ${s.dim("▸")} `}`);
+        const sep = s.dim("─".repeat(c));
+        const permLine = `  ${color(`${icon} ${PERMISSION_LABELS[mode]} permissions`)} ${s.dim("(shift+tab toggle · esc to interrupt)")}`;
+        // Write inline — this naturally sits at the bottom
+        w.write(`${sep}\n`);
+        w.write(`${bashMode ? `${s.yellow("!")} ` : `${s.dim("▸")} `}`);
+        w.write(`\n${sep}\n`);
+        w.write(`${permLine}\n`);
+        // Move cursor back up to the input line
+        w.write(`${ESC}${PROMPT_LINES - 1}A`); // move up to input line
+        w.write(`${ESC}${bashMode ? 3 : 4}G`); // move to column after prompt char
+    }
+    // Redraw the input line and position the terminal cursor at cursorPos
+    function redrawInput() {
+        w.write(`${ESC}2K\r`);
+        w.write(`${bashMode ? `${s.yellow("!")} ` : `${s.dim("▸")} `}`);
+        w.write(inputLine);
+        // Move terminal cursor back from end to cursorPos
+        const back = inputLine.length - cursorPos;
+        if (back > 0)
+            w.write(`${ESC}${back}D`);
     }
+    // Periodic status bar refresh (every 30s) — keeps cost/turns current during long tool runs
+    const statusRefreshTimer = isTTY
+        ? setInterval(() => { if (tuiMode === "chat")
+            statusBar(); }, 30_000)
+        : null;
+    if (statusRefreshTimer)
+        statusRefreshTimer.unref(); // don't keep process alive
     // Terminal cleanup: restore state on exit
     function cleanupTerminal() {
+        if (statusRefreshTimer)
+            clearInterval(statusRefreshTimer);
         w.write("\x1b[?1049l"); // leave alt screen if active
         if (process.stdin.isTTY) {
             try {
@@ -229,6 +153,8 @@ export async function startTui(config, spawner) {
         }
     }
     process.on("exit", cleanupTerminal);
+    // Terminal resize: do nothing — scrollback text reflows naturally.
+    // The Ink TUI handles resize via React re-render. Legacy TUI just lets it be.
     // Setup: clear screen, status bar at top, content area clean
     if (isTTY) {
         w.write(`${ESC}2J${ESC}H`); // clear entire screen + home
@@ -249,7 +175,7 @@ export async function startTui(config, spawner) {
             `${s.dim(config.provider.name)}${project ? s.dim(` · ${project}`) : ""}`,
             `${s.dim(cwd)}`,
             ``,
-            `${permTag(permMode)} ${s.dim("permissions (shift+tab to cycle)")}`,
+            `${permTag(permMode)} ${s.dim("permissions (shift+tab toggle · esc to interrupt)")}`,
             ``,
             `${s.dim("Tab")} memory  ${s.dim("Shift+Tab")} perms  ${s.dim("/help")} cmds  ${s.dim("Ctrl+D")} exit`,
         ];
@@ -274,57 +200,6 @@ export async function startTui(config, spawner) {
     }
     let resolve = null;
     const done = new Promise((r) => { resolve = r; });
-    // ── Menu keypress handler ───────────────────────────────────────────────
-    async function handleMenuKeypress(key) {
-        // Filter input mode: capture text for / search
-        if (menuFilterActive) {
-            if (key.name === "escape") {
-                menuFilterActive = false;
-                menuFilterBuf = "";
-                menuState = { ...menuState, filter: undefined, cursor: 0, scroll: 0 };
-                renderMenu();
-                return;
-            }
-            if (key.name === "return") {
-                menuFilterActive = false;
-                menuState = { ...menuState, filter: menuFilterBuf || undefined, cursor: 0, scroll: 0 };
-                menuFilterBuf = "";
-                renderMenu();
-                return;
-            }
-            if (key.name === "backspace") {
-                menuFilterBuf = menuFilterBuf.slice(0, -1);
-                menuState = { ...menuState, filter: menuFilterBuf || undefined, cursor: 0 };
-                renderMenu();
-                return;
-            }
-            if (key.sequence && !key.ctrl && !key.meta) {
-                menuFilterBuf += key.sequence;
-                menuState = { ...menuState, filter: menuFilterBuf, cursor: 0 };
-                renderMenu();
-            }
-            return;
-        }
-        // "/" starts filter input
-        if (key.sequence === "/") {
-            menuFilterActive = true;
-            menuFilterBuf = "";
-            return;
-        }
-        const mod = await loadMenuModule();
-        if (!mod) {
-            exitMenuMode();
-            return;
-        }
-        const newState = mod.handleMenuKey(menuState, key.name ?? "", menuListCount, config.phrenCtx?.phrenPath, config.phrenCtx?.profile);
-        if (newState === null) {
-            exitMenuMode();
-        }
-        else {
-            menuState = newState;
-            renderMenu();
-        }
-    }
     // ── Keypress router ────────────────────────────────────────────────────
     process.stdin.on("keypress", (_ch, key) => {
         if (!key)
@@ -343,23 +218,104 @@ export async function startTui(config, spawner) {
             const next = nextPermissionMode(config.registry.permissionConfig.mode);
             config.registry.setPermissions({ ...config.registry.permissionConfig, mode: next });
             savePermissionMode(next);
-            // Just update bottom bar in-place — no scrollback output
-            prompt(true);
+            // Redraw the entire prompt bar in-place (permissions line changed)
+            w.write(`\r${ESC}J`); // clear from cursor to end of screen
+            prompt();
+            w.write(inputLine);
+            const back = inputLine.length - cursorPos;
+            if (back > 0)
+                w.write(`${ESC}${back}D`);
             return;
         }
-        // Tab — toggle mode (not during agent run or filter)
-        if (key.name === "tab" && !menuFilterActive) {
+        // Tab — completion or toggle mode
+        if (key.name === "tab" && !key.shift && !menuFilterActive) {
+            // Slash command completion in chat mode
+            if (tuiMode === "chat" && inputLine.startsWith("/")) {
+                const SLASH_COMMANDS = [
+                    "/help", "/model", "/provider", "/turns", "/clear", "/cost",
+                    "/plan", "/undo", "/history", "/compact", "/context", "/mode",
+                    "/spawn", "/agents", "/diff", "/git", "/files", "/cwd",
+                    "/preset", "/exit",
+                ];
+                const matches = SLASH_COMMANDS.filter((c) => c.startsWith(inputLine));
+                if (matches.length === 1) {
+                    inputLine = matches[0];
+                    cursorPos = inputLine.length;
+                    redrawInput();
+                }
+                else if (matches.length > 1) {
+                    // Show matches above prompt, then redraw
+                    w.write(`\r${ESC}J`); // clear from cursor to end of screen
+                    w.write(`\n${s.dim("  " + matches.join("  "))}\n`);
+                    prompt();
+                    w.write(inputLine);
+                    const back = inputLine.length - cursorPos;
+                    if (back > 0)
+                        w.write(`${ESC}${back}D`);
+                }
+                return;
+            }
+            // File path completion in bash mode
+            if (tuiMode === "chat" && bashMode && inputLine.length > 0) {
+                // Complete the last whitespace-delimited token as a path
+                const lastSpace = inputLine.lastIndexOf(" ");
+                const prefix = lastSpace === -1 ? "" : inputLine.slice(0, lastSpace + 1);
+                const partial = lastSpace === -1 ? inputLine : inputLine.slice(lastSpace + 1);
+                const expandedPartial = partial.replace(/^~/, os.homedir());
+                const dir = path.dirname(expandedPartial);
+                const base = path.basename(expandedPartial);
+                try {
+                    const entries = fs.readdirSync(dir, { withFileTypes: true });
+                    const matches = entries.filter((e) => e.name.startsWith(base));
+                    if (matches.length === 1) {
+                        const completed = matches[0];
+                        const fullPath = partial.startsWith("~")
+                            ? "~/" + path.relative(os.homedir(), path.join(dir, completed.name))
+                            : path.join(dir, completed.name);
+                        inputLine = prefix + fullPath + (completed.isDirectory() ? "/" : "");
+                        cursorPos = inputLine.length;
+                        redrawInput();
+                    }
+                    else if (matches.length > 1) {
+                        const names = matches.map((e) => e.name + (e.isDirectory() ? "/" : ""));
+                        w.write(`\r${ESC}J`); // clear from cursor to end of screen
+                        w.write(`\n${s.dim("  " + names.join("  "))}\n`);
+                        // Find longest common prefix for partial completion
+                        let common = matches[0].name;
+                        for (const m of matches) {
+                            while (!m.name.startsWith(common))
+                                common = common.slice(0, -1);
+                        }
+                        if (common.length > base.length) {
+                            const fullPath = partial.startsWith("~")
+                                ? "~/" + path.relative(os.homedir(), path.join(dir, common))
+                                : path.join(dir, common);
+                            inputLine = prefix + fullPath;
+                            cursorPos = inputLine.length;
+                        }
+                        prompt();
+                        w.write(inputLine);
+                        const back = inputLine.length - cursorPos;
+                        if (back > 0)
+                            w.write(`${ESC}${back}D`);
+                    }
+                }
+                catch { /* dir doesn't exist or unreadable */ }
+                return;
+            }
+            // Default: toggle menu mode
             if (tuiMode === "chat" && !running) {
-                enterMenuMode();
+                tuiMode = "menu";
+                enterMenu(getMenuCtx());
             }
             else if (tuiMode === "menu") {
-                exitMenuMode();
+                exitMenu(getMenuCtx());
             }
             return;
         }
         // Route to mode-specific handler
         if (tuiMode === "menu") {
-            handleMenuKeypress(key);
+            handleMenuKey(key, getMenuCtx());
             return;
         }
         // ── Chat mode keys ──────────────────────────────────────────────────
@@ -368,12 +324,14 @@ export async function startTui(config, spawner) {
             if (bashMode) {
                 bashMode = false;
                 inputLine = "";
-                prompt(true);
+                cursorPos = 0;
+                redrawInput();
                 return;
             }
             if (inputLine) {
                 inputLine = "";
-                prompt(true);
+                cursorPos = 0;
+                redrawInput();
                 return;
             }
         }
@@ -389,29 +347,32 @@ export async function startTui(config, spawner) {
             if (bashMode) {
                 bashMode = false;
                 inputLine = "";
-                prompt(true);
+                cursorPos = 0;
+                redrawInput();
                 ctrlCCount = 0;
                 return;
             }
             if (inputLine) {
                 // Clear input
                 inputLine = "";
-                prompt(true);
+                cursorPos = 0;
+                redrawInput();
                 ctrlCCount = 0;
                 return;
             }
             // Nothing to cancel — progressive quit
             ctrlCCount++;
             if (ctrlCCount === 1) {
+                // Clear current prompt, print warning, redraw prompt
+                w.write(`\r${ESC}J`);
                 w.write(s.dim("\n  Press Ctrl+C again to exit.\n"));
-                prompt(true);
+                prompt();
                 // Reset after 2 seconds
                 setTimeout(() => { ctrlCCount = 0; }, 2000);
             }
             else {
                 // Actually quit
-                if (process.stdin.isTTY)
-                    process.stdin.setRawMode(false);
+                cleanupTerminal();
                 w.write(s.dim("\nSession ended.\n"));
                 resolve(session);
             }
@@ -420,10 +381,10 @@ export async function startTui(config, spawner) {
         // Enter — submit
         if (key.name === "return") {
             const line = inputLine.trim();
+            cursorPos = 0;
             inputLine = "";
-            w.write("\n");
             if (!line) {
-                prompt();
+                redrawInput();
                 return;
             }
             // Push to history
@@ -441,7 +402,7 @@ export async function startTui(config, spawner) {
                     if (cdMatch) {
                         try {
                             const target = cdMatch[1].trim().replace(/^~/, os.homedir());
-                            const resolved = require("path").resolve(process.cwd(), target);
+                            const resolved = path.resolve(process.cwd(), target);
                             process.chdir(resolved);
                             w.write(s.dim(process.cwd()) + "\n");
                         }
@@ -473,39 +434,60 @@ export async function startTui(config, spawner) {
                 prompt();
                 return;
             }
-            if (handleCommand(line, {
+            const cmdResult = handleCommand(line, {
                 session,
                 contextLimit,
                 undoStack: [],
                 providerName: config.provider.name,
                 currentModel: config.provider.model,
+                provider: config.provider,
+                systemPrompt: config.systemPrompt,
                 spawner,
-                onModelChange: (result) => {
+                sessionId: config.sessionId,
+                startTime,
+                phrenPath: config.phrenCtx?.phrenPath,
+                phrenCtx: config.phrenCtx,
+                onModelChange: async (result) => {
                     // Live model switch — re-resolve provider with new model
                     try {
-                        const { resolveProvider } = require("./providers/resolve.js");
+                        const { resolveProvider } = await import("./providers/resolve.js");
                         const newProvider = resolveProvider(config.provider.name, result.model);
                         config.provider = newProvider;
                         // Rebuild system prompt with new model info
-                        const { buildSystemPrompt } = require("./system-prompt.js");
+                        const { buildSystemPrompt } = await import("./system-prompt.js");
                         config.systemPrompt = buildSystemPrompt(config.systemPrompt.split("\n## Last session")[0], // preserve context, strip old summary
                         null, { name: newProvider.name, model: result.model });
                         statusBar();
                     }
                     catch { /* keep current provider on error */ }
                 },
-            })) {
+            });
+            if (cmdResult === true) {
                 prompt();
                 return;
             }
-            // If agent is running, buffer input
+            if (typeof cmdResult === "object" && cmdResult instanceof Promise) {
+                cmdResult.then(() => { prompt(); });
+                return;
+            }
+            // If agent is running, add to steer queue
             if (running) {
-                pendingInput = line;
-                const label = inputMode === "steering" ? "steering" : "queued";
-                w.write(s.dim(`  ↳ ${label}: "${line.slice(0, 60)}"\n`));
+                if (inputMode === "steering") {
+                    steerQueue.push(line);
+                }
+                else {
+                    pendingInput = line;
+                }
+                // Show queued input above the thinking line
+                w.write(`${ESC}2K${s.dim(`  ↳ ${inputMode === "steering" ? "steer" : "queued"}: ${line.slice(0, 60)}`)}\n`);
                 return;
             }
-            // Run agent turn
+            // Clear input line, echo user input above prompt, redraw prompt
+            w.write(`\r${ESC}2K`); // clear input line
+            // Scroll up: move to line above prompt area, write content, redraw prompt
+            w.write(`${ESC}${PROMPT_LINES}A`); // move up past the prompt area
+            w.write(`${s.bold("❯")} ${line}\n`);
+            prompt(); // redraw prompt below
             runAgentTurn(line);
             return;
         }
@@ -521,9 +503,8 @@ export async function startTui(config, spawner) {
                 historyIndex--;
             }
             inputLine = inputHistory[historyIndex];
-            w.write(`${ESC}2K\r`);
-            prompt(true);
-            w.write(inputLine);
+            cursorPos = inputLine.length;
+            redrawInput();
             return;
         }
         // Down arrow — next history or restore saved
@@ -538,34 +519,128 @@ export async function startTui(config, spawner) {
                 historyIndex = -1;
                 inputLine = savedInput;
             }
-            w.write(`${ESC}2K\r`);
-            prompt(true);
-            w.write(inputLine);
+            cursorPos = inputLine.length;
+            redrawInput();
+            return;
+        }
+        // Ctrl+A — move cursor to start of line
+        if (key.ctrl && key.name === "a") {
+            cursorPos = 0;
+            redrawInput();
+            return;
+        }
+        // Ctrl+E — move cursor to end of line
+        if (key.ctrl && key.name === "e") {
+            cursorPos = inputLine.length;
+            redrawInput();
+            return;
+        }
+        // Ctrl+U — kill entire line
+        if (key.ctrl && key.name === "u") {
+            inputLine = "";
+            cursorPos = 0;
+            redrawInput();
+            return;
+        }
+        // Ctrl+K — kill from cursor to end of line
+        if (key.ctrl && key.name === "k") {
+            inputLine = inputLine.slice(0, cursorPos);
+            redrawInput();
+            return;
+        }
+        // Left arrow — move cursor left one character
+        if (key.name === "left" && !key.meta && !key.ctrl) {
+            if (cursorPos > 0) {
+                cursorPos--;
+                w.write(`${ESC}D`);
+            }
+            return;
+        }
+        // Right arrow — move cursor right one character
+        if (key.name === "right" && !key.meta && !key.ctrl) {
+            if (cursorPos < inputLine.length) {
+                cursorPos++;
+                w.write(`${ESC}C`);
+            }
+            return;
+        }
+        // Alt+Left — move cursor left by one word
+        if (key.name === "left" && (key.meta || key.ctrl)) {
+            if (cursorPos > 0) {
+                // Skip spaces, then skip non-spaces
+                let p = cursorPos;
+                while (p > 0 && inputLine[p - 1] === " ")
+                    p--;
+                while (p > 0 && inputLine[p - 1] !== " ")
+                    p--;
+                cursorPos = p;
+                redrawInput();
+            }
+            return;
+        }
+        // Alt+Right — move cursor right by one word
+        if (key.name === "right" && (key.meta || key.ctrl)) {
+            if (cursorPos < inputLine.length) {
+                let p = cursorPos;
+                while (p < inputLine.length && inputLine[p] !== " ")
+                    p++;
+                while (p < inputLine.length && inputLine[p] === " ")
+                    p++;
+                cursorPos = p;
+                redrawInput();
+            }
             return;
         }
-        // Backspace
+        // Word-delete: Alt+Backspace, Ctrl+Backspace, Ctrl+W
+        if (((key.meta || key.ctrl) && key.name === "backspace") ||
+            (key.ctrl && key.name === "w")) {
+            if (cursorPos > 0) {
+                // Find word boundary before cursor
+                let p = cursorPos;
+                while (p > 0 && inputLine[p - 1] === " ")
+                    p--;
+                while (p > 0 && inputLine[p - 1] !== " ")
+                    p--;
+                inputLine = inputLine.slice(0, p) + inputLine.slice(cursorPos);
+                cursorPos = p;
+                redrawInput();
+            }
+            return;
+        }
+        // Backspace — delete character before cursor
         if (key.name === "backspace") {
-            if (inputLine.length > 0) {
-                inputLine = inputLine.slice(0, -1);
-                w.write("\b \b");
+            if (cursorPos > 0) {
+                inputLine = inputLine.slice(0, cursorPos - 1) + inputLine.slice(cursorPos);
+                cursorPos--;
+                redrawInput();
+            }
+            return;
+        }
+        // Delete — delete character at cursor
+        if (key.name === "delete") {
+            if (cursorPos < inputLine.length) {
+                inputLine = inputLine.slice(0, cursorPos) + inputLine.slice(cursorPos + 1);
+                redrawInput();
             }
             return;
         }
-        // Regular character
+        // Regular character — insert at cursor position
         if (key.sequence && !key.ctrl && !key.meta) {
             // ! at start of empty input toggles bash mode
             if (key.sequence === "!" && inputLine === "" && !bashMode) {
                 bashMode = true;
-                prompt(true);
+                redrawInput();
                 return;
             }
-            inputLine += key.sequence;
-            w.write(key.sequence);
+            inputLine = inputLine.slice(0, cursorPos) + key.sequence + inputLine.slice(cursorPos);
+            cursorPos += key.sequence.length;
+            redrawInput();
         }
     });
     // TUI hooks — render streaming text with markdown, compact tool output
     let textBuffer = "";
     let firstDelta = true;
+    let activeThinkTimer = null;
     function flushTextBuffer() {
         if (!textBuffer)
             return;
@@ -575,24 +650,43 @@ export async function startTui(config, spawner) {
     const tuiHooks = {
         onTextDelta: (text) => {
             if (firstDelta) {
-                w.write(`${ESC}2K\r`); // clear thinking timer line
+                if (activeThinkTimer) {
+                    clearInterval(activeThinkTimer);
+                    activeThinkTimer = null;
+                }
+                w.write(`${ESC}2K\r`);
+                w.write(`\n${s.brand("◆")} `); // blank line + diamond prefix for phren's response
                 firstDelta = false;
             }
-            textBuffer += text;
-            // Flush on paragraph boundaries (double newline) or single newline for streaming feel
-            if (textBuffer.includes("\n\n") || textBuffer.endsWith("\n")) {
-                flushTextBuffer();
-            }
+            w.write(text);
         },
         onTextDone: () => {
             flushTextBuffer();
         },
         onTextBlock: (text) => {
-            w.write(renderMarkdown(text));
+            if (activeThinkTimer) {
+                clearInterval(activeThinkTimer);
+                activeThinkTimer = null;
+            }
+            if (firstDelta) {
+                w.write(`${ESC}2K\r`);
+                w.write(`\n${s.brand("◆")} `); // diamond prefix + blank line before response
+                firstDelta = false;
+            }
+            w.write(text);
             if (!text.endsWith("\n"))
                 w.write("\n");
         },
         onToolStart: (name, input, count) => {
+            // Kill the thinking animation if it's still running (tools can fire before any text delta)
+            if (activeThinkTimer) {
+                clearInterval(activeThinkTimer);
+                activeThinkTimer = null;
+            }
+            if (firstDelta) {
+                w.write(`${ESC}2K\r`); // clear thinking line
+                firstDelta = false;
+            }
             flushTextBuffer();
             const preview = formatToolInput(name, input);
             const countLabel = count > 1 ? s.dim(` (${count} tools)`) : "";
@@ -609,6 +703,12 @@ export async function startTui(config, spawner) {
         },
         onStatus: (msg) => w.write(s.dim(msg)),
         getSteeringInput: () => {
+            // Drain steer queue first (newest steering inputs)
+            if (steerQueue.length > 0 && inputMode === "steering") {
+                const steer = steerQueue.shift();
+                w.write(s.yellow(`  ↳ steering: ${steer}\n`));
+                return steer;
+            }
             if (pendingInput && inputMode === "steering") {
                 const steer = pendingInput;
                 pendingInput = null;
@@ -622,26 +722,52 @@ export async function startTui(config, spawner) {
         running = true;
         firstDelta = true;
         const thinkStart = Date.now();
-        const thinkTimer = setInterval(() => {
-            const elapsed = ((Date.now() - thinkStart) / 1000).toFixed(1);
-            w.write(`${ESC}2K  ${s.dim(`◌ thinking... ${elapsed}s`)}\r`);
-        }, 100);
+        // Phren thinking — subtle purple/cyan breath with rotating verbs
+        const THINK_VERBS = ["thinking", "reasoning", "recalling", "connecting", "processing"];
+        let thinkFrame = 0;
+        activeThinkTimer = setInterval(() => {
+            const elapsed = (Date.now() - thinkStart) / 1000;
+            const verb = THINK_VERBS[Math.floor(elapsed / 6) % THINK_VERBS.length];
+            const t = (Math.sin(thinkFrame * 0.08) + 1) / 2;
+            const r = Math.round(155 * (1 - t) + 40 * t);
+            const g = Math.round(140 * (1 - t) + 211 * t);
+            const b = Math.round(250 * (1 - t) + 242 * t);
+            const color = `${ESC}38;2;${r};${g};${b}m`;
+            w.write(`${ESC}2K${color}◆ ${verb}${ESC}0m ${s.dim(`${elapsed.toFixed(1)}s`)}\r`);
+            thinkFrame++;
+        }, 50);
         try {
             await runTurn(userInput, session, config, tuiHooks);
-            clearInterval(thinkTimer);
+            if (activeThinkTimer) {
+                clearInterval(activeThinkTimer);
+                activeThinkTimer = null;
+            }
+            const elapsed = ((Date.now() - thinkStart) / 1000).toFixed(1);
+            const DONE_VERBS = ["◆ recalled", "◆ processed", "◆ connected", "◆ resolved"];
+            const doneVerb = DONE_VERBS[session.turns % DONE_VERBS.length];
+            w.write(`${ESC}2K${s.dim(`${doneVerb} in ${elapsed}s`)}\n\n`);
             statusBar();
         }
         catch (err) {
-            clearInterval(thinkTimer);
+            if (activeThinkTimer) {
+                clearInterval(activeThinkTimer);
+                activeThinkTimer = null;
+            }
             const msg = err instanceof Error ? err.message : String(err);
             w.write(`${ESC}2K\r`);
             w.write(s.red(`  Error: ${msg}\n`));
         }
         running = false;
-        // Process queued input
-        if (pendingInput) {
+        // Process queued input — steer queue first, then pending
+        if (steerQueue.length > 0) {
+            const queued = steerQueue.shift();
+            w.write(`${s.bold("❯")} ${queued}\n`);
+            runAgentTurn(queued);
+        }
+        else if (pendingInput) {
             const queued = pendingInput;
             pendingInput = null;
+            w.write(`${s.bold("❯")} ${queued}\n`);
             runAgentTurn(queued);
         }
         else {