agen-vektor 0.3.13 → 0.3.15

package/README.md

@@ -50,14 +50,14 @@ incrementally with no flicker.
 ## Contents
 
 - [Features](#features) · [Installation](#installation) · [Quick start](#quick-start) · [Command line](#command-line) · [TUI commands](#tui-commands)
-- [Provider configuration](#provider-configuration) · [Themes](#themes) · [Security model](#security-model) · [Architecture](#architecture) · [Development](#development)
+- [Provider configuration](#provider-configuration) · [Themes](#themes) · [Security model](#security-model) · [Privacy](#privacy) · [Architecture](#architecture) · [Development](#development)
 - [Testing](#testing) · [Troubleshooting](#troubleshooting) · [Roadmap](#roadmap) · [License](#license)
 
 ## Features
 
 - **Interactive TUI** — chat, agent status, tool execution, diff viewer, input. Keyboard driven, mouse-aware, works on 80×24 terminals and survives resize. Scroll the chat with PgUp/PgDn, the mouse wheel, or ↑/↓ while the input line is empty.
 - **Agent loop** — plan → inspect → tool call → result → review → fix → retry until done (with an iteration cap).
-- **Tools** — read/write/edit files, list directories, search files, run shell commands, git, fetch web pages.
+- **Tools** — read/write/edit files, list directories, search files, run shell commands, git, fetch web pages, and **live web search out of the box** (no key needed — searches relay through the VectorHead gateway; bring your own Exa/Serper/Brave key to use your own quota).
 - **Security first** — command policy classifies every shell command (SAFE / ASK / DANGEROUS / BLOCKED), permission prompts before risky actions, `--yolo` mode with warnings, and API keys are never printed or persisted to sessions.
 - **Multi-provider** — OpenAI, Anthropic, Gemini, OpenRouter, Ollama, and any OpenAI-compatible custom endpoint.
 - **Sessions & memory** — conversations persist to `~/.vector/sessions/`; a relaunch in the same project resumes the conversation automatically (agent keeps the last replies in context), `/continue` resumes any session, and `Ctrl+L`/`/clear` starts fresh.
@@ -232,7 +232,7 @@ here is OpenAI-compatible):
   AgentRouter uses `deepseek-v4-flash` while BitDeer uses
   `deepseek-ai/DeepSeek-V4-Flash`).
 - `/provider` lists built-ins + every configured custom and offers
-  **➕ Add custom provider** (id → name → base URL → key). `/model` then
+  **Add custom provider** (id → name → base URL → key). `/model` then
   auto-discovers models from the endpoint's `/models` route and falls back
   to the `models` map above.
 - The old single-custom setup (`provider: "custom"` + `apiUrl`/`customName`
@@ -307,6 +307,24 @@ Every shell command is classified:
 
 `--yolo` auto-approves ASK-level actions but still prompts for DANGEROUS and refuses BLOCKED ones. API keys are never printed to the terminal, logs, diffs, or session history.
 
+## Privacy
+
+**VectorHead collects nothing.** No telemetry, no analytics, no crash reporting, no usage tracking — there is no code in the app that could phone home. Every network destination in the source is auditable:
+
+| Destination | When |
+|---|---|
+| Your configured AI provider (OpenAI, Anthropic, Gemini, OpenRouter, Ollama, custom) | Only when you chat — with **your own** API key |
+| `vector-tui.methatech.eu.org` (VectorHead Free gateway) | Only if you pick the free tier; the shared provider key stays server-side, users never see it |
+| Brave / Exa / Serper | Only when you use the web-search tool with your own key |
+| `vector-tui.methatech.eu.org/v1/web-search` | Web search when you have NO search key of your own — the query is relayed by the gateway; your own key, when set, always takes precedence and bypasses the relay |
+| Raw model catalog (public JSON) | To populate the free-tier model list |
+
+**Stored locally** (all in `~/.vector/`): `config.json` (preferences, no secrets), `credentials.json` (only keys *you* enter, file mode 0600), sessions, memory, logs. Nothing else is written anywhere.
+
+**No device identity.** The app does not generate a device id or send any tracking header (the old anonymous `device-id` + `X-Vector-Device` pair was fully removed in 0.3.14).
+
+**The agent guards itself against secrets** — its own file tools refuse to read or write `.env`, private keys, `credentials.json`, kubeconfig, and similar files (override only via explicit `VECTOR_ALLOW_SENSITIVE=1`), so a prompt cannot accidentally exfiltrate them.
+
 ## Architecture
 
 ```

package/dist/agent/agent.js

@@ -1,44 +1,6 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Agent = void 0;
-/**
- * Agent — high-level facade bundling provider, tools, permissions
- * and the loop into a single object the TUI/CLI can drive.
- */
-const fs = __importStar(require("node:fs"));
 const factory_1 = require("../providers/factory");
 const registry_1 = require("../tools/registry");
 const filesystem_1 = require("../tools/filesystem");
@@ -47,10 +9,10 @@ const shell_1 = require("../tools/shell");
 const git_1 = require("../tools/git");
 const web_1 = require("../tools/web");
 const extras_1 = require("../tools/extras");
+const design_lab_1 = require("../tools/design-lab");
 const apply_patch_1 = require("../tools/apply-patch");
 const permissions_1 = require("../security/permissions");
 const config_1 = require("../config/config");
-const paths_1 = require("../utils/paths");
 const free_tier_1 = require("../config/free-tier");
 const loop_1 = require("./loop");
 const rules_1 = require("./rules");
@@ -64,14 +26,13 @@ class Agent {
     permissions;
     cwd;
     constructor(opts) {
-        // Free tier (vectorhead-free): define the provider entry, expose the
-        // anonymous device id for the {env:} header template, and default a
-        // FIRST RUN (no config.json yet) to the free tier so onboarding is
-        // "install & pick a model" with zero keys. Existing configs keep their
-        // active provider; only the free ENTRY is (re)defined.
-        const firstRun = !opts.config && (0, free_tier_1.isFirstRun)(fs.existsSync((0, paths_1.getConfigPath)()));
+        // Free tier (vectorhead-free): the provider ENTRY is (re)defined here on
+        // every run (repair), and FIRST-RUN provider/model selection now happens
+        // in loadConfig() itself (2026-09-06) — the old Agent-side seed never ran
+        // on the real CLI path because buildAgent() always passes a config, so
+        // fresh installs landed on 'openrouter' (401 until /connect). No per-
+        // device identity: the gateway requires none (removed 2026-09-05).
         const seeded = (0, config_1.effectiveConfig)(opts.config);
-        (0, free_tier_1.exportDeviceIdEnv)();
         if ((0, free_tier_1.ensureFreeProvider)(seeded)) {
             try {
                 (0, config_1.saveConfig)(seeded);
@@ -80,10 +41,6 @@ class Agent {
                 /* read-only home — the in-memory def still works this session */
             }
         }
-        if (firstRun) {
-            seeded.provider = free_tier_1.FREE_PROVIDER_ID;
-            seeded.model = free_tier_1.FREE_DEFAULT_MODEL;
-        }
         this.config = seeded;
         this.cwd = opts.cwd || process.cwd();
         // Seed Hermes-style SOUL.md/MEMORY.md/USER.md/SKILL.md on first run
@@ -106,6 +63,8 @@ class Agent {
             // Freebuff-style extras: glob, read_subtree, task_completed,
             // suggest_followups, render_ui.
             ...(0, extras_1.createExtrasTools)(),
+            // Design-lab gateway pipeline (Codespace + ui-ux-pro-max): run/status/result.
+            ...(0, design_lab_1.createDesignLabTools)(),
             // Unified-diff editing (Freebuff/Codebuff apply_patch format).
             (0, apply_patch_1.createApplyPatchTool)(),
             // Hermes-style progressive-disclosure skills (list_skills / read_skill).
@@ -167,6 +126,7 @@ class Agent {
             onFinal: cb.onFinal,
             onError: cb.onError,
             onActivity: cb.onActivity,
+            onRetryReset: cb.onRetryReset,
         };
         // Permissions callback must be live-updated as well
         this.permissions.setMode(this.config.permissionMode);

package/dist/agent/loop.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeHistory = sanitizeHistory;
 exports.runAgentLoop = runAgentLoop;
 exports.compactMessages = compactMessages;
 exports.estimateContextSize = estimateContextSize;
@@ -18,6 +19,78 @@ const light_1 = require("./light");
 const prompts_1 = require("./prompts");
 const rules_1 = require("./rules");
 const skills_1 = require("./skills");
+/**
+ * Repair a history window so it stays a VALID OpenAI-style conversation.
+ *
+ * The TUI continues each turn with `lastMessages.slice(-40)`. That slice can
+ * land MID-EXCHANGE: a 'tool' result whose assistant.tool_calls was cut off,
+ * or an assistant.tool_calls whose results were cut off. Strict OpenAI-
+ * compatible gateways reject the whole request with 400 ("tool_calls without
+ * a response" / "unknown tool_call_id"), which the user experiences as the
+ * agent dying "mid-task" after a few long turns — even though the current
+ * task had nothing wrong with it.
+ *
+ * Rules enforced here:
+ * 1. tool results with no preceding matching tool_calls → dropped (orphans);
+ * 2. an assistant.tool_calls interrupted by the next user message (or the
+ *    end of history) is TRIMMED to the calls that were actually answered
+ *    (dropped entirely when none were);
+ * 3. leading tool results (their assistant was sliced away) → dropped.
+ */
+function sanitizeHistory(history) {
+    const msgs = history.filter((m) => m.role !== 'system');
+    const out = [];
+    // toolCallIds of the MOST RECENT assistant.tool_calls still awaiting results.
+    let expected = new Set();
+    /** Trim the latest assistant's toolCalls down to the answered subset. */
+    const trimPendingAssistant = () => {
+        if (expected.size === 0)
+            return;
+        for (let i = out.length - 1; i >= 0; i--) {
+            const prev = out[i];
+            if (prev.role === 'assistant' && prev.toolCalls && prev.toolCalls.length > 0) {
+                const answered = prev.toolCalls.filter((tc) => !expected.has(tc.id));
+                if (answered.length === prev.toolCalls.length)
+                    break; // fully answered
+                if (answered.length === 0)
+                    out.splice(i, 1);
+                else
+                    out[i] = { ...prev, toolCalls: answered };
+                break;
+            }
+            if (prev.role === 'user')
+                break;
+        }
+        expected = new Set();
+    };
+    for (const m of msgs) {
+        if (m.role === 'assistant') {
+            if (m.toolCalls && m.toolCalls.length > 0) {
+                out.push({ ...m, toolCalls: [...m.toolCalls] });
+                expected = new Set(m.toolCalls.map((tc) => tc.id));
+            }
+            else {
+                out.push(m);
+            }
+            continue;
+        }
+        if (m.role === 'tool') {
+            if (!m.toolCallId || !expected.has(m.toolCallId))
+                continue; // orphan result
+            out.push(m);
+            expected.delete(m.toolCallId);
+            continue;
+        }
+        // user: close out any assistant still awaiting results first.
+        trimPendingAssistant();
+        out.push(m);
+    }
+    trimPendingAssistant(); // run died mid tool-execution (history tail)
+    let start = 0;
+    while (start < out.length && out[start].role === 'tool')
+        start++;
+    return start > 0 ? out.slice(start) : out;
+}
 async function runAgentLoop(userRequest, opts, callbacks = {}) {
     const { provider, tools, permissions, config, cwd, signal } = opts;
     const maxIterations = config.maxIterations;
@@ -25,7 +98,7 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
     // 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 history = sanitizeHistory(opts.history ?? []);
     const isContinuation = history.length > 0;
     // Casual small talk ("hallo", "hi", "apa kabar", "kamu siapa", …) gets a
     // plain, direct answer: no project context, no folder listing, no skills
@@ -95,7 +168,11 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
         let final = null;
         for await (const ev of provider.stream(params)) {
             if (ev.type === 'delta' && ev.delta) {
-                content += ev.delta;
+                // Guarded merge (not naive +=): gateways that resend the full text
+                // so far must not accumulate into a doubled answer ("double chat",
+                // reported 2026-09-08 — the TUI guarded its own display but this
+                // accumulator fed the no-done fallback path naively).
+                content = (0, provider_1.mergeStreamDelta)(content, ev.delta);
                 callbacks.onDelta?.(ev.delta);
             }
             else if (ev.type === 'delta' && ev.reasoning) {
@@ -122,6 +199,13 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
             }
         }
         if (final) {
+            // Defense in depth: a provider that still accumulates naively (custom
+            ///mock stream implementations) hands us done.result.content exactly
+            // doubled when its LAST delta resent the full text — "X…" + "X…" =
+            // content+content (custom/mock stream implementations). That shape is never a genuine reply; trust the
+            // guarded stream accumulation instead.
+            if (content && final.content === content + content)
+                final.content = content;
             if (final.reasoning && !lastReasoning) {
                 // Reasoning appeared ONLY in the final result (no deltas were
                 // streamed): emit once so the TUI still gets the thinking card.
@@ -154,7 +238,22 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
         callbacks.onStatus?.(iterations === 1 ? 'Thinking' : 'Thinking…');
         let result;
         try {
-            result = await (0, provider_1.withRetry)(doCall, { retries: config.maxRetries, signal });
+            result = await (0, provider_1.withRetry)(doCall, {
+                retries: config.maxRetries,
+                signal,
+                onRetry: (attempt, err, waitMs) => {
+                    // Surface the silent retry loop: without this the user stares at a
+                    // frozen spinner for 1s+2s+4s while the gateway flakes.
+                    // friendlyApiError keeps provider bodies (JSON, stack-ish text) out
+                    // of the status bar — the raw dump leaked internals and pushed the
+                    // timer/mode labels off the row.
+                    callbacks.onStatus?.(`Retrying ${attempt}/${config.maxRetries} — ${(0, provider_1.friendlyApiError)(err)}, waiting ${Math.round(waitMs / 1000)}s`);
+                    // A partially-streamed reply from the FAILED attempt must not leak
+                    // into the UI or the next attempt's reasoning accumulator.
+                    lastReasoning = '';
+                    callbacks.onRetryReset?.();
+                },
+            });
         }
         catch (err) {
             if (err.name === 'AbortError' || err.message === 'aborted') {
@@ -166,20 +265,21 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
                 callbacks.onError?.(new Error('API authentication failed (401). Check your API key.'));
                 callbacks.onStatus?.('Auth error');
                 stopped = true;
-                finalContent = `⚠️ API authentication failed. Run \`vector /provider\` to configure your API key.`;
+                finalContent = `! API authentication failed. Run \`vector /provider\` to configure your API key.`;
                 break;
             }
             if (err instanceof provider_1.ProviderError && err.status === 429) {
                 callbacks.onError?.(new Error('Rate limited (429) by the provider.'));
                 callbacks.onStatus?.('Rate limited');
                 stopped = true;
-                finalContent = '⚠️ Rate limited by the provider. Wait a moment and try again.';
+                finalContent = '! Rate limited by the provider. Wait a moment and try again.';
                 break;
             }
             callbacks.onError?.(err);
             callbacks.onStatus?.('Error');
             stopped = true;
-            finalContent = `⚠️ Error: ${err.message}`;
+            // Same sanitation as the retry line: no raw HTTP/JSON body in chat.
+            finalContent = `! Error: ${(0, provider_1.friendlyApiError)(err)}`;
             break;
         }
         // Defense in depth: a misbehaving gateway can yield a sparse toolCalls
@@ -211,12 +311,21 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
             ]);
             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,
