agen-vektor 0.3.32 → 0.3.34

package/README.md

@@ -30,6 +30,7 @@ render cleanly right where you work.*
 - **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, 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). Extensible via **MCP servers** (`mcp__<server>__<tool>`, local stdio JSON-RPC, always permission-ask).
+- **Research subagent** — the `task` tool delegates a read-only subtask (map a flow, find all callers of X, survey a module) to a child agent that can only inspect the project and returns a dense factual report — wide exploration costs the main conversation one tool result instead of dozens of read/search calls.
 - **Skills** — 14 bundled, agentskills.io-format skills with progressive disclosure (`list_skills` / `read_skill` tools, `/skills` in the TUI); drop your own into `~/.vector/skills/` or `.agents/skills/`.
 - **Agent files** — SOUL.md / MEMORY.md / USER.md / AGENTS.md auto-seeded in `~/.vector/` and injected into the system prompt (identity, notes, preferences, project rules).
 - **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.
@@ -471,6 +472,17 @@ secrets stay private):
 
 ## Changelog
 
+### 0.3.34
+- **Research subagent (`task` tool)** — the agent can now delegate a focused, read-only research subtask ("find every caller of X", "map the auth flow") to a child agent that can only inspect the project (read/list/search/glob/semantic_search — nothing else) and returns a dense factual report. Wide exploration costs the main conversation ONE tool result instead of dozens — the agent stays sharp on big tasks. No recursion, own iteration budget (≤25), report capped, dedicated research prompt.
+- **Default free model = `vector.5.3`** (jalur Atria). The old `z-ai/glm-5.3-free` default now 404s on the gateway; existing installs on a dead id are migrated automatically.
+- **Fix: model choice no longer reverted on launch.** The free-tier startup repair used to overwrite your selected model back to the compiled default every launch — an explicit model that is still servable in the live catalog now survives.
+- **Fix: `search_files` is literal (`-F`).** Queries with regex metacharacters (e.g. `login(`) no longer make ripgrep fail — a text search tool must search text.
+
+### 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/agent.js

@@ -20,6 +20,7 @@ const rules_1 = require("./rules");
 const skills_1 = require("./skills");
 const skills_tool_1 = require("../tools/skills-tool");
 const background_1 = require("../tools/background");
+const subagent_1 = require("./subagent");
 const mcp_1 = require("../tools/mcp");
 const logger_1 = require("../utils/logger");
 class Agent {
@@ -81,6 +82,16 @@ class Agent {
             // output_from_background / stop_background_job).
             ...(0, background_1.createBackgroundTools)(),
         ]);
