agen-vektor 0.3.29 → 0.3.31

package/README.md

@@ -471,6 +471,10 @@ secrets stay private):
 
 ## Changelog
 
+### 0.3.30
+- **Thinking card matches Freebuff `thinking.tsx` exactly — no mid-run color flip-flop.** The reasoning body renders muted (`#acb3bf`) italic in BOTH streaming and completed states; only the header (dot + bold "Thinking") is foreground-white. Previously the body flipped from white (streaming) to muted (done), which read as the card changing color during a run.
+- **Expanded thinking view is raw muted italic with word wrap.** The in-card markdown re-render was removed — headings/inline code no longer paint their own colors inside the card (the mixed-color expanded view read as noise). Markdown markers in reasoning now show as-is, uniformly styled.
+
 ### 0.3.15
 - **Thinking cards are segmented per completed agent step.** Reasoning for each step (think → tool → think → tool) now renders as its own `• Thinking` card instead of stacking every step's reasoning into one ever-growing card — stale reasoning no longer appears to "leak" below the live thinking preview during multi-step tasks like web research.
 - Streaming answers keep the guarded `mergeStreamDelta` accumulation across all providers (no more doubled final text on gateways that resend the full text).

package/dist/agent/agent.js

@@ -5,6 +5,7 @@ const factory_1 = require("../providers/factory");
 const registry_1 = require("../tools/registry");
 const filesystem_1 = require("../tools/filesystem");
 const search_1 = require("../tools/search");
+const semantic_search_1 = require("../tools/semantic-search");
 const shell_1 = require("../tools/shell");
 const git_1 = require("../tools/git");
 const web_1 = require("../tools/web");