-                });
+                let toolResult;
+                try {
+                    toolResult = await tools.execute(tc.name, tc.arguments, {
+                        cwd,
+                        permissions,
+                        onActivity: callbacks.onActivity,
+                        maxOutput: 30_000,
+                    });
+                }
+                catch (err) {
+                    // Freebuff ToolCallItem: a FAILED call still leaves its card with a
+                    // preview (input-built) but no "running" suffix — surface the error
+                    // as a failed result so the TUI can finalize the card.
+                    toolResult = { output: `ERROR: ${err.message}`, summary: 'tool error' };
+                }
                 return { tc, toolResult };
             };
             try {
@@ -266,6 +375,24 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
             }
             continue;
         }
+        // No tool calls → final answer. GUARD: an EMPTY response with no tool
+        // calls is a protocol glitch (gateway truncation, overloaded edge, a
+        // model that emitted only reasoning) — treating it as the final answer
+        // silently ends the run mid-task (reported as "macet di tengah jalan").
+        if (!result.content.trim() && result.toolCalls.length === 0) {
+            const empty = new provider_1.ProviderError('Upstream returned an empty response (no content, no tool calls).', 0, true);
+            if (iterations >= maxIterations) {
+                // No budget left for another model call — surface honestly.
+                callbacks.onError?.(empty);
+                callbacks.onStatus?.('Error');
+                stopped = true;
+                finalContent = `! ${empty.message}`;
+                break;
+            }
+            callbacks.onStatus?.('Empty response — retrying');
+            lastReasoning = '';
+            continue; // consume the iteration, ask the model again
+        }
         // No tool calls → final answer
         finalContent = result.content;
         callbacks.onStatus?.('Completed');
