agen-vektor 0.3.31 → 0.3.33

package/README.md

@@ -471,6 +471,11 @@ secrets stay private):
 
 ## Changelog
 
+### 0.3.33
+- **Boot splash "Loading System . . ." before the TUI dashboard.** Launching `vector` now shows a brief boot screen — brand banner, three loading steps (Config → Environment → Provider), a braille spinner and progress bar, then "System ready" — before the whole block is cleanly erased and the chat TUI enters alt-screen. Zero scrollback residue.
+- **Zero dependencies, Termux-safe.** The splash follows `VECTOR_ASCII` (spinner becomes `|/-\` in ASCII safe mode), never blocks process exit (timer is unref'd), and failure to build the agent still clears the splash before the error propagates.
+- **Controls:** `VECTOR_SPLASH=0` disables it entirely; `VECTOR_SPLASH_STEP_MS` (default 450) and `VECTOR_SPLASH_HOLD_MS` (default 900) tune the timing.
+
 ### 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.

package/dist/agent/checkpoints.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.takeCheckpoint = takeCheckpoint;
+exports.takeCheckpointAsync = takeCheckpointAsync;
 exports.listCheckpoints = listCheckpoints;
 exports.restoreCheckpoint = restoreCheckpoint;
 exports.pruneCheckpoints = pruneCheckpoints;
@@ -63,6 +64,17 @@ exports.resetCheckpoints = resetCheckpoints;
  * - Everything is best-effort: a missing git binary or a read-only home must
  *   NEVER break a run. All failures resolve to null/empty and the run
  *   proceeds without a safety net.
+ *
+ * Latency rules (bug "mentok di Edit", 2026-09-15):
+ * - The agent loop uses takeCheckpointAsync (off the event loop) so the TUI
+ *   keeps painting while a big tree is scanned; the tool card renders BEFORE
+ *   the snapshot starts (loop.ts), never behind it.
+ * - node_modules / .vector / .git are excluded from BOTH the size-count walk
+ *   and the actual `git add` (pathspec excludes) — a bare /root work-tree
+ *   used to stage 84k files ≈ 41s per snapshot and ballooned the shadow repo
+ *   to 521 MB.
+ * - Work-trees above CP_MAX_FILES candidate files skip the snapshot entirely:
+ *   the net costs more than it protects there.
  */
 const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
@@ -82,9 +94,122 @@ function gitDirFor(cwd) {
     return path.join((0, paths_1.getVectorDir)(), 'checkpoints', slug);
 }
 function git(gitDir, args, workTree) {
-    const r = (0, node_child_process_1.spawnSync)(GIT, [`--git-dir=${gitDir}`, ...(workTree ? [`--work-tree=${workTree}`] : []), ...args], { encoding: 'utf8', timeout: 20_000 });
+    const r = (0, node_child_process_1.spawnSync)(GIT, [`--git-dir=${gitDir}`, ...(workTree ? [`--work-tree=${workTree}`] : []), ...args], 
+    // cwd MUST be the work-tree when one is set: git resolves relative
+    // pathspecs (our `:(exclude)` patterns) against the process cwd — from a
+    // different directory the excludes silently stop matching (probe-proven).
+    { encoding: 'utf8', timeout: 20_000, ...(workTree ? { cwd: workTree } : {}) });
     return { ok: r.status === 0, out: (r.stdout || '') + (r.stderr || '') };
 }
+/** Async variant of `git(...)` — the child runs off the event loop so the
+ * TUI keeps rendering while a big snapshot scans the tree. 120s timeout
+ * (a slow disk scanning 100k+ files must not wedge the run forever). */
+function gitAsync(gitDir, args, workTree) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = (0, node_child_process_1.spawn)(GIT, [`--git-dir=${gitDir}`, ...(workTree ? [`--work-tree=${workTree}`] : []), ...args], 
+            // Same cwd rule as git(): relative pathspecs resolve against cwd.
+            { stdio: ['ignore', 'pipe', 'pipe'], ...(workTree ? { cwd: workTree } : {}) });
+        }
+        catch {
+            resolve({ ok: false, out: 'spawn failed' });
+            return;
+        }
+        let out = '';
+        let done = false;
+        const finish = (ok, tail) => {
+            if (done)
+                return;
+            done = true;
+            resolve({ ok, out: out.slice(-4000) + tail });
+        };
+        const timer = setTimeout(() => {
+            try {
+                child.kill('SIGKILL');
+            }
+            catch {
+                /* ignore */
+            }
+            finish(false, '\ngit timeout');
+        }, 120_000);
+        child.stdout?.on('data', (d) => {
+            out += d.toString();
+            if (out.length > 4096)
+                out = out.slice(-2048); // bounded
+        });
+        child.stderr?.on('data', (d) => {
+            out += d.toString();
+            if (out.length > 4096)
+                out = out.slice(-2048);
+        });
+        child.on('error', () => {
+            clearTimeout(timer);
+            finish(false, '\nspawn error');
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            finish(code === 0, code === 0 ? '' : `\nexit ${code}`);
+        });
+    });
+}
+/**
+ * Folders the safety net should NEVER track even when the project has no
+ * .gitignore of its own: dependency folders and vector's own state (a
+ * ~/.vector tree inside the work-tree would make the snapshot
+ * self-referential and explode the object store — seen live: 521 MB shadow
+ * repo for /root).
+ */
+const CP_EXCLUDE = ['node_modules', '.vector', '.git'];
+/** Upper bound on work-tree scan size: beyond this, snapshotting takes
+ * minutes (VPS bench: 84k files = 41s per run) and the safety net costs
+ * more than it protects — skip with a clear reason instead. */
+const CP_MAX_FILES = 20_000;
+function countCandidateFiles(cwd) {
+    try {
+        let n = 0;
+        const walk = (dir, depth) => {
+            if (depth > 12 || n > CP_MAX_FILES)
+                return;
+            let entries;
+            try {
+                entries = fs.readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const e of entries) {
+                if (CP_EXCLUDE.includes(e.name))
+                    continue;
+                if (e.isDirectory())
+                    walk(path.join(dir, e.name), depth + 1);
+                else if (e.isFile()) {
+                    n++;
+                    if (n > CP_MAX_FILES)
+                        return;
+                }
+            }
+        };
+        walk(cwd, 0);
+        return n;
+    }
+    catch {
+        return null;
+    }
+}
+/** `git add -A` arguments with the exclude pathspecs applied. Runs with
+ * cwd = work-tree (see git()/gitAsync()), so the excludes are RELATIVE to
+ * the work-tree root: the bare name excludes the top-level folder and the
+ * trailing-slash glob excludes nested ones (git 2.43 probe-verified — the
+ * glob alone misses the root folder). */
+function addArgs() {
+    const excludes = [];
+    for (const d of CP_EXCLUDE) {
+        excludes.push(`:(exclude)${d}`);
+        excludes.push(`:(exclude)**/${d}/`);
+    }
+    return ['add', '-A', '--', '.', ...excludes];
+}
 function ensureShadowRepo(gitDir) {
     try {
         if (!fs.existsSync(path.join(gitDir, 'HEAD'))) {
@@ -104,9 +229,24 @@ function ensureShadowRepo(gitDir) {
         return false;
     }
 }
+function stampRef(reason, task) {
+    const stamp = new Date();
+    const pad = (n) => String(n).padStart(2, '0');
+    const t = `${stamp.getFullYear()}${pad(stamp.getMonth() + 1)}${pad(stamp.getDate())}` +
+        `-${pad(stamp.getHours())}${pad(stamp.getMinutes())}${pad(stamp.getSeconds())}`;
+    const suffix = (cpSeq++).toString(36).padStart(4, '0');
+    const ref = `cp-${t}-${suffix}`;
+    const msg = `checkpoint ${ref} (${reason}) ${task.slice(0, 80)}`.trim();
+    return { ref, time: stamp.toISOString(), msg, stamp };
+}
+function parseHash(out) {
+    const hash = out.trim().split('\n')[0]?.trim() ?? '';
+    return /^[0-9a-f]{40}$/.test(hash) ? hash : null;
+}
 /**
- * Take a checkpoint. Returns null when snapshotting is impossible — callers
- * must treat that as "no safety net", never as an error.
+ * Take a checkpoint (SYNC legacy path). Returns null when snapshotting is
+ * impossible — callers must treat that as "no safety net", never as an
+ * error. The agent loop uses the async variant below.
  */
 function takeCheckpoint(cwd, reason, task = '') {
     try {
@@ -115,35 +255,79 @@ function takeCheckpoint(cwd, reason, task = '') {
         const gitDir = gitDirFor(cwd);
         if (!ensureShadowRepo(gitDir))
             return null;
-        // -A stages the full tree incl. deletions and untracked files. A
-        // .gitignore in the user's project is respected (their intent), but
-        // that also means ignored files are NOT protected by checkpoints —
-        // documented trade-off, same as Claude Code.
-        if (!git(gitDir, ['add', '-A', '--'], cwd).ok)
+        // -A stages the full tree incl. deletions and untracked files, minus the
+        // CP_EXCLUDE folders (pathspec excludes). A .gitignore in the user's
+        // project is respected (their intent), but that also means ignored files
+        // are NOT protected by checkpoints — documented trade-off, same as
+        // Claude Code.
+        if (!git(gitDir, addArgs(), cwd).ok)
             return null;
         const tree = git(gitDir, ['write-tree']);
         if (!tree.ok)
             return null;
-        const treeHash = tree.out.trim().split('\n')[0].trim();
-        if (!/^[0-9a-f]{40}$/.test(treeHash))
+        const treeHash = parseHash(tree.out);
+        if (!treeHash)
             return null;
-        const stamp = new Date();
-        const pad = (n) => String(n).padStart(2, '0');
-        const t = `${stamp.getFullYear()}${pad(stamp.getMonth() + 1)}${pad(stamp.getDate())}` +
-            `-${pad(stamp.getHours())}${pad(stamp.getMinutes())}${pad(stamp.getSeconds())}`;
-        const suffix = (cpSeq++).toString(36).padStart(4, '0');
-        const ref = `cp-${t}-${suffix}`;
-        const msg = `checkpoint ${ref} (${reason}) ${task.slice(0, 80)}`.trim();
+        const { ref, time, msg } = stampRef(reason, task);
         // Independent root commit — commit-tree gives full control over parents.
         const commit = git(gitDir, ['commit-tree', treeHash, '-m', msg]);
         if (!commit.ok)
             return null;
-        const hash = commit.out.trim().split('\n')[0].trim();
-        if (!/^[0-9a-f]{40}$/.test(hash))
+        const hash = parseHash(commit.out);
+        if (!hash)
             return null;
         if (!git(gitDir, ['update-ref', `${REF_PREFIX}${ref}`, hash]).ok)
             return null;
-        return { ref, time: stamp.toISOString(), reason, task: task.slice(0, 80), hash };
+        return { ref, time, reason, task: task.slice(0, 80), hash };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * ASYNC checkpoint for the agent loop: same guarantees as takeCheckpoint,
+ * but the git child processes run off the event loop so the TUI keeps
+ * painting (Working line, spinner) while a big tree is scanned. Additional
+ * guards the sync version never had:
+ * - skip when the work-tree exceeds CP_MAX_FILES candidate files,
+ * - prune old refs after a successful snapshot so the shadow repo stays
+ *   bounded (seen live: 521 MB after a week without pruning).
+ */
+async function takeCheckpointAsync(cwd, reason, task = '') {
+    try {
+        if (!fs.existsSync(cwd))
+            return null;
+        const n = countCandidateFiles(cwd);
+        if (n !== null && n > CP_MAX_FILES)
+            return null;
+        const gitDir = gitDirFor(cwd);
+        if (!ensureShadowRepo(gitDir))
+            return null;
+        // -A stages the full tree incl. deletions and untracked files, minus
+        // CP_EXCLUDE via pathspec excludes (the candidate walk above is only
+        // the size guard; git itself must also skip the folders).
+        const add = await gitAsync(gitDir, addArgs(), cwd);
+        if (!add.ok)
+            return null;
+        const tree = await gitAsync(gitDir, ['write-tree']);
+        if (!tree.ok)
+            return null;
+        const treeHash = parseHash(tree.out);
+        if (!treeHash)
+            return null;
+        const { ref, time, msg } = stampRef(reason, task);
+        const commit = await gitAsync(gitDir, ['commit-tree', treeHash, '-m', msg]);
+        if (!commit.ok)
+            return null;
+        const hash = parseHash(commit.out);
+        if (!hash)
+            return null;
+        const upd = await gitAsync(gitDir, ['update-ref', `${REF_PREFIX}${ref}`, hash]);
+        if (!upd.ok)
+            return null;
+        // Bound the shadow repo: keep the newest MAX_CHECKPOINTS refs.
+        pruneCheckpoints(cwd);
+        return { ref, time, reason, task: task.slice(0, 80), hash };
     }
     catch {
         return null;

package/dist/agent/loop.js

@@ -146,15 +146,25 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
     // Best-effort: null = no net, the run proceeds regardless.
     const MUTATING_TOOLS = new Set(['write_file', 'edit_file', 'delete_file', 'apply_patch', 'shell', 'git', 'run_in_background']);
     let checkpointTaken = false;
+    // Snapshot is ASYNC and runs INSIDE runOne (after onToolCall): the tool
+    // card must appear IMMEDIATELY, never behind the snapshot. The old sync
+    // design (spawnSync before onToolCall) froze the TUI for the whole
+    // snapshot — on a big cwd that read as "mentok di Edit" for 40+ seconds
+    // (bench VPS: git add -A pada /root = 41s).
     const maybeCheckpoint = (toolName) => {
         if (checkpointTaken || !MUTATING_TOOLS.has(toolName))
-            return;
+            return Promise.resolve();
         checkpointTaken = true;
-        const cp = (0, checkpoints_1.takeCheckpoint)(cwd, toolName, userRequest);
-        if (cp) {
-            callbacks.onStatus?.(`Checkpoint siap (${cp.ref})`);
-            callbacks.onActivity?.('checkpoint', `safety snapshot ${cp.ref}`);
-        }
+        return (0, checkpoints_1.takeCheckpointAsync)(cwd, toolName, userRequest)
+            .then((cp) => {
+            if (cp) {
+                callbacks.onStatus?.(`Checkpoint siap (${cp.ref})`);
+                callbacks.onActivity?.('checkpoint', `safety snapshot ${cp.ref}`);
+            }
+        })
+            .catch(() => {
+            /* best-effort — never break the run */
+        });
     };
     const checkAbort = () => {
         if (signal?.aborted) {
@@ -399,7 +409,10 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
                 'output_from_background',
             ]);
             const runOne = async (tc) => {
+                // Tool card FIRST (visible instantly), snapshot AFTER — the card
+                // must never wait for the checkpoint git scan.
                 callbacks.onToolCall?.(tc.name, tc.arguments, tc.id);
+                const cpPromise = maybeCheckpoint(tc.name);
                 let toolResult;
                 try {
                     toolResult = await tools.execute(tc.name, tc.arguments, {
@@ -416,6 +429,9 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
                     // as a failed result so the TUI can finalize the card.
                     toolResult = { output: `ERROR: ${err.message}`, summary: 'tool error' };
                 }
+                // The run waits for the (async) safety net before the next model
+                // step, but the tool card above is already visible.
+                await cpPromise;
                 return { tc, toolResult };
             };
             try {
@@ -437,11 +453,9 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
                 for (const batch of batches) {
                     checkAbort();
                     const parallel = batch.length > 1 && batch.every((tc) => PARALLEL_TOOLS.has(tc.name));
-                    // Safety net BEFORE the first mutating call of this run — armed
-                    // once, lazily; parallel batches are read-only by construction and
-                    // never trigger it.
-                    if (!parallel)
-                        maybeCheckpoint(batch[0].name);
+                    // Safety net moved INSIDE runOne (after onToolCall) so the tool
+                    // card renders instantly; armed once per run, lazily. Parallel
+                    // batches are read-only by construction and never trigger it.
                     toolCalls += batch.length;
                     if (!parallel) {
                         callbacks.onStatus?.(`Running ${batch[0].name}`);

package/dist/cli/index.js

@@ -22,6 +22,7 @@ const factory_1 = require("../providers/factory");
 const paths_1 = require("../utils/paths");
 const logger_1 = require("../utils/logger");
 const keyboard_1 = require("./keyboard");
+const splash_1 = require("./splash");
 const terminal_1 = require("../utils/terminal");
 /** Disable auto-wrap margins (DECAWM off): a full-width row then CANNOT
  *  push the cursor into the pending-wrap state, so the next write can never
@@ -248,7 +249,21 @@ async function runTui(opts) {
         await runNonInteractive(opts);
         return;
     }
-    const agent = await buildAgent(opts);
+    // Boot splash "Loading System . . ." (additive, 2026-09-16): tampil
+    // sebelum buildAgent/loading dashboard; VECTOR_SPLASH=0 mematikan.
+    const splash = await (0, splash_1.runSplash)();
+    let agent;
+    try {
+        await splash.step('config dimuat');
+        agent = await buildAgent(opts);
+        await splash.step('environment siap');
+        await splash.step(`provider ${opts.provider || agent.config.provider}`);
+        await splash.finish();
+    }
+    catch (err) {
+        await splash.finish();
+        throw err;
+    }
     const config = agent.config;
     // OpenCode-style theming: --theme wins, then VECTOR_THEME (already folded
     // into config via effectiveConfig inside the Agent), then config.json.

package/dist/cli/splash.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splashEnabled = splashEnabled;
+exports.runSplash = runSplash;
+/**
+ * Boot splash — "Loading System . . ." (2026-09-16).
+ *
+ * Additive fitur: ditampilkan HANYA di runTui (interactive TTY) sebelum
+ * dashboard chat TUI masuk alt-screen. Tidak menyentuh agent, provider,
+ * maupun TUI — murni penggambar ANSI di buffer utama lalu DIHAPUS BERSIH
+ * sebelum TUI mulai (tidak meninggalkan sampah scrollback).
+ *
+ * Zero dependency: hanya ANSI escape dari utils/terminal. ASCII safe mode
+ * (VECTOR_ASCII=1) otomatis: spinner & simbol di-ganti varian 1 kolom via
+ * toAsciiSafe agar tidak merobek layout di Termux/font CJK.
+ *
+ * Skip: VECTOR_SPLASH=0 mematikan splash sepenuhnya (zero delay) — cocok
+ * untuk skrip/otomasi. Step delay bisa diatur VECTOR_SPLASH_STEP_MS.
+ */
+const terminal_1 = require("../utils/terminal");
+/** Spinner frames — braille di mode normal, 1-kolom ASCII di ASCII mode. */
+const SPINNER_BRAILLE = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const SPINNER_ASCII = ['|', '/', '-', '\\'];
+/** Warna brand (independen dari THEME — theme di-apply SETELAH buildAgent). */
+const ORANGE = '\x1b[38;2;255;133;52m'; // #FF8534 — aksen VectorHead
+const GREEN = '\x1b[38;2;159;252;98m'; // #9EFC62 — sukses VectorHead
+const WHITE = '\x1b[97m';
+const DIM = terminal_1.ANSI.dim;
+const RESET = terminal_1.ANSI.reset;
+/** Jeda per step agar urutan loading terasa (bisa di-override untuk test). */
+const STEP_DELAY_MS = Math.max(0, Number(process.env.VECTOR_SPLASH_STEP_MS ?? 450));
+/** Jeda "System ready" sebelum blok dihapus. */
+const FINISH_HOLD_MS = Math.max(0, Number(process.env.VECTOR_SPLASH_HOLD_MS ?? 900));
+/** Lebar progress bar (kolom). */
+const BAR_WIDTH = 22;
+/** Splash aktif? VECTOR_SPLASH=0 mematikan (env menang, default ON). */
+function splashEnabled() {
+    const v = process.env['VECTOR_SPLASH'];
+    if (v === undefined)
+        return true;
+    return v !== '0' && v.toLowerCase() !== 'false';
+}
+/** Panjang terlihat (kolom) dari string ber-ANSI milik splash sendiri. */
+function visibleLen(painted) {
+    return painted.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '').length;
+}
+/** Bar progress "███░░░░░ 45%" — satu kolom per glyph di kedua mode. */
+function bar(fraction) {
+    const pct = Math.max(0, Math.min(1, fraction));
+    const filled = Math.round(BAR_WIDTH * pct);
+    return (GREEN + '█'.repeat(filled) + DIM + '░'.repeat(BAR_WIDTH - filled) + RESET +
+        ` ${Math.round(pct * 100)}%`);
+}
+/**
+ * Jalankan splash: banner sekali + spinner live row. Panggil `step()` per
+ * progress, akhiri dengan `finish()` (WAJIB — mengembalikan kursor).
+ * Menangani sendiri kasus lebar terminal ekstrim (kolom < 24 → bar disembunyikan).
+ */
+async function runSplash() {
+    if (!splashEnabled()) {
+        // No-op handle: kode pemanggil tetap bisa memanggil step()/finish().
+        return { step: async () => { }, finish: async () => { } };
+    }
+    const out = process.stdout;
+    const cols = Math.max(1, (0, terminal_1.getTerminalSize)().cols);
+    const ascii = terminal_1.toAsciiSafe; // ASCII safe mode mengikuti VECTOR_ASCII/Termux
+    const frames = asciiModeFrames();
+    const showBar = cols >= BAR_WIDTH + 30;
+    // Pusatkan satu baris (diukur dari versi TERPAINT agar ASCII map ikut dihitung).
+    const center = (text) => {
+        const painted = ascii(text);
+        const pad = Math.max(0, Math.floor((cols - visibleLen(painted)) / 2));
+        return ' '.repeat(pad) + text;
+    };
+    const lines = []; // jumlah baris yang sudah digambar (untuk clear di finish)
+    const write = (s) => {
+        out.write(ascii(s));
+    };
+    const paintLine = (s) => {
+        lines.push(s);
+        write(center(s) + '\r\n');
+    };
+    out.write(terminal_1.ANSI.hideCursor);
+    // ── Banner (sekali) ──────────────────────────────────────────────
+    paintLine(`${ORANGE}▮${RESET} ${WHITE}VectorHead${RESET} ${DIM}v${version()}${RESET}`);
+    paintLine(`${DIM}Initializing system components . . .${RESET}`);
+    paintLine('');
+    // ── Live row (spinner + label + bar) — di-rewrite di tempat ──────
+    let frame = 0;
+    let stepIndex = 0;
+    let label = 'Loading System';
+    const renderLive = () => {
+        const glyph = frames[frame % frames.length];
+        frame++;
+        const pct = Math.min(0.92, 0.15 + stepIndex * 0.22);
+        const text = `${GREEN}${glyph}${RESET} ${WHITE}${label}${RESET} ${DIM}.${RESET}${DIM}.${RESET}${DIM}.${RESET}` +
+            (showBar ? `   ${bar(pct)}` : '');
+        // Rewrite in place: kembali ke awal baris live lalu gambar ulang.
+        write('\r' + terminal_1.ANSI.clearLineEnd + center(text));
+    };
+    const liveTimer = setInterval(renderLive, 90);
+    // Timer TIDAK boleh menahan proses kalau splash ternyata tidak di-finish
+    // (crash path) — biarkan Node berhemi natural.
+    if (typeof liveTimer.unref === 'function')
+        liveTimer.unref();
+    renderLive();
+    await sleep(420); // momen awal "Loading System . . ." terlihat jelas
+    const names = ['Config', 'Environment', 'Provider'];
+    return {
+        async step(detail) {
+            const name = names[Math.min(stepIndex, names.length - 1)];
+            stepIndex++;
+            // Ganti live row dengan baris step selesai (append permanen).
+            const mark = ascii('✓') === '✓' ? '✓' : 'ok';
+            const check = `${GREEN}${mark}${RESET}`;
+            const info = detail ? `  ${DIM}${detail}${RESET}` : '';
+            write('\r' + terminal_1.ANSI.clearLineEnd); // hapus live row
+            paintLine(`${check} ${WHITE}${name}${RESET}${info}`);
+            label = `Loading ${names[Math.min(stepIndex, names.length - 1)] ?? 'System'}`;
+            renderLive();
+            await sleep(STEP_DELAY_MS);
+        },
+        async finish() {
+            clearInterval(liveTimer);
+            const mark = ascii('✓') === '✓' ? '✓' : 'ok';
+            write('\r' + terminal_1.ANSI.clearLineEnd);
+            paintLine(`${GREEN}${mark}${RESET} ${WHITE}System ready${RESET}`);
+            write(`\r\n${DIM}Starting VectorHead TUI . . .${RESET}`);
+            lines.push('', '');
+            await sleep(FINISH_HOLD_MS);
+            // Hapus seluruh blok splash → terminal bersih sebelum alt-screen TUI.
+            // Kursor berada DI baris terakhir (Starting…) → clearLine dulu, lalu
+            // naik + clear per baris tergambar (banner s.d. baris kosong terakhir).
+            let clear = terminal_1.ANSI.clearLine;
+            for (let i = 0; i < lines.length; i++)
+                clear += terminal_1.ANSI.cursorUp(1) + terminal_1.ANSI.clearLine;
+            out.write('\r' + clear);
+            out.write(terminal_1.ANSI.showCursor);
+        },
+    };
+}
+function asciiModeFrames() {
+    // toAsciiSafe memetakan braille → '*' (3 kolom? tidak — catchall 1 kolom),
+    // tapi spinner jadi tidak enak dilihat; varian ASCII asli lebih rapi.
+    try {
+        // Impur dinamis dihindari; cukup cek env yang sama dengan asciiModeEnabled.
+        const v = process.env['VECTOR_ASCII'];
+        const on = v !== undefined ? v !== '0' && v.toLowerCase() !== 'false' : false;
+        return on ? SPINNER_ASCII : SPINNER_BRAILLE;
+    }
+    catch {
+        return SPINNER_BRAILLE;
+    }
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+function version() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const pkg = require('../../package.json');
+        return pkg.version || '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}

package/dist/tui/chat.js

@@ -1,6 +1,6 @@
 "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 = exports.SIDE_GUTTER = exports.mergeStreamDelta = void 0;
+exports.LOGO_SHEEN_MAX = exports.LOGO_SHEEN_INTERVAL_MS = exports.LOGO_SHEEN_STEP = exports.LOGO_FULL_ASCII_MIN_COLS = exports.LOGO_FULL_MIN_COLS = exports.SIDE_GUTTER = exports.mergeStreamDelta = void 0;
 exports.toolIcon = toolIcon;
 exports.toolLabel = toolLabel;
 exports.followupsGroupOf = followupsGroupOf;
@@ -1484,31 +1484,75 @@ function clampScroll(offset, messages, width, height) {
 /**
  * Full-width VECTORHEAD ASCII logo — font "ANSI Shadow", the same figlet
  * font Freebuff uses for its logo (CodebuffAI/freebuff
- * `cli/src/login/constants.ts` LOGO). All 6 rows are exactly 83 columns
- * (letter blocks: V=9 E=8 C=8 T=9 O=9 R=8 H=8 E=8 A=8 D=8) so the art is
+ * `cli/src/login/constants.ts` LOGO). All 6 rows are exactly 56 columns
+ * (letters V=9 E=8 C=8 T=9 O=9 R=8, joined by 1 space) so the art is
  * column-aligned and never wraps. Coloring follows Freebuff's use-logo
  * rules with a VectorHead accent: solid blocks (█) render in `logoBlock`
  * (white), shadow/border box-drawing chars render in orange #FF8534.
+ *
+ * ASCII safe mode (VECTOR_ASCII=1) uses DEDICATED plain-ASCII art instead
+ * (VECTORHEAD_LOGO_ASCII below, figlet "Standard") — squeezing THIS font
+ * 1:1 (█→#, ╔→+) keeps widths exact but destroys the letterforms.
  */
 const VECTORHEAD_LOGO = [
-    '██╗   ██╗███████╗ ██████╗████████╗ ██████╗ ██████╗ ██╗  ██╗███████╗ █████╗ ██████╗ ',
-    '██║   ██║██╔════╝██╔════╝╚══██╔══╝██╔═══██╗██╔══██╗██║  ██║██╔════╝██╔══██╗██╔══██╗',
-    '██║   ██║█████╗  ██║        ██║   ██║   ██║██████╔╝███████║█████╗  ███████║██║  ██║',
-    '╚██╗ ██╔╝██╔══╝  ██║        ██║   ██║   ██║██╔══██╗██╔══██║██╔══╝  ██╔══██║██║  ██║',
-    ' ╚████╔╝ ███████╗╚██████╗   ██║   ╚██████╔╝██║  ██║██║  ██║███████╗██║  ██║██████╔╝',
-    '  ╚═══╝  ╚══════╝ ╚═════╝   ╚═╝    ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚═════╝ ',
+    '██╗   ██╗ ███████╗  ██████╗ ████████╗  ██████╗  ██████╗ ',
+    '██║   ██║ ██╔════╝ ██╔════╝ ╚══██╔══╝ ██╔═══██╗ ██╔══██╗',
+    '██║   ██║ █████╗   ██║         ██║    ██║   ██║ ██████╔╝',
+    '╚██╗ ██╔╝ ██╔══╝   ██║         ██║    ██║   ██║ ██╔══██╗',
+    ' ╚████╔╝  ███████╗ ╚██████╗    ██║    ╚██████╔╝ ██║  ██║',
+    '  ╚═══╝   ╚══════╝  ╚═════╝    ╚═╝     ╚═════╝  ╚═╝  ╚═╝',
+];
+/** Minimum terminal width for the full logo (~56 cols + margin). */
+exports.LOGO_FULL_MIN_COLS = 62;
+/** Minimum terminal width for the full ASCII (figlet) logo — 64 cols + margin. */
+exports.LOGO_FULL_ASCII_MIN_COLS = 68;
+/**
+ * Plain-ASCII logo (figlet "Standard") for ASCII safe mode — real ASCII art
+ * designed as art, NOT the block font squeezed char-per-char. All 6 rows
+ * exactly 64 columns; pure \x20-\x7E so it renders 1 column per char on
+ * EVERY font (the whole point of ASCII mode).
+ */
+const VECTORHEAD_LOGO_ASCII = [
+    ' __     _______ ____ _____ ___  ____  _   _ _____    _    ____  ',
+    ' \\ \\   / / ____/ ___|_   _/ _ \\|  _ \\| | | | ____|  / \\  |  _ \\ ',
+    '  \\ \\ / /|  _|| |     | || | | | |_) | |_| |  _|   / _ \\ | | | |',
+    '   \\ V / | |__| |___  | || |_| |  _ <|  _  | |___ / ___ \\| |_| |',
+    '    \\_/  |_____\\____| |_| \\___/|_| \\ \\_| |_|_____/_/   \\ \\____/ ',
+    '                                                                ',
+];
+/** Compact "VE" plain-ASCII logo (figlet "Standard") — 16 cols. */
+const VECTORHEAD_LOGO_SMALL_ASCII = [
+    ' __     _______ ',
+    ' \\ \\   / / ____|',
+    '  \\ \\ / /|  _|  ',
+    '   \\ V / | |___ ',
+    '    \\_/  |_____|',
+    '                ',
 ];
-/** Minimum terminal width for the full logo (~82 cols + margin). */
-exports.LOGO_FULL_MIN_COLS = 84;
-/** Compact "VE" logo (Freebuff LOGO_SMALL tier: first letters, same font;
- *  column starts align across rows — trailing widths vary like Freebuff's). */
+/**
+ * Pick the logo art + its full-tier width threshold for this terminal:
+ * dedicated figlet ASCII art in ASCII safe mode, the ANSI Shadow block
+ * font otherwise (Freebuff-style tiers).
+ */
+function logoArt(width) {
+    if ((0, terminal_1.asciiModeEnabled)()) {
+        return width >= exports.LOGO_FULL_ASCII_MIN_COLS
+            ? { rows: VECTORHEAD_LOGO_ASCII, minCols: exports.LOGO_FULL_ASCII_MIN_COLS }
+            : { rows: VECTORHEAD_LOGO_SMALL_ASCII, minCols: 20 };
+    }
+    return width >= exports.LOGO_FULL_MIN_COLS
+        ? { rows: VECTORHEAD_LOGO, minCols: exports.LOGO_FULL_MIN_COLS }
+        : { rows: VECTORHEAD_LOGO_SMALL, minCols: 20 };
+}
+/** Compact "VE" logo (Freebuff LOGO_SMALL tier: same font, letters joined
+ *  by 1 space — all 6 rows exactly 18 columns, column-aligned). */
 const VECTORHEAD_LOGO_SMALL = [
-    '██╗   ██╗███████╗',
-    '██║   ██║██╔════╝',
-    '██║   ██║█████╗ ',
-    '╚██╗ ██╔╝██╔══╝ ',
-    ' ╚████╔╝███████╗',
-    '  ╚═══╝ ╚══════╝',
+    '██╗   ██╗ ███████╗',
+    '██║   ██║ ██╔════╝',
+    '██║   ██║ █████╗  ',
+    '╚██╗ ██╔╝ ██╔══╝  ',
+    ' ╚████╔╝  ███████╗',
+    '  ╚═══╝   ╚══════╝',
 ];
 /** Shadow/border logo characters — Freebuff SHADOW_CHARS (login/constants.ts). */
 const SHADOW_CHARS = new Set(['╚', '═', '╝', '║', '╔', '╗', '╠', '╣', '╦', '╩', '╬']);
@@ -1540,8 +1584,14 @@ function logoFgFor(char, charIndex, sheen) {
     }
     return theme_1.THEME.textBright;
 }
-/** Paint one logo line with per-character colors (optional sheen sweep). */
+/** Paint one logo line with per-character colors (optional sheen sweep).
+ * Plain-ASCII art rows (no block/shadow glyphs) render single-tone — the
+ * two-tone painting below is defined for the block font only. */
 function paintLogoLine(line, sheen) {
+    if (!/[█║═╔╗╚╝]/.test(line)) {
+        // figlet ASCII art row: understated single-tone brand mark.
+        return `${theme_1.THEME.muted}${line}${theme_1.THEME.reset}`;
+    }
     let out = '';
     let color = '';
     for (let i = 0; i < line.length; i++) {
@@ -1575,9 +1625,10 @@ function paintLogoLine(line, sheen) {
 function buildWelcomeBlock(width, cwd, sheen = null) {
     const lines = [];
     // Freebuff use-logo tiers: full logo when wide, compact logo when medium,
-    // single-line wordmark on very narrow terminals.
-    const logo = width >= exports.LOGO_FULL_MIN_COLS ? VECTORHEAD_LOGO : VECTORHEAD_LOGO_SMALL;
-    if (width >= 20) {
+    // single-line wordmark on very narrow terminals (art picked by logoArt —
+    // dedicated figlet ASCII in ASCII safe mode, block font otherwise).
+    const { rows: logo, minCols } = logoArt(width);
+    if (width >= minCols) {
         for (const l of logo)
             lines.push(paintLogoLine(l, sheen));
     }
@@ -1600,8 +1651,8 @@ function buildWelcomeBlock(width, cwd, sheen = null) {
 function renderWelcome(width, height, cwd, opts = {}) {
     const sheen = opts.sheen ?? null;
     const lines = [];
-    const logo = width >= exports.LOGO_FULL_MIN_COLS ? VECTORHEAD_LOGO : VECTORHEAD_LOGO_SMALL;
-    if (width >= 20) {
+    const { rows: logo, minCols } = logoArt(width);
+    if (width >= minCols) {
         for (const l of logo)
             lines.push(paintLogoLine(l, sheen));
     }

package/package.json

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