agen-vektor 0.3.9 → 0.3.10

package/README.md

@@ -13,7 +13,6 @@
 
 ```
 VectorHead ● Ready                     deepseek-ai/DeepSeek-V4-Flash
-───────────────────────────────────────────────────────────────────────────────
 [09:41]
 Perbaiki error authentication pada project ini
 
@@ -56,13 +55,8 @@ Requirements: **Node.js 20+** and **npm** (Termux: `pkg install nodejs`).
 
 ### From source
 
-```bash
-git clone https://github.com/clickmamaheti-prog/vector-agent.git
-cd vector-agent
-npm install
-npm run build
-npm link          # makes `vector` available on PATH
-```
+Dari source: clone repo ini, lalu `npm install && npm run build && npm link`
+(membuat `vector` tersedia di PATH).
 
 Then:
 

package/dist/agent/agent.js

@@ -16,6 +16,7 @@ const loop_1 = require("./loop");
 const rules_1 = require("./rules");
 const skills_1 = require("./skills");
 const skills_tool_1 = require("../tools/skills-tool");
+const background_1 = require("../tools/background");
 class Agent {
     config;
     provider;
@@ -49,6 +50,9 @@ class Agent {
             (0, apply_patch_1.createApplyPatchTool)(),
             // Hermes-style progressive-disclosure skills (list_skills / read_skill).
             ...(0, skills_tool_1.createSkillTools)(),
+            // Parallelism: non-blocking background shell jobs (run_in_background /
+            // output_from_background / stop_background_job).
+            ...(0, background_1.createBackgroundTools)(),
         ]);
     }
     async run(request, signal) {

package/dist/agent/loop.js

@@ -190,25 +190,68 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
             toolCalls: result.toolCalls,
         });
         if (hasToolCalls) {
+            // Parallel execution for READ-ONLY tools (Freebuff-style: when the
+            // model requests several independent reads at once — read_file,
+            // search, glob — run them concurrently instead of one-by-one).
+            // Anything that mutates, prompts for permission, or starts background
+            // work stays sequential so side effects keep their order.
+            const PARALLEL_TOOLS = new Set([
+                'read_file',
+                'list_directory',
+                'search_files',
+                'glob',
+                'read_subtree',
+                'list_skills',
+                'output_from_background',
+            ]);
+            const runOne = async (tc) => {
+                callbacks.onToolCall?.(tc.name, tc.arguments, tc.id);
+                const toolResult = await tools.execute(tc.name, tc.arguments, {
+                    cwd,
+                    permissions,
+                    onActivity: callbacks.onActivity,
+                    maxOutput: 30_000,
+                });
+                return { tc, toolResult };
+            };
             try {
+                const batches = [];
+                let current = [];
                 for (const tc of result.toolCalls) {
+                    if (current.length > 0 && !PARALLEL_TOOLS.has(tc.name)) {
+                        batches.push(current);
+                        current = [];
+                    }
+                    current.push(tc);
+                    if (!PARALLEL_TOOLS.has(tc.name)) {
+                        batches.push(current);
+                        current = [];
+                    }
+                }
+                if (current.length > 0)
+                    batches.push(current);
+                for (const batch of batches) {
                     checkAbort();
-                    toolCalls++;
-                    callbacks.onToolCall?.(tc.name, tc.arguments);
-                    callbacks.onStatus?.(`Running ${tc.name}`);
-                    const toolResult = await tools.execute(tc.name, tc.arguments, {
-                        cwd,
-                        permissions,
-                        onActivity: callbacks.onActivity,
-                        maxOutput: 30_000,
-                    });
-                    callbacks.onToolResult?.(tc.name, toolResult.output, toolResult.data);
-                    messages.push({
-                        role: 'tool',
-                        toolCallId: tc.id,
-                        name: tc.name,
-                        content: toolResult.output.slice(0, 40_000),
-                    });
+                    const parallel = batch.length > 1 && batch.every((tc) => PARALLEL_TOOLS.has(tc.name));
+                    toolCalls += batch.length;
+                    if (!parallel) {
+                        callbacks.onStatus?.(`Running ${batch[0].name}`);
+                    }
+                    else {
+                        callbacks.onStatus?.(`Running ${batch.length}× ${batch[0].name} (parallel)`);
+                    }
+                    const results = parallel
+                        ? await Promise.all(batch.map(runOne))
+                        : [await runOne(batch[0])];
+                    for (const { tc, toolResult } of results) {
+                        callbacks.onToolResult?.(tc.name, toolResult.output, toolResult.data, tc.id);
+                        messages.push({
+                            role: 'tool',
+                            toolCallId: tc.id,
+                            name: tc.name,
+                            content: toolResult.output.slice(0, 40_000),
+                        });
+                    }
                 }
             }
             catch {

package/dist/cli/index.js

@@ -185,7 +185,11 @@ async function runNonInteractive(opts) {
     // answer only arrives in result.content (never via onDelta).
     const reply = result.content.trim();
     if (reply) {
-        process.stdout.write(reply + '\n');
+        // Freebuff appendInterruptionNotice: a user-interrupted run keeps its
+        // partial reply with the marker appended — non-interactive parity.
+        process.stdout.write(result.aborted && !reply.endsWith('[response interrupted]')
+            ? `${reply}\n\n[response interrupted]\n`
+            : reply + '\n');
     }
     else if (result.stopped || result.aborted) {
         console.log(`${terminal_1.ANSI.yellow}⏹ Stopped — no reply was produced.${terminal_1.ANSI.reset}`);

package/dist/config/providers.js

@@ -10,6 +10,7 @@ exports.customProviderPickerOptions = customProviderPickerOptions;
 exports.providerApiKey = providerApiKey;
 exports.isCustomProvider = isCustomProvider;
 exports.providerHeaders = providerHeaders;
+exports.providerBody = providerBody;
 exports.providerConfigured = providerConfigured;
 const credentials_1 = require("./credentials");
 /** Sentinel provider id meaning "add a brand new custom provider". */
@@ -128,6 +129,22 @@ function providerHeaders(config, id) {
     }
     return Object.keys(out).length > 0 ? out : undefined;
 }
+/**
+ * Resolve the extra request-body fields for a provider id (OpenCode-style
+ * per-provider options). Returns a shallow copy so callers cannot mutate the
+ * config; undefined when the definition carries no body overrides.
+ */
+function providerBody(config, id) {
+    const raw = customProviderDef(config, id)?.options?.body;
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return undefined;
+    const out = {};
+    for (const [k, v] of Object.entries(raw)) {
+        if (v !== undefined)
+            out[k] = v;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
 /**
  * Is a provider fully usable right now? Built-ins need a key (env or stored);
  * a legacy custom needs its apiUrl + key; a named custom needs a base URL in

package/dist/providers/custom.js

@@ -19,6 +19,7 @@ class CustomProvider extends openai_compat_1.OpenAICompatProvider {
             defaultModel: cfg.model || 'default',
             contextWindow: 128000,
             headers: cfg.headers,
+            body: cfg.body,
         });
         this.protocol = cfg.protocol;
     }

package/dist/providers/factory.js

@@ -72,6 +72,7 @@ function createProvider(config) {
                 model: config.model,
                 protocol: config.protocol || 'openai',
                 headers: (0, providers_1.providerHeaders)(config, pid),
+                body: (0, providers_1.providerBody)(config, pid),
             });
         }
     }

package/dist/providers/openai-compat.js

@@ -83,6 +83,8 @@ class OpenAICompatProvider {
     defaultModel;
     contextWindow;
     extraHeaders;
+    /** Provider-level request-body defaults (shallow-copied at construction). */
+    extraBody;
     constructor(opts) {
         this.id = opts.id;
         this.name = opts.name;
@@ -91,6 +93,7 @@ class OpenAICompatProvider {
         this.defaultModel = opts.defaultModel || 'gpt-4o-mini';
         this.contextWindow = opts.contextWindow || 128000;
         this.extraHeaders = opts.headers || {};
+        this.extraBody = { ...(opts.body || {}) };
     }
     capabilities() {
         return {
@@ -136,6 +139,12 @@ class OpenAICompatProvider {
         if (params.tools && params.tools.length > 0) {
             body.tools = toToolDefs(params.tools);
         }
+        // Provider-level body defaults FIRST (options.body — e.g. BitDeer's
+        // reasoning_effort), then the call-level fields on top: an explicit
+        // per-call temperature/max_tokens overrides the provider default.
+        for (const [k, v] of Object.entries(this.extraBody)) {
+            body[k] = v;
+        }
         if (params.temperature !== undefined)
             body.temperature = params.temperature;
         if (params.maxTokens)

package/dist/providers/openrouter.js

@@ -15,7 +15,7 @@ class OpenRouterProvider extends openai_compat_1.OpenAICompatProvider {
     }
     headers() {
         const h = super.headers();
-        h['HTTP-Referer'] = 'https://github.com/clickmamaheti-prog/vector-agent';
+        h['HTTP-Referer'] = 'https://www.npmjs.com/package/agen-vektor';
         h['X-Title'] = 'VectorHead AI Coding Agent';
         return h;
     }

package/dist/tools/background.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetBackgroundJobs = resetBackgroundJobs;
+exports.createBackgroundTools = createBackgroundTools;
+/**
+ * Background jobs — long-running shell commands that do NOT block the agent
+ * loop (Freebuff/Codebuff-style parallelism: start a dev server or a long
+ * test suite, keep working, poll the output, stop it when done).
+ *
+ *   run_in_background      → spawn now, return a job id immediately
+ *   output_from_background → status + NEW output since the last poll
+ *   stop_background_job    → SIGKILL the job
+ *
+ * The command goes through the SAME permission policy as the shell tool
+ * (classifyCommand → decide). Jobs live for the lifetime of the process;
+ * output buffers are capped (tail is kept).
+ */
+const node_child_process_1 = require("node:child_process");
+const MAX_LOG = 1_000_000; // keep the TAIL of huge outputs
+const jobs = new Map();
+let nextId = 1;
+/** Test helper: kill everything and reset ids. */
+function resetBackgroundJobs() {
+    for (const job of jobs.values()) {
+        if (job.timeoutTimer)
+            clearTimeout(job.timeoutTimer);
+        killTree(job);
+    }
+    jobs.clear();
+    nextId = 1;
+}
+/** Kill the job's whole process tree — the shell AND its grandchildren. */
+function killTree(job) {
+    const pid = job.child?.pid;
+    if (pid != null) {
+        try {
+            process.kill(-pid, 'SIGKILL'); // detached spawn ⇒ own process group
+        }
+        catch {
+            /* group already gone */
+        }
+    }
+    try {
+        job.child?.kill('SIGKILL');
+    }
+    catch {
+        /* already gone */
+    }
+}
+function trim(job) {
+    if (job.log.length > MAX_LOG) {
+        // keep the tail; shift the cursor so nothing unread is lost
+        const cut = job.log.length - MAX_LOG;
+        job.log = job.log.slice(cut);
+        job.readCursor = Math.max(0, job.readCursor - cut);
+    }
+}
+function describe(job) {
+    const secs = Math.round(((job.endedAt ?? Date.now()) - job.startedAt) / 1000);
+    const status = job.exitCode === null ? `RUNNING (${secs}s)` : job.killed ? `STOPPED after ${secs}s` : `EXITED ${job.exitCode} after ${secs}s`;
+    const fresh = job.log.slice(job.readCursor);
+    job.readCursor = job.log.length;
+    const tail = fresh.length > 20_000 ? `... [${fresh.length - 20_000} chars hidden] ${fresh.slice(-20_000)}` : fresh;
+    return `[${job.id}] ${status} — $ ${job.command}\n${tail || '(no output yet)'}`;
+}
+async function startJob(command, cwd, ctx, timeoutMs) {
+    const level = ctx.permissions.classifyCommand(command);
+    if (level === 'blocked') {
+        return {
+            output: `BLOCKED: command is not permitted by VectorHead security policy:\n${command}`,
+            summary: 'blocked by policy',
+        };
+    }
+    const allowed = await ctx.permissions.decide({ tool: 'shell', summary: `[background] ${command}`, level });
+    if (!allowed) {
+        return { output: `Permission denied by user:\n${command}`, summary: 'denied by user' };
+    }
+    const id = `bg${nextId++}`;
+    const child = (0, node_child_process_1.spawn)(command, {
+        cwd,
+        shell: '/bin/sh',
+        env: { ...process.env },
+        stdio: ['ignore', 'pipe', 'pipe'],
+        detached: true, // own process group → killTree can take down grandchildren
+    });
+    const job = {
+        id,
+        command,
+        child,
+        log: '',
+        readCursor: 0,
+        startedAt: Date.now(),
+        endedAt: null,
+        exitCode: null,
+        killed: false,
+        timeoutTimer: null,
+    };
+    jobs.set(id, job);
+    child.stdout?.on('data', (d) => {
+        job.log += d.toString();
+        trim(job);
+    });
+    child.stderr?.on('data', (d) => {
+        job.log += d.toString();
+        trim(job);
+    });
+    // 'exit' = the shell itself died; 'close' = shell AND stdio pipes closed.
+    // A grandchild (e.g. `sleep`) can hold the pipes open long after the shell
+    // is SIGKILLed, so the final status is recorded on 'exit' — not 'close'.
+    child.on('exit', (code) => {
+        if (job.exitCode === null)
+            job.exitCode = code ?? (job.killed ? -1 : 0);
+        if (job.endedAt === null)
+            job.endedAt = Date.now();
+    });
+    child.on('close', () => {
+        if (job.endedAt === null)
+            job.endedAt = Date.now();
+        job.child = null;
+        if (job.timeoutTimer)
+            clearTimeout(job.timeoutTimer);
+    });
+    child.on('error', (e) => {
+        job.log += `\n[spawn error] ${e.message}`;
+        trim(job);
+        job.exitCode = -1;
+        job.endedAt = Date.now();
+        job.child = null;
+    });
+    if (timeoutMs > 0) {
+        job.timeoutTimer = setTimeout(() => {
+            killTree(job);
+        }, timeoutMs);
+    }
+    return {
+        output: `Started background job ${id}: $ ${command}\nDo NOT wait for it — keep working. Check progress with output_from_background (id: "${id}", or omit for all jobs); stop it with stop_background_job.`,
+        summary: `[bg] started ${id}`,
+        data: { jobId: id },
+    };
+}
+function createBackgroundTools() {
+    return [
+        {
+            definition: {
+                name: 'run_in_background',
+                description: 'Start a shell command in the BACKGROUND and return immediately (non-blocking) — use for dev servers, watchers, long test suites, or anything that runs a while. You get a job id (e.g. bg1); keep working and poll progress with output_from_background, stop with stop_background_job. Do NOT use for quick commands — use shell instead.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        command: { type: 'string', description: 'The shell command to run in the background' },
+                        timeout_ms: { type: 'number', description: 'Optional kill-after timeout in ms (0 or omitted = run until stopped)' },
+                    },
+                    required: ['command'],
+                },
+            },
+            async execute(args, ctx) {
+                const command = String(args.command || '').trim();
+                if (!command)
+                    return { output: 'ERROR: empty command' };
+                ctx.onActivity?.('run_in_background', `[bg] $ ${command}`);
+                return startJob(command, ctx.cwd, ctx, Number(args.timeout_ms) || 0);
+            },
+        },
+        {
+            definition: {
+                name: 'output_from_background',
+                description: 'Read the status and NEW output of a background job started with run_in_background (everything since your last poll). Omit "id" to summarize ALL jobs. A RUNNING job may have partial output; EXITED <code> is finished.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', description: 'Job id from run_in_background (e.g. "bg1"); omit for all jobs' },
+                    },
+                    required: [],
+                },
+            },
+            async execute(args, ctx) {
+                ctx.onActivity?.('output_from_background', 'polling background jobs');
+                if (jobs.size === 0)
+                    return { output: 'No background jobs have been started.' };
+                const id = String(args.id || '').trim();
+                if (id) {
+                    const job = jobs.get(id);
+                    if (!job) {
+                        return { output: `ERROR: unknown background job "${id}". Running/known jobs: ${[...jobs.keys()].join(', ') || '(none)'}` };
+                    }
+                    return { output: describe(job), summary: `[bg] poll ${id}`, data: { jobId: id, exitCode: job.exitCode } };
+                }
+                return { output: [...jobs.values()].map((j) => describe(j)).join('\n\n'), summary: `[bg] poll all (${jobs.size})` };
+            },
+        },
+        {
+            definition: {
+                name: 'stop_background_job',
+                description: 'Stop (SIGKILL) a background job started with run_in_background. Use when the server/test/watch is no longer needed or is stuck.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', description: 'Job id from run_in_background (e.g. "bg1")' },
+                    },
+                    required: ['id'],
+                },
+            },
+            async execute(args, ctx) {
+                const id = String(args.id || '').trim();
+                const job = jobs.get(id);
+                if (!job)
+                    return { output: `ERROR: unknown background job "${id}"` };
+                ctx.onActivity?.('stop_background_job', `stopping ${id}`);
+                job.killed = true;
+                if (job.timeoutTimer)
+                    clearTimeout(job.timeoutTimer);
+                killTree(job);
+                return { output: `Stop signal sent to ${id} ($ ${job.command}). Poll output_from_background for its final output.`, summary: `[bg] stopped ${id}` };
+            },
+        },
+    ];
+}

package/dist/tui/app.js

@@ -39,7 +39,6 @@ exports.App = void 0;
  *
  * Layout (top to bottom):
  *   header      VectorHead ● status        model
- *   ───────────────────────────────────────────────
  *   chat        scrollable message area
  *   ───────────────────────────────────────────────
  *   suggestions  slash-command popup while typing /… (Freebuff-style)
@@ -157,6 +156,11 @@ class App {
     workingShinePos = 0;
     /** True once a terminal reply/error/stopped line was pushed this run. */
     replyHandled = false;
+    /** True once THIS run was aborted by the user (Freebuff wasAbortedByUser,
+     *  cli/src/hooks/helpers/send-message.ts): the abort handler owns the
+     *  interrupted UI — the completion path must not finalize a reply again
+     *  on top of the interruption notice. */
+    wasAbortedByUser = false;
     /**
      * Header status dot: bright↔dim pulse while idle/ready (blinking green),
      * solid while working, red when API tokens/quota are exhausted.
@@ -192,8 +196,10 @@ class App {
     /**
      * Freebuff-style interactive extras from the run: follow-up prompts the
      * model suggested (suggest_followups) and the latest render_ui button.
-     * Cleared at the START of every new run so a fresh task never inherits
-     * suggestions from an older reply.
+     * Freebuff parity: suggestions PERSIST and remain clickable across turns
+     * — the batch only stops being "active" when a NEWER suggest_followups
+     * arrives (which collapses the old one to "▸ Previously suggested
+     * followups").
      */
     activeFollowups = [];
     activeUiButton = null;
@@ -290,10 +296,15 @@ class App {
                     this.ctrlCArmed = false;
             }, App.CTRL_C_WINDOW_MS);
             if (this.running) {
+                this.wasAbortedByUser = true;
                 this.abortController?.abort();
                 this.status = 'Stopping…';
                 this.statusColor = terminal_1.ANSI.yellow;
                 this.running = false;
+                // Freebuff appendInterruptionNotice: the reply gets the
+                // "[response interrupted]" marker (appended to the partial reply,
+                // or standalone when nothing streamed) instead of a status line.
+                this.applyInterruptionNotice();
                 this.addSystem('⏹ Interrupted — press Ctrl+C once more within 2s to exit.');
             }
             else {
@@ -312,10 +323,12 @@ class App {
             // While running only Escape stops the agent (Ctrl+C is intercepted
             // above for the double-press exit); Ctrl+D stops and quits at once.
             if (ev.name === 'escape') {
+                this.wasAbortedByUser = true;
                 this.abortController?.abort();
                 this.status = 'Stopping…';
                 this.statusColor = terminal_1.ANSI.yellow;
                 this.running = false;
+                this.applyInterruptionNotice();
                 this.addSystem('⏹ Stopped.');
             }
             else if (ev.name === 'ctrl_d') {
@@ -369,6 +382,22 @@ class App {
                         this.markDirty();
                     }
                 }
+                else if (this.input.value.length === 0 && ev.char?.toLowerCase() === 'g') {
+                    // Freebuff suggest-followups.tsx: past batches render the
+                    // "▸ Previously suggested followups" toggle (▸/▾). Keyboard: 'g'
+                    // with an empty input flips every past batch (usually at most
+                    // one) between collapsed and expanded.
+                    let toggled = false;
+                    for (const m of this.messages) {
+                        const g = (0, chat_1.followupsGroupOf)(m);
+                        if (g?.past) {
+                            g.expanded = !g.expanded;
+                            toggled = true;
+                        }
+                    }
+                    if (toggled)
+                        this.markDirty();
+                }
                 else if (ev.char) {
                     this.input.insert(ev.char);
                     this.resetSuggest();
@@ -487,6 +516,7 @@ class App {
                 this.workingLine = null;
                 this.lastToolMsg = null;
                 this.replyBubble = null;
+                this.wasAbortedByUser = false;
                 this.thinkingMsg = null;
                 this.todoMsg = null;
                 this.todoSteps = [];
@@ -583,8 +613,10 @@ class App {
     requestExit() {
         this.markDirty();
         if (this.running) {
+            this.wasAbortedByUser = true;
             this.abortController?.abort();
             this.running = false;
+            this.applyInterruptionNotice();
         }
         this.exitRequested = true;
     }
@@ -603,9 +635,11 @@ class App {
             await this.handleCommand(text);
             return;
         }
-        // A new task resets the interactive extras (follow-ups / button) from
-        // the previous run.
-        this.activeFollowups = [];
+        // A new task resets the render_ui button, but NOT the follow-up
+        // suggestions: Freebuff keeps them "persist and remain clickable" —
+        // the digit keys still send them while the input is empty, and the
+        // batch only collapses to "▸ Previously suggested followups" when a
+        // NEWER suggest_followups tool call arrives.
         this.activeUiButton = null;
         this.messages.push({ kind: 'user', content: text, ts: Date.now() });
         this.activity = null;
@@ -1064,7 +1098,32 @@ class App {
             this.replyBubble = null;
         }
     }
+    /** Freebuff marker text (message-block-helpers.ts). */
+    static INTERRUPT_MARKER = '[response interrupted]';
+    /** Freebuff interruption flow (cli/src/hooks/helpers/send-message.ts abort
+     *  listener + appendInterruptionNotice): freeze the partial reply and
+     *  append "\n\n[response interrupted]" to the SAME bubble — or create a
+     *  standalone marker bubble when nothing streamed yet. No completion
+     *  timestamp (it is not a real reply — no stray [HH:MM] footer). */
+    applyInterruptionNotice() {
+        if (this.replyHandled)
+            return; // idempotent — never stack two markers
+        this.replyHandled = true;
+        const m = this.ensureReplyBubble();
+        if (!m)
+            return;
+        m.streaming = false;
+        m.content = m.content.trim()
+            ? `${m.content}\n\n${App.INTERRUPT_MARKER}`
+            : App.INTERRUPT_MARKER;
+        m.ts = undefined;
+        this.bubbleToEnd(m);
+        this.scrollToLatest();
+    }
     async runTask(text, planSteps) {
+        // Per-run interrupt flag (Freebuff wasAbortedByUser): set by the key
+        // handlers when they abort THIS run, consumed in the finally block.
+        this.wasAbortedByUser = false;
         const task = planSteps
             ? `TASK: ${text}\n\nFollow this plan:\n${planSteps.map((s, i) => `${i + 1}. ${s}`).join('\n')}`
             : text;
@@ -1112,6 +1171,11 @@ class App {
             },
             onDelta: (delta) => {
                 this.markDirty();
+                // Aborted mid-stream: the interrupt notice froze the partial reply —
+                // late deltas must not resurrect the streaming bubble after the
+                // "[response interrupted]" marker (Freebuff parity).
+                if (this.wasAbortedByUser)
+                    return;
                 // First visible text: the thinking phase is over — collapse the live
                 // thinking block to preview (default) and stop streaming it.
                 if (this.thinkingMsg) {
@@ -1139,8 +1203,11 @@ class App {
                 // working line never reads "Working — Thinking…".
                 this.showWorking('Working');
             },
-            onToolCall: (tool, args) => {
+            onToolCall: (tool, args, id) => {
                 this.markDirty();
+                // Aborted: no new tool lines may appear under the interrupt marker.
+                if (this.wasAbortedByUser)
+                    return;
                 // write_todos is rendered as the checklist itself (kind 'todo'), not
                 // as a tool line — the model owns it via write_todos, chat never
                 // gets one.
@@ -1224,13 +1291,30 @@ class App {
                 // Hold the message object (see the edit_file branch above): indexes
                 // shift when showWorking() splices the previous working line out.
                 const msg = { kind: 'tool', tool, content: preview, ts: Date.now() };
+                // Parallel tool calls (read-only batch): results arrive by
+                // toolCallId, so remember which transcript line owns this call.
+                if (id)
+                    msg.toolCallId = id;
                 this.messages.push(msg);
                 this.lastToolMsg = msg;
                 this.showWorking(`Working — ${(0, chat_1.toolIcon)(tool)} ${(0, chat_1.toolLabel)(tool)}`);
                 this.scrollToLatest();
             },
-            onToolResult: (tool, result, data) => {
+            onToolResult: (tool, result, data, id) => {
                 this.markDirty();
+                // Aborted: results of in-flight tools are dropped (Freebuff clears
+                // streaming agents in the abort listener) — the transcript stays as
+                // it was at the moment of the interrupt.
+                if (this.wasAbortedByUser)
+                    return;
+                // Resolve the owning tool line: by toolCallId first (parallel calls
+                // interleave), falling back to the last one (sequential unchanged).
+                let owner = this.lastToolMsg;
+                if (id) {
+                    const byId = [...this.messages].reverse().find((m) => m.kind === 'tool' && m.toolCallId === id);
+                    if (byId)
+                        owner = byId;
+                }
                 // write_todos: the model's own checklist state is the source of
                 // truth — sync ☐/☑ from the returned data, never tick via the
                 // fallback per-tool bump (that is for plans executed directly).
@@ -1246,7 +1330,7 @@ class App {
                 // Edit cards: attach the unified diff computed from the old/new
                 // file snapshots the tools return in `data` (Freebuff extractDiff
                 // equivalent). Errors keep the header-only card.
-                const editMsg = this.lastToolMsg;
+                const editMsg = owner;
                 if (editMsg?.edit && (tool === 'edit_file' || tool === 'write_file')) {
                     const d = (data ?? {});
                     if (typeof d.oldContent === 'string' && typeof d.newContent === 'string') {
@@ -1262,7 +1346,7 @@ class App {
                 // Shell cards: attach the output (last-3-lines tail renders under
                 // the `$ command` header — Freebuff terminal-command-display). The
                 // LLM-facing result keeps its full `exit N` + output form.
-                if (tool === 'shell' && this.lastToolMsg?.kind === 'tool' && this.lastToolMsg.shell) {
+                if (tool === 'shell' && owner?.kind === 'tool' && owner.shell) {
                     const d = (data ?? {});
                     const parts = [];
                     if (typeof d.stdout === 'string' && d.stdout.trim())
@@ -1270,8 +1354,8 @@ class App {
                     if (typeof d.stderr === 'string' && d.stderr.trim())
                         parts.push(`[stderr]\n${d.stderr.replace(/\r\n?/g, '\n').trimEnd()}`);
                     const output = parts.join('\n').slice(0, 4_000);
-                    this.lastToolMsg.shell.output = output || undefined;
-                    this.lastToolMsg.shell.noOutput = !output;
+                    owner.shell.output = output || undefined;
+                    owner.shell.noOutput = !output;
                     this.markDirty();
                     return;
                 }
@@ -1282,8 +1366,8 @@ class App {
                         .slice(0, 3)
                         .join('\n')
                         .slice(0, 300);
-                    if (lines.trim())
-                        this.lastToolMsg.content += `\n${lines}`;
+                    if (lines.trim() && owner?.kind === 'tool')
+                        owner.content += `\n${lines}`;
                 }
                 // Freebuff-style interactive extras: suggest_followups hands back a
                 // structured list of clickable prompts, render_ui a button widget.
@@ -1294,8 +1378,21 @@ class App {
                 if (tool === 'suggest_followups' && data && Array.isArray(data.followups)) {
                     const list = data.followups.slice(0, 3);
                     this.activeFollowups = list;
+                    // Freebuff suggest-followups.tsx: only the LATEST batch is active
+                    // (isActive = latestFollowupToolCallId === toolCallId) — a newer
+                    // batch collapses every older one to the "▸ Previously suggested
+                    // followups" toggle. The batch hangs off ONE group object shared
+                    // by every row of this tool call.
+                    for (const m of this.messages) {
+                        const g = (0, chat_1.followupsGroupOf)(m);
+                        if (g && !g.past) {
+                            g.past = true;
+                            g.expanded = false;
+                        }
+                    }
+                    const group = { followups: list };
                     for (const f of list) {
-                        this.messages.push({ kind: 'followup', content: f.prompt, followup: f, ts: Date.now() });
+                        this.messages.push({ kind: 'followup', content: f.prompt, followup: f, followupsGroup: group, ts: Date.now() });
                     }
                 }
                 if (tool === 'render_ui' && data && data.widget) {
@@ -1372,7 +1469,13 @@ class App {
             this.replyHandled = true;
             if (err.message === 'aborted') {
                 stoppedRun = true;
-                this.messages.push({ kind: 'system', content: '⏹ (stopped by user)', ts: Date.now() });
+                // User interrupt: the reply bubble already carries the Freebuff
+                // "[response interrupted]" notice — no extra system line. A false
+                // flag here means the provider threw AbortError on its own
+                // (timeout): keep the legacy notice for that rare path.
+                if (!this.wasAbortedByUser) {
+                    this.messages.push({ kind: 'system', content: '⏹ (stopped by user)', ts: Date.now() });
+                }
             }
             else {
                 this.messages.push({ kind: 'error', content: `⚠️ ${err.message}`, ts: Date.now() });
@@ -1388,6 +1491,12 @@ class App {
             this.markDirty();
             // A run stopped mid-reasoning: finalize (or drop) the thinking block.
             this.finalizeThinkingBlock();
+            // Freebuff handleRunCompletion: when the USER aborted, the abort
+            // handler already finalized the UI (partial reply + the
+            // "[response interrupted]" notice) — don't finalize again on top.
+            if (this.wasAbortedByUser) {
+                this.replyHandled = true;
+            }
             // Freebuff ordering: the reply bubble lands after all activity lines.
             if (!this.replyHandled) {
                 const m = this.ensureReplyBubble();
@@ -1413,6 +1522,7 @@ class App {
             this.lastToolMsg = null;
             this.replyBubble = null;
             this.replyHandled = false;
+            this.wasAbortedByUser = false;
             this.running = false;
             this.runStart = null;
             // Re-snap to the REAL bottom: the transient Working bubble made the
@@ -1612,6 +1722,7 @@ class App {
                 this.workingLine = null;
                 this.lastToolMsg = null;
                 this.replyBubble = null;
+                this.wasAbortedByUser = false;
                 this.thinkingMsg = null;
                 this.todoMsg = null;
                 this.todoSteps = [];
@@ -1637,6 +1748,7 @@ class App {
                 this.lastToolMsg = null;
                 this.replyBubble = null;
                 this.replyHandled = false;
+                this.wasAbortedByUser = false;
                 this.todoMsg = null;
                 this.todoSteps = [];
                 this.todoDone = 0;
@@ -2265,11 +2377,11 @@ class App {
         this.suggestDismissed = false;
     }
     chatHeight() {
-        // Fixed rows: header(1) + sep(1) + chatSep(1) + input box(5 — Freebuff
+        // Fixed rows: header(1) + chatSep(1) + input box(5 — Freebuff
         // chat-input-bar: content area minHeight 3 with the input vertically
-        // centered) + status(1) = 9, plus the activity strip when working and
+        // centered) + status(1) = 8, plus the activity strip when working and
         // the slash suggestion popup when typing a command.
-        return Math.max(1, (0, terminal_1.getTerminalSize)().rows - 9 - this.activityHeight() - this.suggestHeight());
+        return Math.max(1, (0, terminal_1.getTerminalSize)().rows - 8 - this.activityHeight() - this.suggestHeight());
     }
     /**
      * Compute the full frame as plain row strings (index 0 = terminal row 1)
@@ -2321,7 +2433,7 @@ class App {
         // input sits directly under the last content line). Scrolling up switches
         // back to classic top-anchored paging.
         const visible = (0, chat_1.chatWindow)(all, this.scroll, chatH);
-        const chatTop = 3;
+        const chatTop = 2;
         const sepRow = chatTop + chatH;
         const toolRows = this.toolPanelRows(cols);
         const activityH = toolRows.length > 0 ? toolRows.length + 2 : 0;
@@ -2341,7 +2453,6 @@ class App {
         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] = 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] : '';
         }

package/dist/tui/chat.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LOGO_SHEEN_MAX = exports.LOGO_SHEEN_INTERVAL_MS = exports.LOGO_SHEEN_STEP = exports.LOGO_FULL_MIN_COLS = void 0;
+exports.LOGO_SHEEN_MAX = exports.LOGO_SHEEN_INTERVAL_MS = exports.LOGO_SHEEN_STEP = exports.LOGO_FULL_MIN_COLS = exports.SIDE_GUTTER = void 0;
 exports.toolIcon = toolIcon;
 exports.toolLabel = toolLabel;
+exports.followupsGroupOf = followupsGroupOf;
 exports.mergeStreamDelta = mergeStreamDelta;
 exports.renderMessages = renderMessages;
 exports.chatWindow = chatWindow;
@@ -120,6 +121,13 @@ const TOOL_LABELS = {
 function toolLabel(tool) {
     return (tool && TOOL_LABELS[tool]) || tool || 'tool';
 }
+/** The suggest_followups batch carried by a 'followup' message, if any. */
+function followupsGroupOf(m) {
+    if (m.kind !== 'followup')
+        return undefined;
+    const g = m.followupsGroup;
+    return g && Array.isArray(g.followups) ? g : undefined;
+}
 /** Center a string (with ANSI) horizontally within `width`. */
 function center(str, width) {
     const pad = Math.max(0, Math.floor((width - (0, terminal_1.visibleWidth)(str)) / 2));
@@ -130,6 +138,64 @@ function fmtClock(ts) {
     const d = new Date(ts);
     return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`;
 }