@@ -276,7 +403,7 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
     if (iterations >= maxIterations) {
         callbacks.onStatus?.('Iteration limit');
         if (!finalContent) {
-            finalContent = `⚠️ Reached the maximum of ${maxIterations} iterations without completing the task. Run /settings to raise the limit or refine the request.`;
+            finalContent = `! Reached the maximum of ${maxIterations} iterations without completing the task. Run /settings to raise the limit or refine the request.`;
         }
     }
     return { content: finalContent, iterations, toolCalls, stopped, aborted, messages };

package/dist/agent/prompts.js

@@ -59,7 +59,17 @@ Rules:
     write_todos with ["Buat file", "Baca isinya"] before calling write_file.
     The ONLY exceptions — greetings, plain questions, small talk, and
     requests needing just ONE tool call: answer those directly with no
-    write_todos.`;
+    write_todos.
+14. Suggested followups (Freebuff parity): end EVERY task response by
+    calling suggest_followups with exactly 3 clickable followup prompts
+    the user is likely to want next. Call it LAST — after the final
+    answer text and after all other tool calls. Each followup: a short
+    label (2–5 words) and a prompt phrased in the user's voice, one
+    sentence naming the OUTCOME (never the steps, file paths, or design
+    decisions). Make them specific to what you just did — alternatives,
+    related features, testing/verification you could run, or "Continue
+    with the next step" when a plan has more steps. Skip it only when
+    there is no sensible next step (greetings, goodbyes).`;
 /**
  * Identity line injected into the system prompt so the model can answer
  * "which model/provider are you?" truthfully (it has no other way to know).

package/dist/agent/skills.js

@@ -286,7 +286,11 @@ metadata:
 1. \`git status --short\` and \`git log --oneline -5\` to understand state.
 2. Review changes: \`git diff --stat\`, then \`git diff\` for details.
 3. Stage only relevant files: \`git add <paths>\` (never \`git add -A\` blindly).
-4. Commit with a concise message describing WHY, not just WHAT.
+4. Commit with a concise message describing WHY, not just WHAT. When committing
+   on the user's behalf, end the message with the attribution footer from the
+   git tool guidance (COMMIT_ATTRIBUTION_FOOTER + COMMIT_ATTRIBUTION_COAUTHOR,
+   see \`src/tools/git.ts\`) — unless the commit lands in somebody else's
+   repository on their behalf (attribution OFF, no trailer at all).
 5. NEVER run \`git push\` unless the user explicitly asks.
 
 ## Pitfalls

package/dist/cli/index.js

@@ -184,7 +184,7 @@ async function runNonInteractive(opts) {
             catch {
                 preview = args.slice(0, 80);
             }
-            console.log(`${terminal_1.ANSI.brightYellow}⚙ ${t}${terminal_1.ANSI.reset} ${terminal_1.ANSI.dim}${preview}${terminal_1.ANSI.reset}`);
+            console.log(`${terminal_1.ANSI.brightYellow}· ${t}${terminal_1.ANSI.reset} ${terminal_1.ANSI.dim}${preview}${terminal_1.ANSI.reset}`);
         },
     });
     // Print the final reply. The loop uses the non-streaming path, so the
@@ -198,7 +198,7 @@ async function runNonInteractive(opts) {
             : 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(`${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}`);
     // Persist the conversation (per-project session by default) so the
@@ -254,12 +254,12 @@ async function runTui(opts) {
     // into config via effectiveConfig inside the Agent), then config.json.
     const theme = opts.theme || config.theme || 'vectorhead';
     if (!(0, themes_1.applyThemeByName)(theme)) {
-        console.warn(`${terminal_1.ANSI.yellow}⚠${terminal_1.ANSI.reset} Unknown theme "${theme}" — using vectorhead. Put custom themes in ~/.vector/themes/`);
+        console.warn(`${terminal_1.ANSI.yellow}!${terminal_1.ANSI.reset} Unknown theme "${theme}" — using vectorhead. Put custom themes in ~/.vector/themes/`);
         (0, themes_1.applyThemeByName)('vectorhead');
     }
     const hasKey = (0, providers_1.providerConfigured)(config, config.provider);
     if (!hasKey) {
-        console.log(`${terminal_1.ANSI.yellow}⚠${terminal_1.ANSI.reset} Provider "${(0, factory_1.displayProviderName)(config)}" is not fully configured.\n` +
+        console.log(`${terminal_1.ANSI.yellow}!${terminal_1.ANSI.reset} Provider "${(0, factory_1.displayProviderName)(config)}" is not fully configured.\n` +
             `Set ${providerEnv(config.provider)} in your environment, or run /provider inside VectorHead to add one.\n`);
     }
     // Resolve session name — default to a persistent per-project session so
@@ -317,31 +317,52 @@ async function runTui(opts) {
     // frame rows by App.computeFrame, so a selector navigation is diffed per
     // ROW like everything else. The old modal branch forced a full-screen
     // repaint per keystroke (lastFrameRows = []) — the ↑/↓ "berkedip" in
-    // /model. The cursor is HIDDEN while a modal is open (menus don't show a
-    // text cursor) and restored at the input row when it closes.
+    // /model. The hardware cursor is now HIDDEN ALWAYS (Freebuff/opentui
+    // parity) — see the note in doRender below.
     let lastFrameRows = [];
-    let lastCursorPos = '';
+    let lastCols = 0;
+    let lastRows = 0;
     const doRender = () => {
         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;
-        if (app.modalActive()) {
-            out.push(terminal_1.ANSI.hideCursor);
-            lastCursorPos = '';
+        const { rows: nowRows, cols: nowCols } = (0, terminal_1.getTerminalSize)();
+        // Mobile keyboard: when the terminal size CHANGES (keyboard up/down,
+        // rotation), Termux's alt-screen can shift/scroll, so incremental row
+        // diffs land at wrong offsets — logo/header painted TWICE (report:
+        // "makin parah"). Freebuff parity (@opentui full redraw on resize):
+        // a size change forces a FULL repaint — clear the whole alt screen and
+        // repaint every row from scratch. Between ticks (same size) the cheap
+        // row-diff still applies.
+        const resized = nowCols !== lastCols || nowRows !== lastRows;
+        let out;
+        if (resized) {
+            // Full repaint: absolute cursorTo per row — NEVER a trailing '\r\n'
+            // (an explicit LF on the bottom row SCROLLS the alt screen by one;
+            // every later diff would then paint one row off — ghost/double bars).
+            out = [terminal_1.ANSI.clearScreen + terminal_1.ANSI.cursorHome];
+            for (let i = 0; i < rows.length; i++)
+                out.push((0, terminal_1.cursorTo)(i + 1, 1) + rows[i]);
+            lastFrameRows = rows;
         }
         else {
-            const cursor = (0, terminal_1.cursorTo)(snap.inputRow, snap.cursorCol);
-            if (cursor !== lastCursorPos)
-                out.push(cursor);
-            lastCursorPos = cursor;
-            out.push(terminal_1.ANSI.showCursor);
+            // Keyboard shrink: when the terminal loses rows, the new frame is
+            // shorter than the previous screen. Stale rows below the new frame
+            // must be CLEARED or the old input-box border + status bar remain
+            // painted there — the "double ╭╰ + Build • YOLO" report.
+            out = (0, terminal_1.diffFrameUpdates)(lastFrameRows, rows);
+            lastFrameRows = rows;
         }
+        lastCols = nowCols;
+        lastRows = nowRows;
+        // Hardware cursor SELALU disembunyikan (Freebuff/opentui parity): kursor
+        // terminal asli BERKEDIP dengan cadance bawaan terminal (~500ms). Setelah
+        // dot header & sheen logo dihapus, INILAH kedip terakhir yang dilaporkan
+        // user (2026-09-07: "masih ada blink di sebelah YOLO dan di dalam chat
+        // prompt") — dulu showCursor di-push di akhir tiap paint lalu kursor
+        // dibiarkan VISIBLE selama idle → berkedip terus tanpa henti. Caret kini
+        // murni blok ▍ statis lukisan InputBox.render (tidak berkedip);
+        // showCursor dikembalikan sekali saat exit (blok finally di bawah).
+        out.push(terminal_1.ANSI.hideCursor);
         // DECAWM guard: even one exactly-`cols`-wide row (input-box borders,
         // header at the old width) leaves the cursor in the pending-wrap state;
         // the NEXT repaint — e.g. the ~480ms blink dot — then auto-wraps first
@@ -425,7 +446,7 @@ async function main() {
     }
     // Warnings
     if (opts.yolo) {
-        console.warn(`${terminal_1.ANSI.yellow}⚠ WARNING: --yolo mode skips permission prompts for ask-level actions.${terminal_1.ANSI.reset}`);
+        console.warn(`${terminal_1.ANSI.yellow}! WARNING: --yolo mode skips permission prompts for ask-level actions.${terminal_1.ANSI.reset}`);
     }
     (0, paths_1.ensureDirs)();
     logger_1.logger.info(`VectorHead v${VERSION} started in ${process.cwd()}`);

package/dist/cli/keyboard.js

@@ -254,6 +254,13 @@ function parseKey(data) {
             i++;
             continue;
         }
+        if (code === 20) {
+            // Ctrl+T — used by the TUI to cycle the Thinking card (app.ts), so the
+            // plain letter 't' can always be typed into the input.
+            events.push({ name: 'ctrl_t' });
+            i++;
+            continue;
+        }
         // Printable
         if (code >= 32 && code <= 126) {
             events.push({ name: 'char', char: ch });

package/dist/config/config.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_CONFIG = void 0;
+exports.firstRunSeedFree = firstRunSeedFree;
 exports.loadConfig = loadConfig;
 exports.saveConfig = saveConfig;
 exports.effectiveConfig = effectiveConfig;
@@ -48,9 +49,17 @@ const path = __importStar(require("node:path"));
 const paths_1 = require("../utils/paths");
 const logger_1 = require("../utils/logger");
 const providers_1 = require("./providers");
+// Free-tier onboarding (2026-09-06): a FIRST RUN (no config.json) seeds the
+// vectorhead-free provider so `npm install && vector` chats immediately with
+// zero keys (type-only import — no runtime cycle).
+const free_tier_1 = require("./free-tier");
 exports.DEFAULT_CONFIG = {
-    provider: 'openrouter',
-    model: 'deepseek/deepseek-chat',
+    // Free tier is the zero-config default (2026-09-06): the gateway holds the
+    // real provider key server-side, so a fresh install needs NO API key.
+    // BYOK providers remain one /connect away. Previously this pointed at
+    // 'openrouter' (no key → 401 "Not connected" on every fresh install).
+    provider: free_tier_1.FREE_PROVIDER_ID,
+    model: free_tier_1.FREE_DEFAULT_MODEL,
     protocol: 'openai',
     // User request (2026-09-04): the assistant must ACT without permission
     // prompts — yolo is the default. Dangerous commands (rm, git push, chmod…)
@@ -65,6 +74,16 @@ exports.DEFAULT_CONFIG = {
     compactionThreshold: 80_000,
     theme: 'vectorhead',
 };
+/**
+ * First-run onboarding seed (2026-09-06): DEFAULT_CONFIG points at the free
+ * tier, and the free provider ENTRY is always defined. Returns a NEW object
+ * (never mutates DEFAULT_CONFIG) plus true when the caller should persist it.
+ */
+function firstRunSeedFree(base) {
+    const config = { ...exports.DEFAULT_CONFIG, ...base };
+    const changed = (0, free_tier_1.ensureFreeProvider)(config);
+    return { config, changed };
+}
 function loadConfig() {
     (0, paths_1.ensureDirs)();
     const p = (0, paths_1.getConfigPath)();
@@ -92,9 +111,23 @@ function loadConfig() {
         }
     }
     catch (err) {
+        // UNREADABLE config.json: fall through WITHOUT persisting — never
+        // overwrite a user file we failed to parse (their config stays on disk).
         logger_1.logger.warn(`config load failed: ${err.message}`);
+        return firstRunSeedFree().config;
+    }
+    // No config.json (true first run): seed the free tier AND PERSIST it so the
+    // next run keeps the same provider (this was the dormant "first-run seeds
+    // default to the free tier" promise — the Agent-only seeding never ran on
+    // the real CLI path because buildAgent() always passes a config).
+    const seeded = firstRunSeedFree();
+    try {
+        saveConfig(seeded.config);
+    }
+    catch {
+        /* read-only home — the in-memory seed still works this session */
     }
-    return { ...exports.DEFAULT_CONFIG };
+    return seeded.config;
 }
 function saveConfig(config) {
     (0, paths_1.ensureDirs)();