+        // Freebuff-style research subagent: `task` delegates a read-only
+        // subtask to a child agent loop (own iteration budget; registry = read
+        // tools only; cannot recurse). Registered AFTER the built-ins so its
+        // child registry can resolve them.
+        this.tools.register((0, subagent_1.createTaskTool)({
+            provider: () => this.provider,
+            config: () => this.config,
+            cwd: this.cwd,
+            getTool: (name) => this.tools.get(name),
+        }));
         this.initMcpServers();
     }
     async run(request, signal) {

package/dist/agent/loop.js

@@ -119,10 +119,16 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
     const skillsCatalog = (0, skills_1.skillsCatalogText)((0, skills_1.listSkills)(undefined, cwd));
     const messages = [
         // Slot #1: identity (SOUL.md or the built-in VectorHead persona).
-        { role: 'system', content: rulesText || prompts_1.SYSTEM_PROMPT },
-        // Core behavior rules (only when SOUL.md is active we still need the
-        // operation rules; when rulesText is empty SYSTEM_PROMPT already covers it).
-        ...(rulesText ? [{ role: 'system', content: prompts_1.SYSTEM_PROMPT }] : []),
+        // Subagent runs override this slot entirely: the child has its own
+        // read-only mission prompt and must not inherit the main persona.
+        ...(opts.systemPrompt
+            ? [{ role: 'system', content: opts.systemPrompt }]
+            : [
+                { role: 'system', content: rulesText || prompts_1.SYSTEM_PROMPT },
+                // Core behavior rules (only when SOUL.md is active we still need the
+                // operation rules; when rulesText is empty SYSTEM_PROMPT already covers it).
+                ...(rulesText ? [{ role: 'system', content: prompts_1.SYSTEM_PROMPT }] : []),
+            ]),
         // Identity: the model must know its own name/provider to answer
         // "kamu model apa / provider mana" truthfully instead of guessing.
         { role: 'system', content: (0, prompts_1.identityPrompt)(config.model, config.provider) },

package/dist/agent/prompts.js

@@ -60,7 +60,13 @@ Rules:
     The ONLY exceptions — greetings, plain questions, small talk, and
     requests needing just ONE tool call: answer those directly with no
     write_todos.
-14. Suggested followups (Freebuff parity): end EVERY task response by
+15. Deep codebase research goes through the 'task' tool: delegate a
+    self-contained, read-only subtask ("find every caller of X and how the
+    results flow", "map the auth flow", "survey module Y's responsibilities")
+    to the research subagent and work from its dense report instead of
+    burning many of your own read/search calls. Do NOT use 'task' to edit
+    files or run anything mutating.
+16. 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

package/dist/agent/subagent.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUBAGENT_MAX_ITERATIONS = exports.SUBAGENT_READ_TOOLS = void 0;
+exports.buildSubagentRegistry = buildSubagentRegistry;
+exports.createTaskTool = createTaskTool;
+/**
+ * Subagent — Freebuff-style `task` tool: delegates a focused, READ-ONLY
+ * research subtask to a child agent loop. The child runs the SAME provider
+ * with its own iteration budget and a registry containing ONLY read tools
+ * (read_file, list_directory, search_files, glob, read_subtree, list_skills,
+ * read_skill, semantic_search) — it physically cannot mutate anything, and
+ * `task` itself is not part of its registry so it can never recurse.
+ *
+ * The child's final answer (a dense factual report) becomes the tool result,
+ * so wide codebase exploration costs the MAIN conversation one tool result
+ * instead of dozens of read/search tool results.
+ */
+const registry_1 = require("../tools/registry");
+const permissions_1 = require("../security/permissions");
+const loop_1 = require("./loop");
+/** Tools the subagent may use — read-only by construction. */
+exports.SUBAGENT_READ_TOOLS = [
+    'read_file',
+    'list_directory',
+    'search_files',
+    'glob',
+    'read_subtree',
+    'list_skills',
+    'read_skill',
+    'semantic_search',
+];
+/** Own iteration budget — a research dive must not run forever. */
+exports.SUBAGENT_MAX_ITERATIONS = 25;
+/** Hard cap (chars) on the report returned to the main agent. */
+const REPORT_MAX_CHARS = 12_000;
+const SUBAGENT_SYSTEM_PROMPT = `You are the VectorHead research subagent — a READ-ONLY explorer spawned by the main agent to investigate one subtask inside the current project.
+
+MISSION: investigate the subtask and return a DENSE, FACTUAL report.
+
+STRICT RULES:
+- You may only INSPECT: read_file, list_directory, search_files, glob, read_subtree, list_skills, read_skill, semantic_search. Mutating tools do not exist for you — never attempt to change anything.
+- Be efficient: locate with search/glob first, then read only the parts that matter. Do not re-read the same file.
+- You have a limited iteration budget — plan, then execute.
+
+REPORT FORMAT (your final answer is the ONLY thing the main agent sees):
+- Short bullets of key findings, each anchored with a file path (and line numbers when known).
+- Concrete identifiers (function/class/variable names), call sites and relationships.
+- End with "Bottom line:" plus one paragraph directly answering the subtask.
+- At most ~400 words. No preamble, no pleasantries, do not restate the subtask.`;
+/**
+ * Build the child registry: ONLY the read tools present in the parent.
+ * `task` itself is deliberately NOT resolvable here (no recursion), and no
+ * mutating tool ever enters the child registry.
+ */
+function buildSubagentRegistry(getTool) {
+    const registry = new registry_1.ToolRegistry();
+    for (const name of exports.SUBAGENT_READ_TOOLS) {
+        const tool = getTool(name);
+        if (tool)
+            registry.register(tool);
+    }
+    return registry;
+}
+/** One-line preview of raw tool arguments for the activity strip. */
+function previewArgs(raw) {
+    const s = raw.replace(/\s+/g, ' ').trim();
+    return s.length > 60 ? `${s.slice(0, 57)}…` : s;
+}
+function createTaskTool(deps) {
+    return {
+        definition: {
+            name: 'task',
+            description: 'Delegate a focused, READ-ONLY research subtask to a subagent. The subagent can read files, list directories, search, glob and semantic_search — nothing else — and returns a dense factual report (file paths, identifiers, relationships). Use it for wide codebase exploration (map a flow, find all callers of X, survey a module) so your own context stays lean: one task call replaces dozens of read/search calls. Do NOT use it to edit files, run commands, or anything mutating — do those yourself.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    subtask: {
+                        type: 'string',
+                        description: 'The specific research question, self-contained (the subagent does not see this conversation).',
+                    },
+                },
+                required: ['subtask'],
+            },
+        },
+        async execute(args, ctx) {
+            const subtask = typeof args.subtask === 'string' ? args.subtask.trim() : '';
+            if (!subtask) {
+                return { output: 'ERROR: parameter "subtask" (string) is required.' };
+            }
+            const capped = subtask.slice(0, 2000);
+            const tools = buildSubagentRegistry(deps.getTool);
+            const config = deps.config();
+            const childConfig = {
+                ...config,
+                maxIterations: Math.min(config.maxIterations, exports.SUBAGENT_MAX_ITERATIONS),
+            };
+            ctx.onActivity?.('task', `subagent: ${previewArgs(capped)}`);
+            const result = await (0, loop_1.runAgentLoop)(capped, {
+                provider: deps.provider(),
+                tools,
+                permissions: new permissions_1.PermissionManager({ mode: 'yolo' }),
+                config: childConfig,
+                cwd: ctx.cwd || deps.cwd,
+                signal: ctx.signal,
+                systemPrompt: SUBAGENT_SYSTEM_PROMPT,
+            }, {
+                // Child progress surfaces as parent activity lines — never as chat
+                // deltas: the report must land as ONE tool result, and streamed
+                // child text must not look like the main agent's answer.
+                onStatus: (status) => ctx.onActivity?.('task', status),
+                onActivity: (kind, message) => ctx.onActivity?.(kind, message),
+                onToolCall: (name, raw) => ctx.onActivity?.(name, previewArgs(raw)),
+            });
+            let report = (result.content || '').trim();
+            if (!report)
+                report = '(subagent returned an empty report)';
+            if (result.aborted)
+                report = `SUBAGENT STOPPED (user abort).\n${report}`;
+            else if (report.startsWith('! '))
+                report = `SUBAGENT DID NOT FINISH.\n${report}`;
+            if (report.length > REPORT_MAX_CHARS) {
+                report = `${report.slice(0, REPORT_MAX_CHARS)}\n…(report truncated at ${REPORT_MAX_CHARS} chars)`;
+            }
+            return {
+                output: report,
+                summary: `subagent: ${result.iterations} iterations, ${result.toolCalls} tool calls`,
+                permission: 'safe',
+            };
+        },
+    };
+}

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/config/free-tier.js