@@ -59,6 +60,9 @@ class Agent {
         this.tools.registerMany([
             ...(0, filesystem_1.createFilesystemTools)(),
             ...(0, search_1.createSearchTools)(),
+            // Semantic code search (via gateway embeddings relay): semantic_index /
+            // semantic_search — cari kode by MEANING, zero-config (key di gateway).
+            ...(0, semantic_search_1.createSemanticSearchTools)(),
             (0, shell_1.createShellTool)(),
             (0, git_1.createGitTool)(),
             ...(0, web_1.createWebTools)(),

package/dist/tools/semantic-search.js

@@ -0,0 +1,276 @@
+"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.createSemanticSearchTools = createSemanticSearchTools;
+/**
+ * Semantic code search — "agent yang hafal codebase" (2026-09-14).
+ *
+ * Alur: chunk file proyek → embedding via GATEWAY relay (/v1/embeddings,
+ * zero-config & zero-key — key provider sk- hidup di gateway, pola sama
+ * dengan e2b.ts/web.ts) → simpan vektor di file lokal (~/.vector/index.json)
+ * → cosine similarity saat query → top-k potongan paling relevan.
+ *
+ * Zero dependency: embedding = HTTP call, similarity = dot product manual,
+ * storage = satu file JSON. Index dibangun manual via tool semantic_index
+ * (atau otomatis saat semantic_search pertama tanpa index).
+ *
+ * Batas wajar (anti-abuse & anti-bloat):
+ * - max file 400 (arg hingga 2000), skip >200KB & file binary-ish
+ * - max chunk 4000; batch embedding 16 input/request; jeda antar-batch
+ *   1.1s (rate limit gateway 60/menit — env VECTOR_EMBED_DELAY_MS utk test)
+ * - skip nama file sensitif (credential/secret/.env/key/pem) — index tidak
+ *   boleh jadi salinan rahasia
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const free_tier_1 = require("../config/free-tier");
+const paths_1 = require("../utils/paths");
+const GW_BASE = free_tier_1.FREE_GATEWAY_URL.replace(/\/v1$/, '');
+const EMBED_URL = GW_BASE + '/v1/embeddings';
+const DEFAULT_EMBED_MODEL = 'text-embedding-v4';
+const IGNORE = new Set(['.git', 'node_modules', 'vendor', 'dist', 'build', '.cache', '.next', 'target', 'coverage', 'sessions', 'logs', 'memory']);
+const TEXT_EXT = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json', '.md', '.py', '.go', '.rs', '.java', '.rb', '.php', '.sh', '.bash', '.yml', '.yaml', '.toml', '.html', '.css', '.scss', '.sql', '.c', '.h', '.cpp', '.hpp', '.cs', '.swift', '.kt', '.txt', '.dockerfile', '.ini', '.cfg']);
+const SENSITIVE = /credential|secret|\.env|\.pem|\.key|id_rsa|password/i;
+const MAX_FILE_BYTES = 200_000;
+const MAX_FILES_DEFAULT = 400;
+const MAX_FILES_HARD = 2000;
+const MAX_CHUNKS = 4000;
+const CHUNK_LINES = 64;
+const BATCH = 16;
+const DELAY_MS = Math.max(0, Number(process.env.VECTOR_EMBED_DELAY_MS ?? 1100));
+function indexPath() {
+    return path.join((0, paths_1.getVectorDir)(), 'index.json');
+}
+function loadIndex() {
+    try {
+        const raw = fs.readFileSync(indexPath(), 'utf8');
+        const j = JSON.parse(raw);
+        return j && j.version === 1 && Array.isArray(j.chunks) ? j : null;
+    }
+    catch {
+        return null;
+    }
+}
+function saveIndex(idx) {
+    fs.mkdirSync((0, paths_1.getVectorDir)(), { recursive: true });
+    fs.writeFileSync(indexPath(), JSON.stringify(idx), { mode: 0o600 });
+}
+function walkFiles(dir, out, max) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        if (out.length >= max)
+            return;
+        if (IGNORE.has(e.name) || e.name.startsWith('.'))
+            continue;
+        if (SENSITIVE.test(e.name))
+            continue;
+        const full = path.join(dir, e.name);
+        if (e.isDirectory())
+            walkFiles(full, out, max);
+        else if (TEXT_EXT.has(path.extname(e.name).toLowerCase()) || e.name === 'Dockerfile')
+            out.push(full);
+    }
+}
+function chunkText(content) {
+    const lines = content.split('\n');
+    const chunks = [];
+    for (let i = 0; i < lines.length && chunks.length < MAX_CHUNKS; i += CHUNK_LINES) {
+        const slice = lines.slice(i, i + CHUNK_LINES);
+        const text = slice.join('\n').trim();
+        if (text)
+            chunks.push({ start: i + 1, end: i + slice.length, text });
+    }
+    return chunks;
+}
+async function embed(inputs, model) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 30_000);
+    try {
+        const res = await fetch(EMBED_URL, {
+            method: 'POST',
+            signal: controller.signal,
+            headers: { 'Content-Type': 'application/json', 'User-Agent': 'VectorHead-AI-Agent/0.1' },
+            body: JSON.stringify({ model, input: inputs }),
+        });
+        const data = await res.json().catch(() => null);
+        if (!res.ok || !data || !Array.isArray(data.data)) {
+            const snippet = data && data.error ? JSON.stringify(data.error).slice(0, 200) : `HTTP ${res.status}`;
+            throw new Error(`gateway embeddings gagal: ${snippet}`);
+        }
+        // OpenAI format: data[i].embedding — urut by index utk aman.
+        const sorted = [...data.data].sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+        return sorted.map((d) => d.embedding);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function cosine(a, b) {
+    let dot = 0, na = 0, nb = 0;
+    const n = Math.min(a.length, b.length);
+    for (let i = 0; i < n; i++) {
+        dot += a[i] * b[i];
+        na += a[i] * a[i];
+        nb += b[i] * b[i];
+    }
+    return na && nb ? dot / (Math.sqrt(na) * Math.sqrt(nb)) : 0;
+}
+async function buildIndex(root, maxFiles) {
+    const files = [];
+    walkFiles(root, files, maxFiles);
+    if (!files.length)
+        return `ERROR: tidak ada file teks yang bisa di-index di ${root}`;
+    const model = DEFAULT_EMBED_MODEL;
+    const chunks = [];
+    for (const full of files) {
+        let content;
+        try {
+            if (fs.statSync(full).size > MAX_FILE_BYTES)
+                continue;
+            content = fs.readFileSync(full, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        if (content.includes('\u0000'))
+            continue; // binary-ish
+        const rel = path.relative(root, full).split(path.sep).join('/');
+        for (const c of chunkText(content))
+            chunks.push({ file: rel, ...c, embedding: [] });
+    }
+    if (!chunks.length)
+        return 'ERROR: tidak ada chunk yang bisa di-index';
+    for (let i = 0; i < chunks.length; i += BATCH) {
+        const vecs = await embed(chunks.slice(i, i + BATCH).map((c) => c.text), model);
+        if (vecs.length !== Math.min(BATCH, chunks.length - i)) {
+            return `ERROR: jumlah vektor upstream tidak cocok (${vecs.length})`;
+        }
+        vecs.forEach((v, j) => { chunks[i + j].embedding = v; });
+        if (i + BATCH < chunks.length && DELAY_MS)
+            await sleep(DELAY_MS);
+    }
+    saveIndex({ version: 1, model, builtAt: Date.now(), chunks });
+    const preview = [...new Set(chunks.map((c) => c.file))].slice(0, 5).join(', ');
+    return `OK: index dibangun — ${chunks.length} chunk dari ${files.length} file (model ${model}) → ${indexPath()}${preview ? '\nContoh: ' + preview : ''}`;
+}
+function searchIndex(idx, queryVec, k) {
+    const scored = idx.chunks
+        .map((c) => ({ c, score: cosine(queryVec, c.embedding) }))
+        .sort((a, b) => b.score - a.score)
+        .slice(0, Math.max(1, k));
+    if (!scored.length || scored[0].score <= 0) {
+        return 'Tidak ada hasil relevan (index kosong / skor 0) — coba semantic_index ulang.';
+    }
+    const lines = scored.map((s, i) => {
+        const head = s.c.text.replace(/\s+/g, ' ').slice(0, 180);
+        return `${i + 1}. ${s.c.file}:${s.c.start}-${s.c.end} (skor ${s.score.toFixed(3)})\n   ${head}`;
+    });
+    return `Hasil semantic search (top ${scored.length} dari ${idx.chunks.length} chunk):\n${lines.join('\n')}`;
+}
+function createSemanticSearchTools() {
+    return [
+        {
+            definition: {
+                name: 'semantic_index',
+                description: 'Build/refresh the local semantic index: embed project files (via the VectorHead gateway, no API key needed) and store vectors in ~/.vector/index.json. Run once per project (or after big changes) — then semantic_search can find code by MEANING, not just keywords.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'Directory to index, relative to project root (default ".")' },
+                        max_files: { type: 'number', description: 'Max files to index (default 400, max 2000)' },
+                    },
+                    required: [],
+                },
+            },
+            async execute(args, ctx) {
+                const base = path.resolve(ctx.cwd, String(args.path || '.'));
+                const max = Math.min(MAX_FILES_HARD, Math.max(1, Number(args.max_files) || MAX_FILES_DEFAULT));
+                try {
+                    return { output: await buildIndex(base, max) };
+                }
+                catch (e) {
+                    return { output: 'ERROR: ' + String(e.message || e) };
+                }
+            },
+        },
+        {
+            definition: {
+                name: 'semantic_search',
+                description: 'Search the codebase by MEANING (semantic similarity over embedded chunks). Automatically builds the index first if none exists. Use for "where is the retry logic?" style questions where grep/keywords fail.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        query: { type: 'string', description: 'Natural-language query, e.g. "where do we validate the device id"' },
+                        k: { type: 'number', description: 'Max results (default 5, max 20)' },
+                        path: { type: 'string', description: 'Directory that was indexed (default ".")' },
+                    },
+                    required: ['query'],
+                },
+            },
+            async execute(args, ctx) {
+                const query = String(args.query || '').trim();
+                if (!query)
+                    return { output: 'ERROR: query wajib' };
+                const k = Math.min(20, Math.max(1, Number(args.k) || 5));
+                try {
+                    let idx = loadIndex();
+                    if (!idx) {
+                        const base = path.resolve(ctx.cwd, String(args.path || '.'));
+                        const built = await buildIndex(base, MAX_FILES_DEFAULT);
+                        if (built.startsWith('ERROR'))
+                            return { output: built };
+                        idx = loadIndex();
+                        if (!idx)
+                            return { output: 'ERROR: index gagal dibaca setelah build' };
+                    }
+                    const [qv] = await embed([query], idx.model || DEFAULT_EMBED_MODEL);
+                    if (!qv)
+                        return { output: 'ERROR: embedding query kosong' };
+                    return { output: searchIndex(idx, qv, k) };
+                }
+                catch (e) {
+                    return { output: 'ERROR: ' + String(e.message || e) };
+                }
+            },
+        },
+    ];
+}

package/dist/tui/app.js

@@ -3051,7 +3051,9 @@ class App {
                 continue;
             const args = (m.content.split('\n')[0] || '').trim();
             const head = `${(0, chat_1.toolIcon)(m.tool)} ${theme_1.THEME.bold}${(0, chat_1.toolLabel)(m.tool)}${theme_1.THEME.reset}`;
-            const line = args ? `${head} ${theme_1.THEME.faint}${args}${theme_1.THEME.reset}` : head;
+            // Freebuff SimpleToolCallItem: description in the FOREGROUND (white),
+            // not faint — the panel is a live indicator, dark gray read as junk.
+            const line = args ? `${head} ${theme_1.THEME.textBright}${args}${theme_1.THEME.reset}` : head;
             out.unshift((0, terminal_1.truncate)(line, inner));
         }
         return out;
@@ -3168,6 +3170,16 @@ class App {
         const visible = (0, chat_1.chatWindow)(all, this.scroll, chatH);
         const chatTop = 2;
         const sepRow = chatTop + chatH;
+        // Responsive content width (Freebuff use-terminal-dimensions.ts
+        // separatorWidth = terminal − 2): EVERY structural element — separator,
+        // tool panel, input box — spans exactly cols − 2 with a 1-col margin on
+        // BOTH sides (symmetric). Dulu separator di-cap 120 kolom sementara input
+        // box full-width → di terminal lebar garis ─ tidak lurus dengan box di
+        // bawahnya, dan box menempel ke tepi sementara teks chat ber-gutter 1
+        // kolom ("sisi sama sisi tidak seimbang"). Chat rows carry the same
+        // 1-col SIDE_GUTTER, so text column == box outer width == frameW.
+        const frameW = Math.max(10, cols - 2);
+        const frameIndent = ' ';
         const toolRows = this.toolPanelRows(cols);
         const activityH = toolRows.length > 0 ? toolRows.length + 2 : 0;
         const suggestH = this.suggestHeight();
@@ -3177,9 +3189,9 @@ class App {
         // blank row, input (vertically centered), blank row, bottom border.
         // Slash suggestions render between the tool panel and the box.
         const boxTop = sepRow + activityH + suggestH + 1;
-        const boxBot = boxTop + this.input.wrappedRows(cols) + 3;
+        const boxBot = boxTop + this.input.wrappedRows(frameW) + 3;
         const statusRow = boxBot + 1;
-        const rendered = this.input.render(cols, input_1.DEFAULT_PLACEHOLDER);
+        const rendered = this.input.render(frameW, input_1.DEFAULT_PLACEHOLDER);
         // Cursor row: prompt line 0 DILUKIS di boxTop + 1 (border ╭ di boxTop−1,
         // blank padding di boxTop). Dulu +2 menaruh kursor hardware SATU BARIS di
         // bawah teks prompt — baris kosong dasar box, tepat di atas bar "Build •
@@ -3187,26 +3199,27 @@ class App {
         // YOLO" (laporan user 2026-09-07). Kursor hardware sendiri kini SELALU
         // hidden (lihat doRender di cli/index.ts); posisi tetap diperbaiki agar
         // benar untuk audit/bounds.
-        const cursorCol = rendered.cursorCol + 1;
+        // +2: 1-col frame indent + 1 left border column.
+        const cursorCol = rendered.cursorCol + 2;
         const cursorRow = boxTop + 1 + rendered.cursorRow;
         const frame = new Array(rows).fill('');
         frame[0] = (0, statusbar_1.renderHeader)(cols, info);
         for (let i = 0; i < chatH; i++) {
             frame[chatTop - 1 + i] = visible[i] !== undefined ? visible[i] : '';
         }
-        frame[sepRow - 1] = theme_1.THEME.border + terminal_1.BOX.h.repeat(Math.min(cols, 120)) + theme_1.THEME.reset;
+        frame[sepRow - 1] = frameIndent + theme_1.THEME.border + terminal_1.BOX.h.repeat(frameW) + theme_1.THEME.reset;
         // Boxed tool-call panel: `· Tool args` lines (last TOOL_PANEL_ROWS calls)
         // inside a rounded box, directly above the chat prompt — mirrors the
         // committed README example instead of a plain unboxed strip.
         if (activityH > 0) {
             const toolBorder = `${theme_1.THEME.bold}${theme_1.THEME.textBright}`;
-            frame[sepRow] = `${toolBorder}╭${terminal_1.BOX.h.repeat(Math.max(0, cols - 2))}╮${theme_1.THEME.reset}`;
+            frame[sepRow] = `${frameIndent}${toolBorder}╭${terminal_1.BOX.h.repeat(Math.max(0, frameW - 2))}╮${theme_1.THEME.reset}`;
             for (let i = 0; i < toolRows.length; i++) {
                 const line = toolRows[i];
-                const pad = Math.max(0, cols - 2 - (0, terminal_1.visibleWidth)(line));
-                frame[sepRow + 1 + i] = `${toolBorder}│${theme_1.THEME.reset}${line}${' '.repeat(pad)}${toolBorder}│${theme_1.THEME.reset}`;
+                const pad = Math.max(0, frameW - 2 - (0, terminal_1.visibleWidth)(line));
+                frame[sepRow + 1 + i] = `${frameIndent}${toolBorder}│${theme_1.THEME.reset}${line}${' '.repeat(pad)}${toolBorder}│${theme_1.THEME.reset}`;
             }
-            frame[sepRow + toolRows.length + 1] = `${toolBorder}╰${terminal_1.BOX.h.repeat(Math.max(0, cols - 2))}╯${theme_1.THEME.reset}`;
+            frame[sepRow + toolRows.length + 1] = `${frameIndent}${toolBorder}╰${terminal_1.BOX.h.repeat(Math.max(0, frameW - 2))}╯${theme_1.THEME.reset}`;
         }
         // Freebuff-style slash command popup (when typing `/…`). The reserved
         // height IS the render budget: suggestHeight already fits the whole
@@ -3220,17 +3233,17 @@ class App {
         }
         // Freebuff renders the input box border in the foreground color (white).
         const boxBorder = `${theme_1.THEME.bold}${theme_1.THEME.textBright}`;
-        frame[boxTop - 1] = `${boxBorder}╭${terminal_1.BOX.h.repeat(Math.max(0, cols - 2))}╮${theme_1.THEME.reset}`;
+        frame[boxTop - 1] = `${frameIndent}${boxBorder}╭${terminal_1.BOX.h.repeat(Math.max(0, frameW - 2))}╮${theme_1.THEME.reset}`;
         // Vertical padding (Freebuff chat-input-bar): one blank content row
         // above and below the wrapped prompt lines.
-        const blankRow = `${boxBorder}│${theme_1.THEME.reset}${' '.repeat(Math.max(0, cols - 2))}${boxBorder}│${theme_1.THEME.reset}`;
+        const blankRow = `${frameIndent}${boxBorder}│${theme_1.THEME.reset}${' '.repeat(Math.max(0, frameW - 2))}${boxBorder}│${theme_1.THEME.reset}`;
         frame[boxTop] = blankRow;
         for (let i = 0; i < rendered.lines.length; i++) {
-            frame[boxTop + 1 + i] = `${boxBorder}│${theme_1.THEME.reset}${rendered.lines[i]}${boxBorder}│${theme_1.THEME.reset}`;
+            frame[boxTop + 1 + i] = `${frameIndent}${boxBorder}│${theme_1.THEME.reset}${rendered.lines[i]}${boxBorder}│${theme_1.THEME.reset}`;
         }
         for (let i = boxTop + 1 + rendered.lines.length; i < boxBot - 1; i++)
             frame[i] = blankRow;
-        frame[boxBot - 1] = `${boxBorder}╰${terminal_1.BOX.h.repeat(Math.max(0, cols - 2))}╯${theme_1.THEME.reset}`;
+        frame[boxBot - 1] = `${frameIndent}${boxBorder}╰${terminal_1.BOX.h.repeat(Math.max(0, frameW - 2))}╯${theme_1.THEME.reset}`;
         frame[statusRow - 1] = (0, statusbar_1.renderStatusBar)(cols, info);
         // OpenCode single-buffer compositing: the modal overlay is composed INTO
         // the frame rows so the incremental renderer can row-diff while a dialog

package/dist/tui/chat.js

@@ -126,6 +126,21 @@ const TOOL_LABELS = {
 function toolLabel(tool) {
     return (tool && TOOL_LABELS[tool]) || tool || 'tool';
 }
+/**
+ * Tool-card description color — Freebuff tools/*.tsx parity:
+ * SimpleToolCallItem paints the description with theme.foreground (white)
+ * unless the tool overrides it: read-url.tsx → theme.muted (#acb3bf),
+ * list-directory.tsx → theme.directory (#9CA3AF). The old renderer painted
+ * EVERY description with faint #6b7280 (gray-500) — read as a dark smudge
+ * next to the white tool name ("Read Url · Glob · List masih gelap").
+ */
+const TOOL_DESC_COLOR = {
+    web_fetch: theme_1.THEME.muted,
+    list_directory: theme_1.THEME.directory,
+};
+function toolDescColor(tool) {
+    return (tool && TOOL_DESC_COLOR[tool]) || theme_1.THEME.textBright;
+}
 /** The suggest_followups batch carried by a 'followup' message, if any. */
 function followupsGroupOf(m) {
     if (m.kind !== 'followup')
@@ -147,6 +162,30 @@ function formatTimeout(timeoutSeconds) {
         return `${r / 60}m timeout`;
     return `${r}s timeout`;
 }
+/**
+ * Strip PAIRED inline markdown markers for plain-text surfaces (thinking
+ * preview): `**bold**`/`__bold__` → bold, `*emph*`/`_emph_` → emph,
+ * `` `code` `` → code, `~~strike~~` → plain. UNPAIRED leftovers (a lone `
+ * backtick or asterisk pair still open mid-stream) are dropped so no
+ * "sampah kutipan" sticks to the words. Whitespace collapses back cleanly.
+ */
+function stripPairedMarkdown(text) {
+    let out = text;
+    for (let pass = 0; pass < 2; pass++) {
+        // Pairs first (non-greedy, same line semantics).
+        out = out
+            .replace(/\*\*([^*\n]+)\*\*/g, '$1')
+            .replace(/__([^_\n]+)__/g, '$1')
+            .replace(/(^|[^*])\*([^*\n]+)\*(?!\*)/g, '$1$2')
+            .replace(/(^|[^\w_])_([^_\n]+)_(?!\w)/g, '$1$2')
+            .replace(/~~([^~\n]+)~~/g, '$1')
+            .replace(/`([^`\n]+)`/g, '$1');
+    }
+    // Unpaired leftovers — only chars that would EVER render literal junk.
+    out = out.replace(/^[*`~]+/, '').replace(/[*`~]+$/, '');
+    out = out.replace(/\s*[*`~]\s*/g, ' ').replace(/ {2,}/g, ' ');
+    return out.trim();
+}
 /** 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));
@@ -959,11 +998,15 @@ function renderMessage(m, width, seenGroups, seenCallIds) {
             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.
+            // Compact block (Freebuff tool-call-item.tsx parity): bullet + BOLD
+            // tool name in the foreground, description in the tool's own color
+            // (white by default — read-url muted, list directory), then the result
+            // preview in muted ITALIC (Freebuff ToolCallItem collapsed preview:
+            // `fg={isStreaming ? foreground : muted}` + ITALIC). The old all-faint
+            // #6b7280 rendering read as dark gray junk under the white label.
             const icon = toolIcon(m.tool);
             const parts = body.split('\n');
-            const first = `${icon} ${theme_1.THEME.bold}${toolLabel(m.tool)}${theme_1.THEME.reset} ${theme_1.THEME.faint}${(parts[0] || '').trim()}${theme_1.THEME.reset}`;
+            const first = `${icon} ${theme_1.THEME.bold}${toolLabel(m.tool)}${theme_1.THEME.reset} ${toolDescColor(m.tool)}${(parts[0] || '').trim()}${theme_1.THEME.reset}`;
             if (first.trim()) {
                 for (const line of (0, terminal_1.wrapText)(first, width))
                     out.push(line);
@@ -971,7 +1014,7 @@ function renderMessage(m, width, seenGroups, seenCallIds) {
             const rest = parts.slice(1).filter((l) => l.trim());
             if (rest.length > 0) {
                 for (const line of (0, terminal_1.wrapText)(rest.join('\n'), Math.max(4, width - 2))) {
-                    out.push(`${theme_1.THEME.faint}${line}${theme_1.THEME.reset}`);
+                    out.push(`${theme_1.THEME.muted}${theme_1.THEME.italic}${line}${theme_1.THEME.reset}`);
                 }
             }
             return out;
@@ -1036,14 +1079,19 @@ function renderMessage(m, width, seenGroups, seenCallIds) {
             if (singleBoldMatch)
                 return out;
             const complete = !m.streaming;
-            // 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.
+            // Models (GLM/DeepSeek reasoning) often write MARKDOWN inside their
+            // reasoning — raw `**`, backticks and `#` used to leak onto the card as
+            // literal junk ("banyak kutipan seperti sampah"). Freebuff never shows
+            // markers: its renderer CONSUMES them. Mirror that:
+            //   preview  → strip PAIRED markers (bold/italic/code), collapse unpaired
+            //              leftovers (a lone ` or ** mid-stream must not stick out),
+            //              keep words intact;
+            //   expanded → render through the SAME markdown engine as the chat
+            //              (splitMarkdown consumes **bold**, *emph*, `code`, # heads,
+            //              > quotes, lists) so nothing literal survives.
             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 normalizedContent = stripPairedMarkdown(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();
@@ -1054,19 +1102,33 @@ function renderMessage(m, width, seenGroups, seenCallIds) {
             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;
+            // Body color — Freebuff thinking.tsx EXACT: the preview text element
+            // paints `fg: theme.muted` + TextAttributes.ITALIC in BOTH states
+            // (streaming AND completed); expanded paints the same muted italic
+            // with wrapMode 'word'. There is NO white reasoning state in Freebuff —
+            // the previous "streaming = textBright" flip-flop read as the card
+            // changing color mid-run ("warna thinking masih sama tidak berubah /
+            // makin kacau"). The HEADER (dot + bold label) is the only
+            // foreground-white part of the card.
+            const thinkBody = `${theme_1.THEME.muted}${theme_1.THEME.italic}`;
             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)) {
+                    for (const w of (0, terminal_1.wrapText)(`${thinkBody}${body}${theme_1.THEME.reset}`, bodyCols)) {
                         out.push(`  ${w}`);
                     }
                 }
             }
             if (showFull) {
+                // Expanded — Freebuff thinking.tsx EXACT: the SAME muted italic body,
+                // raw content with original line breaks (wrapMode 'word'). Plain wrap,
+                // NO markdown re-render: the markdown engine paints headings/inline
+                // code in their own colors inside a card whose body must stay uniformly
+                // muted italic (the mixed-color expanded card read as "kacau").
                 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)) {
+                    for (const w of (0, terminal_1.wrapText)(`${thinkBody}${line}${theme_1.THEME.reset}`, bodyCols)) {
                         out.push(`  ${w}`);
                     }
                 }

package/dist/tui/themes.js

@@ -138,9 +138,31 @@ function resolveValue(spec, value, mode, bg, visited) {
         return resolveValue(spec, next, mode, bg, visited);
     return null; // unknown reference → keep the slot default
 }
+/**
+ * THEME slots a theme may NOT override — the chat TEXT legibility core.
+ * Freebuff renders message text with its foreground palette in BOTH its dark
+ * and light theme (user-content is never dark-on-dark), so a custom theme
+ * with dark/near-background `text`/`textMuted` values must not be able to
+ * turn chat prose, reasoning or tool output into an unreadable smudge.
+ * Everything else (accent, borders, headings, code chips…) stays themeable.
+ */
+const LOCKED_SLOTS = new Set([
+    'text',
+    'textBright',
+    'muted',
+    'faint',
+    'quoteText',
+    'code',
+]);
 /** Apply a parsed ThemeSpec onto THEME (values that resolve win). */
 function applySpec(spec, mode = 'dark') {
     for (const slot of Object.keys(SLOT_KEYS)) {
+        // Chat-body slots keep their Freebuff defaults: custom themes (e.g.
+        // solarized/gold dumps) mapped `text` to a dark base color and the chat
+        // turned near-invisible. Locked = theme colors are for CHROME, not for
+        // the words themselves.
+        if (LOCKED_SLOTS.has(slot))
+            continue;
         for (const key of SLOT_KEYS[slot]) {
             const raw = spec.theme[key];
             if (raw === undefined)

package/package.json

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