agen-vektor 0.3.7 → 0.3.8

package/README.md

@@ -12,30 +12,25 @@
 ```
 
 ```
-╭──────────────────────────────────────────────────────────────╮
-│ VectorHead ● Ready                         openrouter · deepseek/deepseek-chat │
-│ Project: ~/my-project                         Mode: ask        │
-├──────────────────────────────────────────────────────────────┤
-│                                                              │
-│ YOU                                                          │
-│ > Perbaiki error authentication pada project ini            │
-│                                                              │
-│ VectorHead                                                   │
-│ ● Inspecting project...                                      │
-│ ● Searching authentication files                             │
-│                                                              │
-│ TOOL                                                         │
-│ $ npm test                                                   │
-│                                                              │
-│ ✓ Tests passed                                               │
-│                                                              │
-├──────────────────────────────────────────────────────────────┤
-│ > _                                                          │
-├──────────────────────────────────────────────────────────────┤
-│ ENTER Send │ TAB Commands │ CTRL+C Stop │ ? Help             │
-╰──────────────────────────────────────────────────────────────╯
+VectorHead ● Ready                     custom · deepseek-ai/DeepSeek-V4-Flash
+Project: ~/my-project                         Mode: ask
+───────────────────────────────────────────────────────────────────────────────
+│ Perbaiki error authentication pada project ini
+VectorHead akan memeriksa file auth, memperbaiki, lalu menjalankan test.
+
+───────────────────────────────────────────────────────────────────────────────
+⚙ shell · $ npm test
+✓ Tests passed
+╭─────────────────────────────────────────────────────────────────────────────╮
+│  ▍ Enter a coding task or / for commands                                   │
+╰─────────────────────────────────────────────────────────────────────────────╯
+● Ready                                          ● ask
 ```
 
+A Freebuff-style terminal UI: chat history with a bold-white assistant line,
+compact agent-activity strip (⚙ tool calls), and a rounded input box with a
+block cursor and placeholder — all rendered incrementally with no flicker.
+
 ## Features
 
 - **Interactive TUI** — chat, agent status, tool execution, diff viewer, input. Keyboard driven, mouse-aware, works on 80×24 terminals and survives resize.
@@ -213,7 +208,6 @@ npm run build
 - Web search tool (provider-backed) behind the `web` abstraction
 - Interactive diff approval before edits in safe mode
 - Persistent permission rules per project
-- Publish under a dedicated npm package name for the VectorHead brand
 - Windows support (WSL-focused)
 
 ## License

package/dist/agent/agent.js

@@ -35,31 +35,41 @@ class Agent {
         ]);
     }
     async run(request, signal) {
-        return (0, loop_1.runAgentLoop)(request, {
+        return this.runLoop(request, [], signal);
+    }
+    /**
+     * Run continuing from a prior conversation (multi-turn continuity).
+     * The previous turn's messages are passed as history so the model
+     * remembers earlier exchanges instead of starting fresh every turn.
+     */
+    async runWithHistory(request, history, signal) {
+        return this.runLoop(request, history, signal);
+    }
+    async runLoop(request, history, signal) {
+        const result = await (0, loop_1.runAgentLoop)(request, {
             provider: this.provider,
             tools: this.tools,
             permissions: this.permissions,
             config: this.config,
             cwd: this.cwd,
             signal,
+            history,
         }, this.callbacks);
+        this.lastMessages = result.messages;
+        return result;
     }
     /**
      * Run with optional prior session messages (non-interactive continue).
-     * If sessionMessages is provided, the task is appended after the history.
+     * If sessionMessages is provided, the loop continues from that history.
      */
     async runWithContext(request, session, cb = {}) {
         this.setCallbacks(cb);
         if (!session)
             return this.run(request);
-        // Replay history into the loop by prefixing the task request.
-        const context = session.messages
-            .filter((m) => m.role === 'user' || m.role === 'assistant')
-            .slice(-30)
-            .map((m) => `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content.slice(0, 2000)}`)
-            .join('\n\n');
-        return this.run(`[Previous conversation summary]\n${context}\n\n---\n\nTASK:\n${request}`);
+        return this.runWithHistory(request, session.messages.filter((m) => m.role !== 'system').slice(-40));
     }
+    /** Raw messages of the most recent run (for cross-turn continuity). */
+    lastMessages = [];
     /** Rebuild the provider (e.g. after changing provider id). */
     rebuildProvider() {
         this.provider = (0, factory_1.createProvider)(this.config);

package/dist/agent/loop.js

@@ -18,13 +18,19 @@ const prompts_1 = require("./prompts");
 async function runAgentLoop(userRequest, opts, callbacks = {}) {
     const { provider, tools, permissions, config, cwd, signal } = opts;
     const maxIterations = config.maxIterations;
-    // Seed conversation with system + project context + task
+    // Seed conversation with system + project context + task.
+    // On a continuation (history present) the project context is not
+    // re-injected: the model already saw it in the first turn, and repeating
+    // the folder listing on every turn makes the agent re-explain/echo it.
+    const history = (opts.history ?? []).filter((m) => m.role !== 'system');
+    const isContinuation = history.length > 0;
+    const context = isContinuation
+        ? ''
+        : `${(0, context_1.buildProjectContext)(cwd)}\n\n${(0, context_1.listRootEntries)(cwd)}\n\n---\n\n`;
     const messages = [
         { role: 'system', content: prompts_1.SYSTEM_PROMPT },
-        {
-            role: 'user',
-            content: `${(0, context_1.buildProjectContext)(cwd)}\n\n${(0, context_1.listRootEntries)(cwd)}\n\n---\n\nTASK:\n${userRequest}`,
-        },
+        ...history,
+        { role: 'user', content: `${context}TASK:\n${userRequest}` },
     ];
     let iterations = 0;
     let toolCalls = 0;

package/dist/cli/index.js

@@ -23,6 +23,7 @@ const logger_1 = require("../utils/logger");
 const keyboard_1 = require("./keyboard");
 const terminal_1 = require("../utils/terminal");
 const session_1 = require("../agent/session");
+const paths_2 = require("../utils/paths");
 // Read version from package.json so --version always matches the published release.
 function getVersion() {
     try {
@@ -164,12 +165,29 @@ async function runNonInteractive(opts) {
             }
             console.log(`${terminal_1.ANSI.brightYellow}⚙ ${t}${terminal_1.ANSI.reset} ${terminal_1.ANSI.dim}${preview}${terminal_1.ANSI.reset}`);
         },
-        onDelta: (d) => process.stdout.write(d),
-        onFinal: () => process.stdout.write('\n'),
     });
+    // Print the final reply. The loop uses the non-streaming path, so the
+    // answer only arrives in result.content (never via onDelta).
+    const reply = result.content.trim();
+    if (reply) {
+        process.stdout.write(reply + '\n');
+    }
+    else if (result.stopped || result.aborted) {
+        console.log(`${terminal_1.ANSI.yellow}⏹ Stopped — no reply was produced.${terminal_1.ANSI.reset}`);
+    }
     console.log(`\n${terminal_1.ANSI.dim}— ${result.iterations} iterations, ${result.toolCalls} tool calls${terminal_1.ANSI.reset}`);
-    if (opts.sessionName) {
-        // persist
+    // Persist the conversation (per-project session by default) so the
+    // session is not lost after the run finishes.
+    try {
+        const name = opts.sessionName || defaultSessionName(agent.cwd);
+        (0, session_1.saveSession)(name, result.messages, {
+            cwd: agent.cwd,
+            model: agent.config.model,
+            provider: agent.config.provider,
+        });
+    }
+    catch {
+        /* ignore */
     }
     process.exit(0);
 }
@@ -193,6 +211,13 @@ function latestSessionName() {
     const sessions = (0, session_1.listSessions)();
     return sessions.length > 0 ? sessions[0].name : undefined;
 }
+/**
+ * Default session name: one persistent session per project directory,
+ * so conversations are never silently lost when no --session is given.
+ */
+function defaultSessionName(cwd) {
+    return (0, paths_2.sanitizeName)(cwd) || 'default';
+}
 async function runTui(opts) {
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
         await runNonInteractive(opts);
@@ -207,11 +232,15 @@ async function runTui(opts) {
         console.log(`${terminal_1.ANSI.yellow}⚠${terminal_1.ANSI.reset} No API key configured for provider "${config.provider}".\n` +
             `Set ${providerEnv(config.provider)} in your environment, or run /provider inside VectorHead to add one.\n`);
     }
-    // Resolve session name
+    // Resolve session name — default to a persistent per-project session so
+    // conversations are saved even when no --session flag is given.
     let sessionName = opts.sessionName;
     if (opts.continueSession && !sessionName) {
         sessionName = latestSessionName();
     }
+    if (!sessionName) {
+        sessionName = defaultSessionName(process.cwd());
+    }
     let exit = false;
     // Permission callback: drive a modal through the app
     let app = null;
@@ -243,9 +272,41 @@ async function runTui(opts) {
     });
     // Terminal setup
     const cleanup = (0, keyboard_1.enableRawMode)();
+    // Incremental renderer: keep the previous frame and only rewrite the rows
+    // that actually changed. Full-screen redraws every tick caused constant
+    // flicker, especially while the agent is running (spinner + timer animate
+    // every frame). Modal overlays are absolutely positioned, so they force a
+    // full repaint.
+    let lastFrameRows = [];
+    let lastCursorPos = '';
     const doRender = () => {
-        const out = app.render();
-        process.stdout.write(terminal_1.ANSI.hideCursor + out);
+        if (app.modalActive()) {
+            // A modal (e.g. a permission prompt) is static while open, so only
+            // repaint when something actually changed (open/close/keystroke).
+            // Full-screen redraws every tick while waiting for permission caused
+            // the chat to flicker during multi-tool turns.
+            if (app.isDirty()) {
+                lastFrameRows = [];
+                process.stdout.write(terminal_1.ANSI.hideCursor + app.render());
+                app.consumeRender();
+            }
+            return;
+        }
+        const snap = app.frameSnapshot();
+        const rows = snap.rows;
+        const out = [];
+        for (let i = 0; i < rows.length; i++) {
+            if (lastFrameRows[i] !== rows[i]) {
+                out.push((0, terminal_1.cursorTo)(i + 1, 1) + terminal_1.ANSI.clearLineEnd + rows[i]);
+            }
+        }
+        lastFrameRows = rows;
+        const cursor = (0, terminal_1.cursorTo)(snap.inputRow, snap.cursorCol);
+        if (cursor !== lastCursorPos)
+            out.push(cursor);
+        lastCursorPos = cursor;
+        out.push(terminal_1.ANSI.showCursor);
+        process.stdout.write(terminal_1.ANSI.hideCursor + out.join(''));
     };
     const onResize = () => {
         app.markDirty();

package/dist/providers/openai-compat.js

@@ -82,6 +82,17 @@ class OpenAICompatProvider {
         };
     }
     endpoint(path) {
+        if (!this.baseUrl) {
+            throw new provider_1.ProviderError('Custom API base URL is not set. Run /connect (or /setup) to enter it.', 0, false);
+        }
+        try {
+            const u = new URL(this.baseUrl);
+            if (u.protocol !== 'http:' && u.protocol !== 'https:')
+                throw new Error('not http');
+        }
+        catch {
+            throw new provider_1.ProviderError(`Invalid API base URL "${this.baseUrl}". Run /connect to fix it (e.g. https://host/v1).`, 0, false);
+        }
         return `${this.baseUrl}${path}`;
     }
     headers() {

package/dist/tui/app.js

@@ -81,6 +81,19 @@ class App {
     runStart = null;
     /** set on every mutation so the render loop only repaints when needed */
     dirty = true;
+    /**
+     * When true the chat view follows the newest messages. Disabled while the
+     * user scrolls up (PgUp); re-enabled when they scroll back to the bottom.
+     * Without this, new turns render below the visible area and replies to
+     * turns 2+ appear to "not respond".
+     */
+    followBottom = true;
+    /**
+     * Compact Freebuff-style activity strip: the current/last tool action
+     * (e.g. searching folders, running a command) shown above the input.
+     * Kept out of the main chat transcript so the conversation stays clean.
+     */
+    activity = null;
     constructor(agent, opts) {
         this.agent = agent;
         this.opts = opts;
@@ -184,10 +197,14 @@ class App {
                 break;
             case 'pageup':
                 this.scroll = (0, chat_1.clampScroll)(this.scroll - 10, this.messages, this.cols(), this.chatHeight());
+                this.followBottom = false;
                 break;
-            case 'pagedown':
+            case 'pagedown': {
                 this.scroll = (0, chat_1.clampScroll)(this.scroll + 10, this.messages, this.cols(), this.chatHeight());
+                const all = this.messages.length === 0 ? [] : (0, chat_1.renderMessages)(this.messages, this.cols());
+                this.followBottom = this.scroll >= Math.max(0, all.length - this.chatHeight());
                 break;
+            }
             case 'ctrl_u':
                 this.input.deleteToStart();
                 break;
@@ -203,6 +220,8 @@ class App {
             case 'ctrl_l':
                 this.messages = [];
                 this.scroll = 0;
+                this.followBottom = true;
+                this.activity = null;
                 this.addSystem('Conversation cleared.');
                 break;
             case 'ctrl_d':
@@ -252,6 +271,14 @@ class App {
         this.exitRequested = true;
     }
     // ─── Submission ───────────────────────────────────────────────
+    /** Snap the chat view to the newest messages (unless the user scrolled up). */
+    scrollToLatest() {
+        if (!this.followBottom)
+            return;
+        const { cols } = (0, terminal_1.getTerminalSize)();
+        const all = this.messages.length === 0 ? [] : (0, chat_1.renderMessages)(this.messages, cols);
+        this.scroll = Math.max(0, all.length - this.chatHeight());
+    }
     async submit(text) {
         this.markDirty();
         if (text.startsWith('/')) {
@@ -259,7 +286,8 @@ class App {
             return;
         }
         this.messages.push({ kind: 'user', content: text });
-        this.scroll = 0;
+        this.activity = null;
+        this.scrollToLatest();
         this.running = true;
         this.status = 'Thinking';
         this.statusColor = (0, theme_1.statusColor)('Thinking');
@@ -312,6 +340,7 @@ class App {
                 const m = this.messages[msgIndex];
                 if (m)
                     m.content += delta;
+                this.scrollToLatest();
             },
             onStatus: (status) => {
                 this.markDirty();
@@ -330,15 +359,13 @@ class App {
                 catch {
                     preview = args.slice(0, 80);
                 }
-                this.messages.push({ kind: 'tool', tool, content: `→ ${preview}` });
+                // Show tool activity in the compact strip, not the chat transcript.
+                this.activity = { tool, detail: preview };
             },
             onToolResult: (tool, result) => {
                 this.markDirty();
-                const last = this.messages[this.messages.length - 1];
-                if (last && last.kind === 'tool' && last.tool === tool) {
-                    last.content = result.split('\n').slice(0, 12).join('\n');
-                    if (result.split('\n').length > 12)
-                        last.content += '\n…';
+                if (this.activity && this.activity.tool === tool) {
+                    this.activity = { ...this.activity, result: result.split('\n').slice(0, 8).join('\n') };
                 }
             },
             onError: (err) => {
@@ -357,13 +384,17 @@ class App {
                     m.content = result.content || m.content;
                     m.streaming = false;
                 }
+                this.scrollToLatest();
             },
         });
+        let stoppedRun = false;
         try {
-            await this.agent.run(task, this.abortController?.signal);
+            const res = await this.agent.runWithHistory(task, this.agent.lastMessages.filter((m) => m.role !== 'system').slice(-40), this.abortController?.signal);
+            stoppedRun = res.stopped || res.aborted;
         }
         catch (err) {
             if (err.message === 'aborted') {
+                stoppedRun = true;
                 const m = this.messages[msgIndex];
                 if (m) {
                     m.content += '\n\n⏹ (stopped by user)';
@@ -383,8 +414,10 @@ class App {
             const m = this.messages[msgIndex];
             if (m) {
                 m.streaming = false;
-                if (!m.content.trim())
-                    m.content = '(no response)';
+                // Keep any partial reply; only fall back when there is nothing.
+                if (!m.content.trim()) {
+                    m.content = stoppedRun ? '⏹ (stopped — no reply)' : '(no response)';
+                }
             }
             this.running = false;
             this.runStart = null;
@@ -460,6 +493,8 @@ class App {
             case '/clear':
                 this.messages = [];
                 this.scroll = 0;
+                this.followBottom = true;
+                this.activity = null;
                 this.addSystem('Conversation cleared.');
                 break;
             case '/continue':
@@ -558,9 +593,12 @@ class App {
                 }
                 else if (ev.name === 'pageup') {
                     this.scroll = (0, chat_1.clampScroll)(this.scroll - 10, this.messages, this.cols(), this.chatHeight());
+                    this.followBottom = false;
                 }
                 else if (ev.name === 'pagedown') {
                     this.scroll = (0, chat_1.clampScroll)(this.scroll + 10, this.messages, this.cols(), this.chatHeight());
+                    const all = this.messages.length === 0 ? [] : (0, chat_1.renderMessages)(this.messages, this.cols());
+                    this.followBottom = this.scroll >= Math.max(0, all.length - this.chatHeight());
                 }
                 break;
             case 'provider':
@@ -671,14 +709,17 @@ class App {
             case 'apikey':
                 this.handleTextInput(ev, (value) => {
                     (0, credentials_1.setApiKey)(modal.provider, value);
+                    this.agent.rebuildProvider();
                     this.addSystem(`API key stored for ${modal.provider} (not printed).`);
                     this.modal = { type: 'none' };
                 });
                 break;
             case 'custom-url':
                 this.handleTextInput(ev, (value) => {
-                    this.agent.config.apiUrl = value;
+                    this.agent.config.apiUrl = value.trim();
                     (0, config_1.saveConfig)(this.agent.config);
+                    // Rebuild so the live provider picks up the new base URL
+                    this.agent.rebuildProvider();
                     this.addSystem('Custom API URL set.');
                     if (!(0, credentials_1.hasApiKey)('custom')) {
                         this.modal = { type: 'custom-key', value: '' };
@@ -690,7 +731,9 @@ class App {
                 break;
             case 'custom-key':
                 this.handleTextInput(ev, (value) => {
-                    (0, credentials_1.setApiKey)('custom', value);
+                    (0, credentials_1.setApiKey)('custom', value.trim());
+                    // Rebuild so the live provider picks up the new API key
+                    this.agent.rebuildProvider();
                     this.addSystem('Custom API key stored (not printed).');
                     this.modal = { type: 'none' };
                 });
@@ -737,6 +780,7 @@ class App {
     addSystem(text) {
         this.markDirty();
         this.messages.push({ kind: 'system', content: text });
+        this.scrollToLatest();
     }
     /** Show a permission modal (called by the permission callback). */
     setPermissionModal(req) {
@@ -756,15 +800,33 @@ class App {
     addTool(tool, content) {
         this.markDirty();
         this.messages.push({ kind: 'tool', tool, content });
+        this.scrollToLatest();
     }
     // ─── Rendering ────────────────────────────────────────────────
     cols() {
         return (0, terminal_1.getTerminalSize)().cols;
     }
+    /**
+     * Rows reserved for the activity strip above the input.
+     * FIXED at 3 while working (or while the last tool action is shown) so the
+     * chat area never resizes between tool calls — a dynamic height made the
+     * separator/chat reflow on every tool result, which looked like the screen
+     * blinking during multi-tool turns (e.g. "apakah vectorhead sehat").
+     */
+    activityHeight() {
+        return this.running || this.activity ? 3 : 0;
+    }
     chatHeight() {
-        return Math.max(1, (0, terminal_1.getTerminalSize)().rows - 6);
+        // Fixed rows: header(1) + project(1) + sep(1) + chatSep(1) + input box(3)
+        // + status(1) = 8, plus the activity strip when working.
+        return Math.max(1, (0, terminal_1.getTerminalSize)().rows - 8 - this.activityHeight());
     }
-    render() {
+    /**
+     * Compute the full frame as plain row strings (index 0 = terminal row 1)
+     * plus the input cursor position. Modal overlays are excluded (they are
+     * absolutely positioned and handled separately by render()).
+     */
+    computeFrame() {
         const { rows, cols } = (0, terminal_1.getTerminalSize)();
         const info = {
             status: this.status,
@@ -778,48 +840,77 @@ class App {
             running: this.running,
             elapsed: this.running && this.runStart !== null ? Math.floor((Date.now() - this.runStart) / 1000) : undefined,
         };
-        const parts = [];
-        // Row 1-2: header + project line
-        parts.push((0, terminal_1.cursorTo)(1, 1) + terminal_1.ANSI.clearLineEnd + (0, statusbar_1.renderHeader)(cols, info));
-        parts.push((0, terminal_1.cursorTo)(2, 1) + terminal_1.ANSI.clearLineEnd + (0, statusbar_1.renderProjectBar)(cols, info));
-        // Row 3: separator
-        parts.push((0, terminal_1.cursorTo)(3, 1) + terminal_1.ANSI.clearLineEnd + theme_1.THEME.border + terminal_1.BOX.h.repeat(Math.min(cols, 120)) + theme_1.THEME.reset);
-        // Chat area (rows 4..) — Freebuff-style message blocks (welcome screen when empty)
         const chatH = this.chatHeight();
         const all = this.messages.length === 0 ? (0, chat_1.renderWelcome)(cols, chatH, this.agent.cwd) : (0, chat_1.renderMessages)(this.messages, cols);
         const maxScroll = Math.max(0, all.length - chatH);
         this.scroll = Math.min(this.scroll, maxScroll);
         const visible = all.slice(this.scroll, this.scroll + chatH);
         const chatTop = 4;
-        for (let i = 0; i < chatH; i++) {
-            const content = visible[i] !== undefined ? visible[i] : '';
-            parts.push((0, terminal_1.cursorTo)(chatTop + i, 1) + terminal_1.ANSI.clearLineEnd + content);
-        }
-        // Separator between chat and input
         const sepRow = chatTop + chatH;
-        parts.push((0, terminal_1.cursorTo)(sepRow, 1) + terminal_1.ANSI.clearLineEnd + theme_1.THEME.border + terminal_1.BOX.h.repeat(Math.min(cols, 120)) + theme_1.THEME.reset);
-        // Input row
-        const inputRow = sepRow + 1;
-        const rendered = this.input.render(cols);
-        parts.push((0, terminal_1.cursorTo)(inputRow, 1) + terminal_1.ANSI.clearLineEnd + rendered.line);
+        const activityH = this.activityHeight();
+        // Freebuff-style rounded input box (3 rows: top border, content, bottom).
+        const boxTop = sepRow + activityH + 1;
+        const boxMid = boxTop + 1;
+        const boxBot = boxTop + 2;
+        const statusRow = boxBot + 1;
+        const rendered = this.input.render(cols, input_1.DEFAULT_PLACEHOLDER);
         const cursorCol = rendered.cursorCol + 1;
-        // Status bar row
-        const statusRow = inputRow + 1;
-        parts.push((0, terminal_1.cursorTo)(statusRow, 1) + terminal_1.ANSI.clearLineEnd + (0, statusbar_1.renderStatusBar)(cols, info));
-        // Modal overlay
+        // Inner width is cols - 2 (between the borders); pad to fill it exactly.
+        const padInner = Math.max(0, cols - 2 - (0, terminal_1.visibleWidth)(rendered.line));
+        const frame = new Array(rows).fill('');
+        frame[0] = (0, statusbar_1.renderHeader)(cols, info);
+        frame[1] = (0, statusbar_1.renderProjectBar)(cols, info);
+        frame[2] = theme_1.THEME.border + terminal_1.BOX.h.repeat(Math.min(cols, 120)) + theme_1.THEME.reset;
+        for (let i = 0; i < chatH; i++) {
+            frame[chatTop - 1 + i] = visible[i] !== undefined ? visible[i] : '';
+        }
+        frame[sepRow - 1] = theme_1.THEME.border + terminal_1.BOX.h.repeat(Math.min(cols, 120)) + theme_1.THEME.reset;
+        if (activityH > 0 && this.activity) {
+            const actRows = (0, statusbar_1.renderActivity)(this.activity, cols, activityH);
+            for (let i = 0; i < actRows.length; i++)
+                frame[sepRow + i] = actRows[i];
+        }
+        // Freebuff renders the input box border in the foreground color (white).
+        const boxBorder = `${theme_1.THEME.bold}${theme_1.THEME.textBright}`;
+        frame[boxTop - 1] = `${boxBorder}╭${terminal_1.BOX.h.repeat(Math.max(0, cols - 2))}╮${theme_1.THEME.reset}`;
+        frame[boxMid - 1] = `${boxBorder}│${theme_1.THEME.reset}${rendered.line}${' '.repeat(padInner)}${boxBorder}│${theme_1.THEME.reset}`;
+        frame[boxBot - 1] = `${boxBorder}╰${terminal_1.BOX.h.repeat(Math.max(0, cols - 2))}╯${theme_1.THEME.reset}`;
+        frame[statusRow - 1] = (0, statusbar_1.renderStatusBar)(cols, info);
+        return { rows: frame, inputRow: boxMid, cursorCol };
+    }
+    /** True while a modal overlay is shown (its rows are absolutely positioned). */
+    modalActive() {
+        return this.modal.type !== 'none';
+    }
+    /** True when a repaint is needed because something actually changed. */
+    isDirty() {
+        return this.dirty;
+    }
+    /**
+     * Frame snapshot for the CLI's incremental renderer: plain rows + cursor.
+     * The caller compares rows with the previous frame and only rewrites the
+     * changed lines — this is what eliminates the full-screen flicker.
+     */
+    frameSnapshot() {
+        return this.computeFrame();
+    }
+    render() {
+        const { rows, cols } = (0, terminal_1.getTerminalSize)();
+        const { rows: frame, inputRow, cursorCol } = this.computeFrame();
+        const parts = [];
+        for (let r = 0; r < rows; r++) {
+            parts.push((0, terminal_1.cursorTo)(r + 1, 1) + terminal_1.ANSI.clearLineEnd + frame[r]);
+        }
         if (this.modal.type !== 'none') {
             const overlay = this.renderModal(rows, cols);
             for (const l of overlay.lines)
                 parts.push(l);
+            parts.push(terminal_1.ANSI.hideCursor);
         }
-        // Cursor placement
-        if (this.modal.type === 'none') {
+        else {
             parts.push((0, terminal_1.cursorTo)(inputRow, cursorCol));
             parts.push(terminal_1.ANSI.showCursor);
         }
-        else {
-            parts.push(terminal_1.ANSI.hideCursor);
-        }
         return parts.join('');
     }
     renderModal(rows, cols) {

package/dist/tui/chat.js

@@ -83,13 +83,14 @@ function renderMessage(m, width) {
             out.push('');
             return out;
         default: {
-            // Assistant: plain foreground text (Freebuff style — no label).
+            // Assistant: bold white foreground so the conversation is clearly visible.
             const marker = m.streaming ? `${theme_1.THEME.info}◐ ${theme_1.THEME.reset}` : '';
             const lines = (0, terminal_1.wrapText)(body, width);
             if (lines.length === 0)
                 lines.push('(no content)');
+            const style = `${theme_1.THEME.bold}${theme_1.THEME.textBright}`;
             for (let i = 0; i < lines.length; i++) {
-                out.push(i === 0 ? `${marker}${lines[i]}` : lines[i]);
+                out.push(i === 0 ? `${marker}${style}${lines[i]}${theme_1.THEME.reset}` : `${style}${lines[i]}${theme_1.THEME.reset}`);
             }
             out.push('');
             return out;

package/dist/tui/input.js

@@ -1,20 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InputBox = void 0;
+exports.InputBox = exports.DEFAULT_PLACEHOLDER = void 0;
 /**
- * Input box — single-line text input with cursor, history, and hints.
+ * Input box — single-line text input with a Freebuff-style block cursor (▍)
+ * and placeholder, rendered inside a rounded border box.
  */
-const terminal_1 = require("../utils/terminal");
 const theme_1 = require("./theme");
+/** Freebuff-style placeholder shown while the input is empty. */
+exports.DEFAULT_PLACEHOLDER = 'Enter a coding task or / for commands';
 class InputBox {
     text = '';
     cursor = 0;
     history = [];
     historyIndex = -1;
-    hint = '';
-    setHint(hint) {
-        this.hint = hint;
-    }
     get value() {
         return this.text;
     }
@@ -96,30 +94,34 @@ class InputBox {
         }
         this.cursor = this.text.length;
     }
-    /** Render the input line, returns the cursor column (0-based within line). */
-    render(width) {
-        const prefix = `${theme_1.THEME.accent}❯${terminal_1.ANSI.reset} `;
-        const prefixWidth = 2; // ❯ + space (ANSI codes are invisible)
-        const available = Math.max(1, width - prefixWidth - 1);
-        let display = this.text;
-        let cursorCol = prefixWidth + this.cursor;
-        if (this.text.length > available) {
-            // Scroll window around the cursor
-            let start = this.cursor - Math.floor(available / 2);
-            start = Math.max(0, Math.min(start, this.text.length - available));
-            display = this.text.slice(start, start + available);
-            // Visible column: prefix width (2) + offset inside the window.
-            // (prefix.length is the raw ANSI byte length — must not be used here.)
-            cursorCol = prefixWidth + (this.cursor - start);
+    /**
+     * Render the input content line (between the box borders) with the ▍ block
+     * cursor. `width` is the full terminal row width; the returned `line` starts
+     * with 2 leading spaces (Freebuff style) and `cursorCol` is the 0-based
+     * column where the block cursor sits.
+     */
+    render(width, placeholder = exports.DEFAULT_PLACEHOLDER) {
+        const inner = Math.max(4, width - 2); // between the │ borders
+        const lead = 2; // spaces after the left border
+        const textW = Math.max(1, inner - lead - 1); // room for the text + right padding
+        let display;
+        let cursorCol;
+        if (!this.text) {
+            display = `${theme_1.THEME.accent}▍${theme_1.THEME.reset} ${theme_1.THEME.faint}${placeholder}${theme_1.THEME.reset}`;
+            cursorCol = lead; // the ▍ sits at column `lead`
         }
-        let suffix = '';
-        if (!this.text && this.hint) {
-            suffix = terminal_1.ANSI.dim + this.hint + terminal_1.ANSI.reset;
+        else {
+            // Window the text around the cursor when it overflows the box.
+            let start = 0;
+            if (this.text.length > textW) {
+                start = Math.max(0, Math.min(this.cursor - Math.floor(textW / 2), this.text.length - textW));
+            }
+            const visible = this.text.slice(start, start + textW);
+            const cur = Math.min(Math.max(0, this.cursor - start), visible.length);
+            display = `${visible.slice(0, cur)}${theme_1.THEME.accent}▍${theme_1.THEME.reset}${visible.slice(cur)}`;
+            cursorCol = lead + cur;
         }
-        return {
-            line: `${prefix}${display}${suffix}`,
-            cursorCol,
-        };
+        return { line: `${' '.repeat(lead)}${display}`, cursorCol };
     }
 }
 exports.InputBox = InputBox;

package/dist/tui/statusbar.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderHeader = renderHeader;
 exports.renderProjectBar = renderProjectBar;
+exports.renderActivity = renderActivity;
 exports.renderStatusBar = renderStatusBar;
 /**
  * Status bar — top header + project line + bottom status bar.
@@ -44,6 +45,28 @@ function renderProjectBar(width, info) {
     const mid = Math.max(1, width - (0, terminal_1.stripAnsi)(fit.left).length - (0, terminal_1.stripAnsi)(fit.right).length - 1);
     return theme_1.THEME.bgBar + (0, terminal_1.pad)(`${fit.left}${' '.repeat(mid)}${fit.right}`, width) + theme_1.THEME.reset;
 }
+/**
+ * Render the dedicated agent-activity strip (Freebuff-style): a compact
+ * block above the input showing the current/last tool action instead of
+ * flooding the main chat transcript with every tool call.
+ */
+function renderActivity(act, width, maxRows) {
+    const out = [];
+    const head = `${theme_1.THEME.warn}⚙${theme_1.THEME.reset} ${theme_1.THEME.bold}${act.tool}${theme_1.THEME.reset} ${theme_1.THEME.faint}${act.detail}${theme_1.THEME.reset}`;
+    for (const line of (0, terminal_1.wrapText)(head, Math.max(10, width - 2))) {
+        out.push(line);
+        if (out.length >= maxRows)
+            return out;
+    }
+    if (act.result) {
+        const lines = act.result.split('\n').filter((l) => l.trim());
+        const budget = Math.max(0, maxRows - out.length);
+        for (const rl of lines.slice(0, budget)) {
+            out.push(`${theme_1.THEME.faint}${rl.slice(0, Math.max(20, width - 4))}${theme_1.THEME.reset}`);
+        }
+    }
+    return out;
+}
 /** Render the bottom status bar: live status + spinner + elapsed timer. */
 function renderStatusBar(width, info) {
     const statusColorCode = (0, theme_1.statusColor)(info.status);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agen-vektor",
-  "version": "0.3.7",
+  "version": "0.3.8",
   "description": "VectorHead (agen-vektor) — AI Coding Agent CLI/TUI for Linux & Termux. Multi-provider, tool calling, session, permission system.",
   "type": "commonjs",
   "bin": {