@@ -25,6 +25,7 @@ exports.resetFreeCatalogCache = resetFreeCatalogCache;
 exports.freeTierEnabled = freeTierEnabled;
 exports.freeProviderDef = freeProviderDef;
 exports.ensureFreeProvider = ensureFreeProvider;
+exports.freeModelServable = freeModelServable;
 exports.isFirstRun = isFirstRun;
 exports.fetchFreeCatalog = fetchFreeCatalog;
 exports.applyFreeCatalog = applyFreeCatalog;
@@ -66,11 +67,13 @@ exports.FREE_PROVIDER_ID = 'vectorhead-free';
  * (ketemu via smoke test 0.3.22). Router Kilo terverifikasi live end-to-end
  * (chat 200, dijawab dots-3-note-preview:free). Riwayat trap yang sama:
  * `deepseek-ai/DeepSeek-V4-Flash` → `claude-sonnet-4-6` → `glm-5.3-flash`
- * (dua flip 2026-09-06/07) → `kilo-auto/free` (2026-09-13) → **z-ai/glm-5.3-free**
- * (2026-09-14: katalog gateway tinggal 2 model — `kilo-auto/free` TIDAK lagi
- * dilayani; default baru terverifikasi live: 1 request → 200 OK, jawaban "hai").
+ * (dua flip 2026-09-06/07) → `kilo-auto/free` (2026-09-13) → `z-ai/glm-5.3-free`
+ * (2026-09-14) → **vector.5.3** (2026-09-17: gateway live tinggal melayani
+ * `glm-5.3-flash-modal` + `vector.5.3` jalur Atria; z-ai/glm-5.3-free 404
+ * "model not found" — ketemu live di TUI VPS; vector.5.3 chat 200 terverifikasi
+ * live end-to-end di drive subagent hari itu).
  */