+/**
+ * EXACT port of Freebuff `getLastNVisualLines` (cli/src/utils/text-layout.ts):
+ * word-wrap `text` to `cols` visible columns and return the LAST n visual
+ * lines plus whether earlier lines were cut (→ the '...' prefix). Used by
+ * the thinking card so the 5-line preview matches Freebuff byte-for-byte.
+ */
+function getLastNVisualLines(text, cols, n) {
+    if (n <= 0 || cols <= 0)
+        return { lines: [], hasMore: false };
+    const lines = [];
+    if (!text)
+        return { lines, hasMore: false };
+    const tokens = text.split(/(\s+)/);
+    let current = '';
+    let currentWidth = 0;
+    const pushLine = () => {
+        lines.push(current);
+        current = '';
+        currentWidth = 0;
+    };
+    const appendSegment = (segment) => {
+        if (!segment)
+            return;
+        const segWidth = (0, terminal_1.visibleWidth)(segment);
+        if (segWidth > cols) {
+            for (const ch of Array.from(segment)) {
+                const w = (0, terminal_1.visibleWidth)(ch);
+                if (currentWidth + w > cols)
+                    pushLine();
+                current += ch;
+                currentWidth += w;
+            }
+            return;
+        }
+        if (currentWidth + segWidth > cols)
+            pushLine();
+        current += segment;
+        currentWidth += segWidth;
+    };
+    for (const token of tokens) {
+        if (!token)
+            continue;
+        if (token.includes('\n')) {
+            const parts = token.split('\n');
+            for (let i = 0; i < parts.length; i++) {
+                appendSegment(parts[i]);
+                if (i < parts.length - 1)
+                    pushLine();
+            }
+            continue;
+        }
+        appendSegment(token);
+    }
+    if (current.length > 0 || lines.length === 0)
+        pushLine();
+    const hasMore = lines.length > n;
+    return { lines: lines.slice(-n), hasMore };
+}
 /**
  * Wrap a stream of styled chunks to `width`, breaking at spaces (or hard
  * newlines) while preserving each chunk's style — unlike wrapText on a
@@ -528,38 +594,57 @@ function inlineStyle(seg) {
  * yellow (Freebuff paints header cells with headingFg[3]), body cells
  * plain, cell content word-wrapped, columns sized to content and
  * proportionally shrunk (min 3 cols each) when the table exceeds width.
+ *
+ * The grid must NEVER exceed `width`: every row costs ΣcolW + 3·numCols + 1
+ * visible columns (corner + per column (w+2) fill + one junction each),
+ * so column widths are budgeted to ΣcolW ≤ width − 3·numCols − 1. A wider
+ * row wraps on the terminal and shoves the whole screen down a line on
+ * every repaint (the "layar bergerak liar" / jitter bug).
  */
 function renderTableBlock(seg, width) {
     const rows = [seg.header, ...seg.rows];
     const numCols = Math.max(...rows.map((r) => r.length), 1);
-    const separatorWidth = 3; // ' │ '
-    // Grid rows cost ΣcolW + 3·numCols + 1 visible columns (per-cell padding
-    // 'x2 plus a │ border per cell AND at both ends), so budget width-4 of
-    // content to guarantee the grid never exceeds the terminal width.
-    const availableWidth = Math.max(20, width - 4);
     const naturalWidths = Array.from({ length: numCols }, () => 3);
     for (const row of rows) {
         for (let i = 0; i < numCols; i++) {
             naturalWidths[i] = Math.max(naturalWidths[i], (0, terminal_1.visibleWidth)(row[i] ?? ''));
         }
     }
-    const numSeparators = numCols - 1;
-    const totalNaturalWidth = naturalWidths.reduce((a, b) => a + b, 0) + numSeparators * separatorWidth;
+    const budget = width - (3 * numCols + 1); // max ΣcolumnWidths that fits
+    const totalNatural = naturalWidths.reduce((a, b) => a + b, 0);
     let columnWidths;
-    if (totalNaturalWidth <= availableWidth) {
+    if (totalNatural <= budget) {
         columnWidths = naturalWidths.slice();
     }
+    else if (budget < numCols * 3) {
+        // Too narrow even for 3-column cells: shrink evenly (min 1).
+        const per = Math.max(1, Math.floor(budget / numCols));
+        columnWidths = Array.from({ length: numCols }, () => per);
+    }
     else {
-        const availableForContent = availableWidth - numSeparators * separatorWidth;
-        const totalNaturalContent = naturalWidths.reduce((a, b) => a + b, 0);
-        const scale = availableForContent / Math.max(1, totalNaturalContent);
+        const scale = budget / Math.max(1, totalNatural);
         columnWidths = naturalWidths.map((w) => Math.max(3, Math.floor(w * scale)));
-        let remaining = availableForContent - columnWidths.reduce((a, b) => a + b, 0);
-        for (let i = 0; i < columnWidths.length && remaining > 0; i++) {
-            if (columnWidths[i] < naturalWidths[i]) {
-                const add = Math.min(remaining, naturalWidths[i] - columnWidths[i]);
-                columnWidths[i] += add;
-                remaining -= add;
+        // Scale floors + the 3-col minimum can land above or below the budget:
+        // trim the widest columns (never below 3) or give leftovers back to the
+        // columns that were shrunk most, so ΣcolumnWidths fits exactly.
+        const order = columnWidths.map((_, i) => i).sort((x, y) => columnWidths[y] - columnWidths[x]);
+        let diff = budget - columnWidths.reduce((a, b) => a + b, 0);
+        if (diff < 0) {
+            for (let k = 0; k < order.length && diff < 0; k++) {
+                const i = order[k];
+                while (diff < 0 && columnWidths[i] > 3) {
+                    columnWidths[i]--;
+                    diff++;
+                }
+            }
+        }
+        else if (diff > 0) {
+            for (let k = 0; k < order.length && diff > 0; k++) {
+                const i = order[k];
+                while (diff > 0 && columnWidths[i] < naturalWidths[i]) {
+                    columnWidths[i]++;
+                    diff--;
+                }
             }
         }
     }
@@ -751,6 +836,15 @@ function renderMessage(m, width) {
             if (m.shell) {
                 return renderShellCard(m.shell, width);
             }
+            // suggest_followups renders NO generic tool card, EVER (Freebuff
+            // suggest-followups.tsx: the tool block shows ONLY the followup
+            // group — never an arg preview like "💡 Follow-ups
+            // followups=[object Object]", not even transiently while the call
+            // is in flight before its result). The group itself renders via the
+            // 'followup' messages that share this batch (pushed at result time).
+            if (m.tool === 'suggest_followups') {
+                return out;
+            }
             // Compact block: <icon> tool · preview (Freebuff tool-call style:
             // bullet + bold tool name + description), then dim result lines.
             const icon = toolIcon(m.tool);
@@ -814,19 +908,46 @@ function renderMessage(m, width) {
             const th = m.thinking;
             if (!th || !th.text.trim())
                 return out;
+            // Freebuff thinking.tsx special case: a single short **bold** string
+            // (< 100 chars) renders NOTHING (compact dedup — the bold text already
+            // shows in the answer bubble).
+            const singleBoldMatch = th.text.length < 100 ? th.text.trim().match(/^\*\*([^*]+)\*\*$/) : null;
+            if (singleBoldMatch)
+                return out;
             const complete = !m.streaming;
-            const indicator = !complete ? '• ' : th.state === 'expanded' ? '▾ ' : '• ';
-            out.push(`${theme_1.THEME.info}${indicator}${theme_1.THEME.reset}${theme_1.THEME.bold}Thinking${theme_1.THEME.reset}`);
+            // Freebuff EXACT: the preview normalizes the content to ONE line and
+            // word-wraps it (getLastNVisualLines) — so the 5-line preview is the
+            // last 5 VISUAL lines, with '...' prefixed when earlier lines exist.
+            // The wrap width accounts for the '...' prefix (−3) and the indent (−2,
+            // Freebuff paddingLeft: 2). Expanded keeps the original line breaks.
+            const PREVIEW_LINE_COUNT = 5;
+            const bodyCols = Math.max(10, width - 2);
+            const normalizedContent = th.text.replace(/\r\n?/g, '\n').replace(/\n+/g, ' ').trim();
+            const effectiveWidth = bodyCols - 3;
+            const { lines: previewLines, hasMore } = getLastNVisualLines(normalizedContent, effectiveWidth, PREVIEW_LINE_COUNT);
+            const expandedContent = th.text.replace(/\r\n?/g, '\n').replace(/\n\n+/g, '\n\n').trim();
+            const showFull = th.state === 'expanded';
+            const showPreview = th.state === 'preview' && previewLines.length > 0;
+            const toggleIndicator = !complete ? '• ' : showFull ? '▾ ' : showPreview ? '• ' : '▸ ';
+            // Header: theme.foreground (not green) + bold label — Freebuff EXACT.
+            out.push(`${theme_1.THEME.textBright}${toggleIndicator}${theme_1.THEME.reset}${theme_1.THEME.bold}Thinking${theme_1.THEME.reset}`);
             if (th.state === 'hidden')
                 return out;
-            const lines = th.text.replace(/\r\n?/g, '\n').split('\n');
-            const bodyLines = th.state === 'expanded' ? lines : lines.slice(-5);
-            if (th.state === 'preview' && lines.length > 5) {
-                out.push(`  ${theme_1.THEME.muted}${theme_1.THEME.italic}...${theme_1.THEME.reset}`);
+            if (showPreview) {
+                for (let i = 0; i < previewLines.length; i++) {
+                    // '...' sits at the START of the first visual line (Freebuff:
+                    // '...' + lines.join('\n')).
+                    const body = (i === 0 && hasMore ? '...' : '') + previewLines[i];
+                    for (const w of (0, terminal_1.wrapText)(`${theme_1.THEME.muted}${theme_1.THEME.italic}${body}${theme_1.THEME.reset}`, bodyCols)) {
+                        out.push(`  ${w}`);
+                    }
+                }
             }
-            for (const line of bodyLines) {
-                for (const w of (0, terminal_1.wrapText)(`${theme_1.THEME.muted}${theme_1.THEME.italic}${line}${theme_1.THEME.reset}`, Math.max(4, width - 2))) {
-                    out.push(`  ${w}`);
+            if (showFull) {
+                for (const line of expandedContent.split('\n')) {
+                    for (const w of (0, terminal_1.wrapText)(`${theme_1.THEME.muted}${theme_1.THEME.italic}${line}${theme_1.THEME.reset}`, bodyCols)) {
+                        out.push(`  ${w}`);
+                    }
                 }
             }
             return out;
@@ -865,18 +986,61 @@ function renderMessage(m, width) {
             return out;
         }
         case 'followup': {
-            // Freebuff suggest_followups: a clickable "➤ label" row. Rendered dim
-            // under the reply; clicking sends the prompt (keyboard: press the
-            // matching number while the input is empty). Freebuff parity: clicked
-            // ones are "visually updated to show they were used" — the arrow
-            // turns into a green ✓ and the text dims.
+            // Freebuff suggest-followups.tsx port. The ACTIVE batch (the latest
+            // suggest_followups tool call) renders a muted "Suggested followups:"
+            // header + one "→ label" row per suggestion (icon muted, label
+            // foreground; clicked ones are "visually updated": ✓ in success green
+            // + muted text). Batches from EARLIER turns collapse to a
+            // "▸ Previously suggested followups" toggle (muted italic, expand
+            // with 'g') whose items indent 2 and gain a muted-italic full-prompt
+            // sub-line when a label differs from the prompt.
+            const grp = followupsGroupOf(m);
+            if (grp) {
+                if (grp.past) {
+                    const ind = grp.expanded ? '▾' : '▸';
+                    for (const w of (0, terminal_1.wrapText)(`${theme_1.THEME.muted}${ind}${theme_1.THEME.reset}${theme_1.THEME.muted}${theme_1.THEME.italic} Previously suggested followups${theme_1.THEME.reset}`, width)) {
+                        out.push(w);
+                    }
+                    if (grp.expanded) {
+                        for (const f of grp.followups) {
+                            if (!f || !f.prompt)
+                                continue;
+                            const t = f.label || f.prompt;
+                            const row = f.used
+                                ? `${theme_1.THEME.success}✓${theme_1.THEME.reset}${theme_1.THEME.muted} ${t}${theme_1.THEME.reset}`
+                                : `${theme_1.THEME.muted}→${theme_1.THEME.reset}${theme_1.THEME.textBright} ${t}${theme_1.THEME.reset}`;
+                            for (const w of (0, terminal_1.wrapText)(row, Math.max(10, width - 2)))
+                                out.push(`  ${w}`);
+                            if (f.label && f.label !== f.prompt) {
+                                for (const w of (0, terminal_1.wrapText)(`${theme_1.THEME.muted}${theme_1.THEME.italic}${f.prompt}${theme_1.THEME.reset}`, Math.max(10, width - 4))) {
+                                    out.push(`    ${w}`);
+                                }
+                            }
+                        }
+                    }
+                    return out;
+                }
+                out.push(`${theme_1.THEME.muted}Suggested followups:${theme_1.THEME.reset}`);
+                for (const f of grp.followups) {
+                    if (!f || !f.prompt)
+                        continue;
+                    const t = f.label || f.prompt;
+                    const row = f.used
+                        ? `${theme_1.THEME.success}✓${theme_1.THEME.reset}${theme_1.THEME.muted} ${t}${theme_1.THEME.reset}`
+                        : `${theme_1.THEME.muted}→${theme_1.THEME.reset}${theme_1.THEME.textBright} ${t}${theme_1.THEME.reset}`;
+                    for (const w of (0, terminal_1.wrapText)(row, width))
+                        out.push(w);
+                }
+                return out;
+            }
+            // Legacy shape (old saved sessions): one message per suggestion.
             const f = m.followup;
             if (!f || !f.prompt)
                 return out;
             const t = f.label || f.prompt;
             const row = f.used
                 ? `${theme_1.THEME.success}✓ ${theme_1.THEME.reset}${theme_1.THEME.muted}${t}${theme_1.THEME.reset}`
-                : `${theme_1.THEME.info}➤ ${theme_1.THEME.reset}${theme_1.THEME.textBright}${t}${theme_1.THEME.reset}`;
+                : `${theme_1.THEME.muted}→ ${theme_1.THEME.reset}${theme_1.THEME.textBright}${t}${theme_1.THEME.reset}`;
             for (const w of (0, terminal_1.wrapText)(row, width)) {
                 out.push(w);
             }
@@ -992,15 +1156,35 @@ function renderShellCard(shell, width) {
     }
     return out;
 }
+/**
+ * Freebuff SIDE_GUTTER (message-with-agents.tsx): every message content box
+ * gets paddingLeft: 1 + paddingRight: 1 — chat text NEVER touches the screen
+ * edges, so the conversation reads as a tidy centered column. The pinned
+ * welcome block is exempt (Freebuff's landing/chat-header centers on the
+ * full terminal width).
+ */
+exports.SIDE_GUTTER = 1;
 function renderMessages(messages, width) {
     const out = [];
+    // `width` is the FULL terminal width here (same contract as before) — the
+    // gutter is subtracted once, at this single point, so every caller (frame,
+    // scroll helpers, audits) stays width-safe: content wraps to width − 2 and
+    // the gutters bring each row back to exactly ≤ width. No wrap, no jitter.
+    // On very narrow terminals (< 12 cols) the gutter is dropped: the 10-col
+    // content floors inside renderMessage already fill the screen there.
+    const gutted = width - 2 * exports.SIDE_GUTTER;
+    const inner = Math.max(10, gutted);
+    const useGutter = gutted >= 10;
+    const gutter = (line) => (line.length === 0 ? '' : ` ${line} `);
     for (let i = 0; i < messages.length; i++) {
-        const rendered = renderMessage(messages[i], width);
+        const m = messages[i];
+        const wrap = m.kind === 'welcome' || !useGutter ? (line) => line : gutter;
+        const rendered = renderMessage(m, inner);
         if (rendered.length === 0)
             continue;
         if (out.length > 0)
             out.push('');
-        out.push(...rendered);
+        out.push(...rendered.map(wrap));
     }
     return out;
 }

package/dist/tui/statusbar.js

@@ -23,27 +23,30 @@ function fitTwo(left, right, inner) {
     const maxR = Math.max(0, avail - maxL);
     return { left: (0, terminal_1.truncate)(left, maxL), right: (0, terminal_1.truncate)(right, maxR) };
 }
-/** Render the top header line: VectorHead status ... model ● */
+/** Render the top header line: VectorHead status ... model • */
 function renderHeader(width, info) {
-    const brand = `${theme_1.THEME.bold}${theme_1.THEME.accent}VectorHead${theme_1.THEME.reset}`;
+    // Brand chip (user request): the green "VectorHead" sits on a GRAY
+    // background block — text color stays accent green, only the chip is gray.
+    // Padded with a space on each side so the green never touches the gray edge.
+    const brand = `${theme_1.THEME.brandBg}${theme_1.THEME.bold}${theme_1.THEME.accent} VectorHead ${theme_1.THEME.reset}`;
     // Status dot sits at the top-right, right next to the model (Freebuff-style).
     // Red = API tokens/quota exhausted; blinking green pulse = idle/ready
     // (agent waiting for input); solid green = working; gray ring = disconnected.
     let dot;
     if (info.tokenExhausted) {
-        dot = `${theme_1.THEME.error}●${theme_1.THEME.reset}`;
+        dot = `${theme_1.THEME.error}•${theme_1.THEME.reset}`;
     }
     else if (info.needsSetup) {
         // Provider was removed / never configured — solid red until /connect.
-        dot = `${theme_1.THEME.error}●${theme_1.THEME.reset}`;
+        dot = `${theme_1.THEME.error}•${theme_1.THEME.reset}`;
     }
     else if (info.blinking) {
         dot = info.blinkPhase
-            ? `${theme_1.THEME.success}●${theme_1.THEME.reset}`
-            : `${theme_1.THEME.faint}●${theme_1.THEME.reset}`;
+            ? `${theme_1.THEME.success}•${theme_1.THEME.reset}`
+            : `${theme_1.THEME.faint}•${theme_1.THEME.reset}`;
     }
     else {
-        dot = info.connected ? `${theme_1.THEME.success}●${theme_1.THEME.reset}` : `${theme_1.THEME.error}○${theme_1.THEME.reset}`;
+        dot = info.connected ? `${theme_1.THEME.success}•${theme_1.THEME.reset}` : `${theme_1.THEME.error}◦${theme_1.THEME.reset}`;
     }
     const status = `${(0, theme_1.statusColor)(info.status)}${info.status}${theme_1.THEME.reset}`;
     const left = `${brand}  ${status}`;
@@ -54,12 +57,19 @@ function renderHeader(width, info) {
     // Exception: when no provider is configured, keep the red "connect to
     // provider" hint so the user knows what to do next.
     const model = `${theme_1.THEME.muted}${info.model}${theme_1.THEME.reset}`;
-    const right = info.needsSetup
-        ? `${theme_1.THEME.error}${info.provider}${theme_1.THEME.reset} ${dot}`
-        : `${model} ${dot}`;
-    const fit = fitTwo(left, right, width);
-    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;
+    // The truncatable right-side text (model, or the red provider hint). The
+    // status dot is NOT part of it: it is appended AFTER width fitting, so
+    // on narrow terminals only the model gets "…" and the dot can never be
+    // truncated away — a vanishing/repositioning dot reads as the indicator
+    // "jumping" between the header (model •) and the status bar (• ask).
+    const right = info.needsSetup ? `${theme_1.THEME.error}${info.provider}${theme_1.THEME.reset}` : model;
+    // Budget 3 columns for the gap before the right text, the space, and the
+    // dot itself, and leave >= 1 gap column (mid) — the composed row is then
+    // exactly `width` wide with the dot as its last visible glyph, so it
+    // never wraps and never shifts the rows below (jitter bug).
+    const fit = fitTwo(left, right, width - 3);
+    const mid = Math.max(1, width - 2 - (0, terminal_1.stripAnsi)(fit.left).length - (0, terminal_1.stripAnsi)(fit.right).length);
+    return theme_1.THEME.bgBar + `${fit.left}${' '.repeat(mid)}${fit.right} ${dot}` + theme_1.THEME.reset;
 }
 /**
  * Render the dedicated agent-activity strip (Freebuff-style): a compact
@@ -90,6 +100,14 @@ function renderStatusBar(width, info) {
     if (info.running && info.spinner) {
         left = `${statusColorCode}${info.spinner}${theme_1.THEME.reset} ${statusColorCode}${info.status}${theme_1.THEME.reset}`;
     }
+    else if (info.status === 'Ready') {
+        // User request: the idle bottom-bar label reads "Build" — BOLD dark
+        // gray (#374151), replacing the old green "Ready". A leading space
+        // insets it one column so the label never sits flush against the left
+        // screen edge. Functional statuses (Thinking/Working/Error/…) keep
+        // their own words and colors.
+        left = ` ${theme_1.THEME.bold}${theme_1.THEME.build}Build${theme_1.THEME.reset}`;
+    }
     else {
         left = `${statusColorCode}${info.status}${theme_1.THEME.reset}`;
     }
@@ -97,10 +115,12 @@ function renderStatusBar(width, info) {
     if (info.running && info.elapsed !== undefined) {
         right += `${theme_1.THEME.dim}${info.elapsed}s${theme_1.THEME.reset} `;
     }
-    const conn = info.connected ? `${theme_1.THEME.success}●${theme_1.THEME.reset}` : `${theme_1.THEME.error}○${theme_1.THEME.reset}`;
+    const conn = info.connected ? `${theme_1.THEME.success}•${theme_1.THEME.reset}` : `${theme_1.THEME.error}◦${theme_1.THEME.reset}`;
     const mode = info.mode === 'yolo' ? `${theme_1.THEME.warn}YOLO${theme_1.THEME.reset}` : `${theme_1.THEME.faint}ask${theme_1.THEME.reset}`;
     right += `${conn} ${mode}`;
-    const fit = fitTwo(left, right, width);
+    // Same width-1 budget as the header (see renderHeader) — left+right must
+    // leave room for the mandatory gap column so the row never exceeds width.
+    const fit = fitTwo(left, right, width - 1);
     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;
 }

package/dist/tui/theme.js

@@ -33,6 +33,8 @@ const FB = {
     codeHeader: '\x1b[38;2;91;100;122m', // #5b647a (markdown codeHeaderFg)
     surface: '\x1b[48;2;32;35;39m', // #202327
     surfaceHover: '\x1b[48;2;51;65;85m', // #334155
+    brandBg: '\x1b[48;2;55;65;81m', // #374151 (gray chip behind the header brand — Freebuff codeBackground gray)
+    buildFg: '\x1b[38;2;55;65;81m', // #374151 fg (dark gray for the bottom-bar Build label)
 };
 exports.THEME = {
     accent: FB.primary, // Freebuff primary green #9EFC62
@@ -68,6 +70,8 @@ exports.THEME = {
     divider: '\x1b[38;2;40;48;66m', // #283042 (Freebuff markdown.dividerFg)
     bgBar: FB.surface,
     bgPanel: FB.surfaceHover,
+    brandBg: FB.brandBg, // gray chip behind the header brand (teks tetap hijau)
+    build: FB.buildFg, // bottom-bar idle label "Build" — dark gray #374151
     bold: '\x1b[1m',
     italic: '\x1b[3m',
     dim: '\x1b[2m',
@@ -97,7 +101,7 @@ exports.SPINNERS = {
     dots: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'],
     line: ['─', '╌', '╍', '═', '╍', '╌'],
     arrows: ['←', '↖', '↑', '↗', '→', '↘', '↓', '↙'],
-    pulse: ['●', '◐', '◑', '○'],
+    pulse: ['•', '◐', '◑', '◦'], // round glyphs only — no oval ●/○ anywhere
 };
 /** A frame-advancing spinner (call frame() on each render tick). */
 class Spinner {

package/dist/tui/themes.js

@@ -102,6 +102,8 @@ const SLOT_KEYS = {
     userLineBg: ['userLineBg', 'userLine', 'primary'],
     bgBar: ['backgroundElement', 'backgroundPanel'],
     bgPanel: ['backgroundPanel', 'backgroundElement'],
+    brandBg: ['brandBg', 'codeBg', 'backgroundPanel'],
+    build: ['build', 'brandBg', 'textMuted'],
 };
 function ansi(bg, n) {
     return bg ? `\x1b[48;5;${n}m` : `\x1b[38;5;${n}m`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agen-vektor",
-  "version": "0.3.9",
+  "version": "0.3.10",
   "description": "VectorHead (agen-vektor) — AI Coding Agent CLI/TUI for Linux & Termux. Multi-provider, tool calling, session, permission system.",
   "type": "commonjs",
   "bin": {
@@ -39,14 +39,6 @@
     "ollama"
   ],
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/clickmamaheti-prog/vector-agent.git"
-  },
-  "homepage": "https://github.com/clickmamaheti-prog/vector-agent",
-  "bugs": {
-    "url": "https://github.com/clickmamaheti-prog/vector-agent/issues"
-  },
   "dependencies": {},
   "devDependencies": {
     "@types/node": "^22.10.0",