@phren/agent 0.1.1 → 0.1.3

package/dist/tui.js

@@ -9,6 +9,8 @@ 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";
@@ -46,6 +48,19 @@ const PERMISSION_LABELS = {
     "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] : "";
@@ -84,10 +99,9 @@ function formatDuration(ms) {
     return `${mins}m ${secs}s`;
 }
 function formatToolInput(name, input) {
-    // Show the most relevant input field for each tool type
     switch (name) {
-        case "read_file": return input.file_path ?? "";
-        case "write_file": return input.file_path ?? "";
+        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 ?? "";
@@ -132,10 +146,12 @@ export async function startTui(config, spawner) {
     const session = createSession(contextLimit);
     const w = process.stdout;
     const isTTY = process.stdout.isTTY;
+    const startTime = Date.now();
     let inputMode = loadInputMode();
     let pendingInput = null;
     let running = false;
     let inputLine = "";
+    let cursorPos = 0;
     let costStr = "";
     // ── Dual-mode state ─────────────────────────────────────────────────────
     let tuiMode = "chat";
@@ -149,6 +165,10 @@ export async function startTui(config, spawner) {
     let menuFilterActive = false;
     let menuFilterBuf = "";
     let ctrlCCount = 0;
+    // Input history
+    const inputHistory = [];
+    let historyIndex = -1;
+    let savedInput = "";
     // ── Menu rendering ─────────────────────────────────────────────────────
     async function renderMenu() {
         const mod = await loadMenuModule();
@@ -174,6 +194,7 @@ export async function startTui(config, spawner) {
         menuFilterActive = false;
         menuFilterBuf = "";
         w.write("\x1b[?1049l"); // leave alternate screen (restores chat)
+        setScrollRegion(); // re-establish scroll region after alt screen
         statusBar();
         prompt(true); // skip newline — alt screen restore already positioned cursor
     }
@@ -190,28 +211,69 @@ export async function startTui(config, spawner) {
         if (!isTTY)
             return;
         const mode = config.registry.permissionConfig.mode;
-        const modeIcon = mode === "full-auto" ? "●" : mode === "auto-confirm" ? "◐" : "○";
-        const modeColor = mode === "full-auto" ? s.yellow : mode === "auto-confirm" ? s.green : s.cyan;
+        const color = PERMISSION_COLORS[mode];
+        const icon = PERMISSION_ICONS[mode];
         const rows = process.stdout.rows || 24;
         const c = cols();
-        if (!skipNewline)
+        if (!skipNewline) {
+            // Newline within the scroll region so content scrolls up naturally
+            cursorToScrollEnd();
             w.write("\n");
-        // Separator line + prompt on last 2 rows
-        const permLabel = PERMISSION_LABELS[mode];
-        // 3 bottom rows: separator, permission line, input
-        const sepLine = s.dim("─".repeat(c));
-        const permLine = `  ${modeColor(`${modeIcon} ${permLabel} 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}`);
-        if (bashMode) {
-            w.write(`${ESC}${rows};1H${ESC}2K${s.yellow("!")} `);
-        }
-        else {
-            w.write(`${ESC}${rows};1H${ESC}2K${modeColor(modeIcon)} ${s.dim("▸")} `);
         }
+        // Draw the fixed bottom bar outside the scroll region.
+        // Temporarily reset DECSTBM so writes to rows (rows-4)..(rows) work.
+        w.write(`${ESC}r`); // reset scroll region temporarily
+        // Layout (bottom up): blank, permissions, separator, input, separator
+        const sep = s.dim("─".repeat(c));
+        const permLine = `  ${color(`${icon} ${PERMISSION_LABELS[mode]} permissions`)} ${s.dim("(shift+tab to cycle)")}`;
+        w.write(`${ESC}${rows - 4};1H${ESC}2K${sep}`);
+        w.write(`${ESC}${rows - 3};1H${ESC}2K${bashMode ? `${s.yellow("!")} ` : `${s.dim("▸")} `}`);
+        w.write(`${ESC}${rows - 2};1H${ESC}2K${sep}`);
+        w.write(`${ESC}${rows - 1};1H${ESC}2K${permLine}`);
+        w.write(`${ESC}${rows};1H${ESC}2K`); // blank bottom row
+        // Re-establish scroll region and position cursor at the input line
+        setScrollRegion();
+        w.write(`${ESC}${rows - 3};${bashMode ? 3 : 4}H`);
+    }
+    // Redraw the input line and position the terminal cursor at cursorPos
+    function redrawInput() {
+        w.write(`${ESC}2K\r`);
+        prompt(true);
+        w.write(inputLine);
+        // Move terminal cursor back from end to cursorPos
+        const back = inputLine.length - cursorPos;
+        if (back > 0)
+            w.write(`${ESC}${back}D`);
     }
+    // ── Scroll region management ─────────────────────────────────────────
+    // DECSTBM: rows 1..(rows-5) scroll; bottom 5 rows are fixed for the input bar.
+    function setScrollRegion() {
+        if (!isTTY)
+            return;
+        const rows = process.stdout.rows || 24;
+        const scrollBottom = Math.max(1, rows - 5);
+        w.write(`${ESC}1;${scrollBottom}r`);
+    }
+    // Move cursor to the bottom of the scroll region so new output scrolls naturally.
+    function cursorToScrollEnd() {
+        if (!isTTY)
+            return;
+        const rows = process.stdout.rows || 24;
+        const scrollBottom = Math.max(1, rows - 5);
+        w.write(`${ESC}${scrollBottom};1H`);
+    }
+    // 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(`${ESC}r`); // reset scroll region
         w.write("\x1b[?1049l"); // leave alt screen if active
         if (process.stdin.isTTY) {
             try {
@@ -221,6 +283,15 @@ export async function startTui(config, spawner) {
         }
     }
     process.on("exit", cleanupTerminal);
+    // Re-establish scroll region on terminal resize.
+    // Node's "resize" event already fires on SIGWINCH — no separate signal handler needed.
+    process.stdout.on("resize", () => {
+        if (tuiMode === "chat") {
+            setScrollRegion();
+            statusBar();
+            prompt(true);
+        }
+    });
     // Setup: clear screen, status bar at top, content area clean
     if (isTTY) {
         w.write(`${ESC}2J${ESC}H`); // clear entire screen + home
@@ -230,26 +301,23 @@ export async function startTui(config, spawner) {
         const project = config.phrenCtx?.project;
         const cwd = process.cwd().replace(os.homedir(), "~");
         const permMode = config.registry.permissionConfig.mode;
-        const modeColor = permMode === "full-auto" ? s.yellow : permMode === "auto-confirm" ? s.green : s.cyan;
-        // Try to show the phren character art alongside info
         let artLines = [];
         try {
             const { PHREN_ART } = await import("@phren/cli/phren-art");
             artLines = PHREN_ART.filter((l) => l.trim());
         }
         catch { /* art not available */ }
+        const info = [
+            `${s.brand("◆ phren agent")}  ${s.dim(`v${AGENT_VERSION}`)}`,
+            `${s.dim(config.provider.name)}${project ? s.dim(` · ${project}`) : ""}`,
+            `${s.dim(cwd)}`,
+            ``,
+            `${permTag(permMode)} ${s.dim("permissions (shift+tab to cycle)")}`,
+            ``,
+            `${s.dim("Tab")} memory  ${s.dim("Shift+Tab")} perms  ${s.dim("/help")} cmds  ${s.dim("Ctrl+D")} exit`,
+        ];
         if (artLines.length > 0) {
-            // Art on left, info on right
-            const info = [
-                `${s.brand("◆ phren agent")}  ${s.dim(`v${AGENT_VERSION}`)}`,
-                `${s.dim(config.provider.name)}${project ? s.dim(` · ${project}`) : ""}`,
-                `${s.dim(cwd)}`,
-                ``,
-                `${modeColor(`${permMode === "full-auto" ? "●" : permMode === "auto-confirm" ? "◐" : "○"} ${permMode}`)} ${s.dim("permissions (shift+tab to cycle)")}`,
-                ``,
-                `${s.dim("Tab")} memory  ${s.dim("Shift+Tab")} perms  ${s.dim("/help")} cmds  ${s.dim("Ctrl+D")} exit`,
-            ];
-            const maxArtWidth = 26; // phren art is ~24 chars wide
+            const maxArtWidth = 26;
             for (let i = 0; i < Math.max(artLines.length, info.length); i++) {
                 const artPart = i < artLines.length ? artLines[i] : "";
                 const infoPart = i < info.length ? info[i] : "";
@@ -258,13 +326,10 @@ export async function startTui(config, spawner) {
             }
         }
         else {
-            // Fallback: text-only banner
-            w.write(`\n  ${s.brand("◆ phren agent")}  ${s.dim(`v${AGENT_VERSION}`)}\n`);
-            w.write(`  ${s.dim(config.provider.name)}${project ? s.dim(` · ${project}`) : ""}  ${s.dim(cwd)}\n`);
-            w.write(`  ${modeColor(`${permMode === "full-auto" ? "●" : permMode === "auto-confirm" ? "◐" : "○"} ${permMode}`)} ${s.dim("permissions (shift+tab to cycle)")}\n\n`);
-            w.write(`  ${s.dim("Tab")} memory  ${s.dim("Shift+Tab")} perms  ${s.dim("/help")} cmds  ${s.dim("Ctrl+D")} exit\n\n`);
+            w.write(`\n  ${info[0]}\n  ${info[1]}  ${info[2]}\n  ${info[4]}\n\n  ${info[6]}\n\n`);
         }
         w.write("\n");
+        setScrollRegion(); // establish scroll region after banner
     }
     // Raw stdin for steering
     if (process.stdin.isTTY) {
@@ -339,20 +404,90 @@ export async function startTui(config, spawner) {
         }
         // Shift+Tab — cycle permission mode (works in chat mode, not during filter)
         if (key.shift && key.name === "tab" && !menuFilterActive && tuiMode === "chat") {
-            const current = config.registry.permissionConfig.mode;
-            const next = nextPermissionMode(current);
+            const next = nextPermissionMode(config.registry.permissionConfig.mode);
             config.registry.setPermissions({ ...config.registry.permissionConfig, mode: next });
             savePermissionMode(next);
-            const modeColor = next === "full-auto" ? s.yellow : next === "auto-confirm" ? s.green : s.cyan;
-            const modeIcon = next === "full-auto" ? "●" : next === "auto-confirm" ? "◐" : "○";
-            w.write(`  ${modeColor(`${modeIcon} ${next}`)}\n`);
-            statusBar();
-            if (!running)
-                prompt();
+            // Just update bottom bar in-place — no scrollback output
+            prompt(true);
             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 in scroll area, then redraw prompt
+                    cursorToScrollEnd();
+                    w.write(`\n${s.dim("  " + matches.join("  "))}\n`);
+                    prompt(true);
+                    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() ? "/" : ""));
+                        cursorToScrollEnd();
+                        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(true);
+                        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();
             }
@@ -372,11 +507,13 @@ export async function startTui(config, spawner) {
             if (bashMode) {
                 bashMode = false;
                 inputLine = "";
+                cursorPos = 0;
                 prompt(true);
                 return;
             }
             if (inputLine) {
                 inputLine = "";
+                cursorPos = 0;
                 prompt(true);
                 return;
             }
@@ -393,6 +530,7 @@ export async function startTui(config, spawner) {
             if (bashMode) {
                 bashMode = false;
                 inputLine = "";
+                cursorPos = 0;
                 prompt(true);
                 ctrlCCount = 0;
                 return;
@@ -400,6 +538,7 @@ export async function startTui(config, spawner) {
             if (inputLine) {
                 // Clear input
                 inputLine = "";
+                cursorPos = 0;
                 prompt(true);
                 ctrlCCount = 0;
                 return;
@@ -414,8 +553,7 @@ export async function startTui(config, spawner) {
             }
             else {
                 // Actually quit
-                if (process.stdin.isTTY)
-                    process.stdin.setRawMode(false);
+                cleanupTerminal();
                 w.write(s.dim("\nSession ended.\n"));
                 resolve(session);
             }
@@ -424,12 +562,20 @@ export async function startTui(config, spawner) {
         // Enter — submit
         if (key.name === "return") {
             const line = inputLine.trim();
+            cursorPos = 0;
             inputLine = "";
+            // Move to the bottom of the scroll region so new output scrolls naturally
+            cursorToScrollEnd();
             w.write("\n");
             if (!line) {
                 prompt();
                 return;
             }
+            // Push to history
+            if (inputHistory[inputHistory.length - 1] !== line) {
+                inputHistory.push(line);
+            }
+            historyIndex = -1;
             // Bash mode: ! prefix runs shell directly
             if (line.startsWith("!") || bashMode) {
                 const cmd = bashMode ? line : line.slice(1).trim();
@@ -472,17 +618,42 @@ 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,
-            })) {
+                sessionId: config.sessionId,
+                startTime,
+                phrenPath: config.phrenCtx?.phrenPath,
+                phrenCtx: config.phrenCtx,
+                onModelChange: (result) => {
+                    // Live model switch — re-resolve provider with new model
+                    try {
+                        const { resolveProvider } = require("./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");
+                        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 (typeof cmdResult === "object" && cmdResult instanceof Promise) {
+                cmdResult.then(() => { prompt(); });
+                return;
+            }
             // If agent is running, buffer input
             if (running) {
                 pendingInput = line;
@@ -494,15 +665,140 @@ export async function startTui(config, spawner) {
             runAgentTurn(line);
             return;
         }
-        // Backspace
+        // Up arrow — previous history
+        if (key.name === "up" && !running && tuiMode === "chat") {
+            if (inputHistory.length === 0)
+                return;
+            if (historyIndex === -1) {
+                savedInput = inputLine;
+                historyIndex = inputHistory.length - 1;
+            }
+            else if (historyIndex > 0) {
+                historyIndex--;
+            }
+            inputLine = inputHistory[historyIndex];
+            cursorPos = inputLine.length;
+            redrawInput();
+            return;
+        }
+        // Down arrow — next history or restore saved
+        if (key.name === "down" && !running && tuiMode === "chat") {
+            if (historyIndex === -1)
+                return;
+            if (historyIndex < inputHistory.length - 1) {
+                historyIndex++;
+                inputLine = inputHistory[historyIndex];
+            }
+            else {
+                historyIndex = -1;
+                inputLine = savedInput;
+            }
+            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;
+        }
+        // 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;
         }
-        // Regular character
+        // 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 — insert at cursor position
         if (key.sequence && !key.ctrl && !key.meta) {
             // ! at start of empty input toggles bash mode
             if (key.sequence === "!" && inputLine === "" && !bashMode) {
@@ -510,12 +806,14 @@ export async function startTui(config, spawner) {
                 prompt(true);
                 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;
     function flushTextBuffer() {
         if (!textBuffer)
             return;
@@ -524,11 +822,12 @@ export async function startTui(config, spawner) {
     }
     const tuiHooks = {
         onTextDelta: (text) => {
-            textBuffer += text;
-            // Flush on paragraph boundaries (double newline) or single newline for streaming feel
-            if (textBuffer.includes("\n\n") || textBuffer.endsWith("\n")) {
-                flushTextBuffer();
+            if (firstDelta) {
+                w.write(`${ESC}2K\r`); // clear thinking timer line
+                firstDelta = false;
             }
+            // Stream directly for real-time feel — write each delta immediately
+            w.write(text);
         },
         onTextDone: () => {
             flushTextBuffer();
@@ -566,13 +865,33 @@ export async function startTui(config, spawner) {
     };
     async function runAgentTurn(userInput) {
         running = true;
-        w.write(`${ESC}2K  ${s.dim("◌ thinking...")}\r`);
+        firstDelta = true;
+        cursorToScrollEnd(); // ensure all turn output stays within scroll region
+        const thinkStart = Date.now();
+        // Phren thinking — subtle purple/cyan breath, no spinner gimmicks
+        let thinkFrame = 0;
+        const thinkTimer = setInterval(() => {
+            const elapsed = (Date.now() - thinkStart) / 1000;
+            // Gentle sine-wave interpolation between phren purple and cyan
+            const t = (Math.sin(thinkFrame * 0.08) + 1) / 2; // 0..1, slow oscillation
+            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}◆ thinking${ESC}0m ${s.dim(`${elapsed.toFixed(1)}s`)}\r`);
+            thinkFrame++;
+        }, 50);
         try {
             await runTurn(userInput, session, config, tuiHooks);
+            clearInterval(thinkTimer);
+            const elapsed = ((Date.now() - thinkStart) / 1000).toFixed(1);
+            w.write(`${ESC}2K  ${s.dim(`◆ thought for ${elapsed}s`)}\n`);
             statusBar();
         }
         catch (err) {
+            clearInterval(thinkTimer);
             const msg = err instanceof Error ? err.message : String(err);
+            w.write(`${ESC}2K\r`);
             w.write(s.red(`  Error: ${msg}\n`));
         }
         running = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phren/agent",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Coding agent with persistent memory — powered by phren",
   "type": "module",
   "bin": {
@@ -13,7 +13,7 @@
     "dist"
   ],
   "dependencies": {
-    "@phren/cli": "0.1.1"
+    "@phren/cli": "0.1.3"
   },
   "engines": {
     "node": ">=20.0.0"