-exports.FREE_DEFAULT_MODEL = 'z-ai/glm-5.3-free';
+exports.FREE_DEFAULT_MODEL = 'vector.5.3';
 /** The providers-map entry for the free tier (idempotent — same shape always). */
 function freeProviderDef() {
     // When a catalog has been fetched in this process, the gateway URL and
@@ -111,6 +114,7 @@ exports.FREE_LEGACY_MODELS = [
     'claude-sonnet-4-6',
     'glm-5.3-flash',
     'kilo-auto/free',
+    'z-ai/glm-5.3-free',
 ];
 /**
  * Ensure the free provider entry exists in the config's providers map
@@ -132,6 +136,20 @@ function ensureFreeProvider(config) {
     }
     return changed;
 }
+/**
+ * True when `model` is currently KNOWN-SERVABLE on the free tier: it is the
+ * compiled default, OR it appears in the last fetched live catalog (gateway
+ * /v1/catalog — includes vector.5.3 via the Atria path). Used to protect a
+ * user's explicit model choice from being reverted by the repair step.
+ */
+function freeModelServable(model) {
+    if (!model)
+        return false;
+    if (model === exports.FREE_DEFAULT_MODEL)
+        return true;
+    const cat = catalogCache?.data;
+    return !!cat && Array.isArray(cat.models) && cat.models.some((m) => m && m.id === model);
+}
 /**
  * True when this machine has never run VectorHead before (no config.json).
  * First-run seeds default to the free tier so onboarding is zero-config.
@@ -185,5 +203,22 @@ async function fetchFreeCatalog(opts) {
  */
 function applyFreeCatalog(data, config) {
     catalogCache = { data, fetchedAt: Date.now() };
-    return ensureFreeProvider(config);
+    const changed = ensureFreeProvider(config);
+    // Anti-regression (live drive 2026-09-17): an explicit free model that is
+    // STILL SERVABLE per the live catalog (e.g. vector.5.3 — owner's choice on
+    // the VPS) must survive startup; only a provably-dead id (absent from the
+    // catalog, not the default, not legacy) is migrated. Free models are also
+    // migrated by ensureFreeProvider above when they appear in
+    // FREE_LEGACY_MODELS, so this only catches ids that rotted without ever
+    // being listed there. Without this guard a user's model choice could be
+    // flipped back to the (possibly stale) compile-time default and 404 forever.
+    if (config.provider === exports.FREE_PROVIDER_ID &&
+        config.model &&
+        config.model !== exports.FREE_DEFAULT_MODEL &&
+        !exports.FREE_LEGACY_MODELS.includes(config.model) &&
+        !freeModelServable(config.model)) {
+        config.model = exports.FREE_DEFAULT_MODEL;
+        return true;
+    }
+    return changed;
 }

package/dist/tools/search.js

@@ -150,7 +150,13 @@ async function runRg(base, query, filename, max) {
         // "--max-count 3" makes ripgrep exit with code 2 ("The argument
         // '--max-count' was provided more than once") — a bug that silently
         // broke every search when rg was installed.
-        const args = ['--no-ignore', '--line-number', '--max-count', '3'];
+        // NOTE: -F (fixed strings). The tool description promises a TEXT search,
+        // but the query used to be forwarded as a REGEX — a model searching for
+        // "login(" (unbalanced paren, live TUI drive 2026-09-17) made rg exit 2
+        // "regex parse error" and every such search failed. Models frequently
+        // search code fragments with regex metacharacters; literal matching is
+        // the least-surprise behavior for a "search text" tool.
+        const args = ['--no-ignore', '--line-number', '--max-count', '3', '-F'];
         // "**/<dir>/**" so exclusion works even when the search base is an
         // absolute path outside the rg process cwd (plain "!dir/**" only
         // matches relative to cwd — bit us with tmpdir-based tests).

package/package.json

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