agen-vektor 0.3.8 → 0.3.9

package/README.md

@@ -12,33 +12,42 @@
 ```
 
 ```
-VectorHead ● Ready                     custom · deepseek-ai/DeepSeek-V4-Flash
-Project: ~/my-project                         Mode: ask
+VectorHead ● Ready                     deepseek-ai/DeepSeek-V4-Flash
 ───────────────────────────────────────────────────────────────────────────────
-│ Perbaiki error authentication pada project ini
-VectorHead akan memeriksa file auth, memperbaiki, lalu menjalankan test.
+[09:41]
+Perbaiki error authentication pada project ini
 
-───────────────────────────────────────────────────────────────────────────────
-⚙ shell · $ npm test
-✓ Tests passed
+# Cek Auth      ← kuning (heading H1–H6, Freebuff palette)
+VectorHead akan memeriksa file auth, memperbaiki, lalu menjalankan test.
+[09:42]
+$ npm test
+  ... (2 more lines above)
+  3 tests passed
 ╭─────────────────────────────────────────────────────────────────────────────╮
+│                                                                             │
 │  ▍ Enter a coding task or / for commands                                   │
+│                                                                             │
 ╰─────────────────────────────────────────────────────────────────────────────╯
 ● Ready                                          ● ask
 ```
 
-A Freebuff-style terminal UI: chat history with a bold-white assistant line,
-compact agent-activity strip (⚙ tool calls), and a rounded input box with a
-block cursor and placeholder — all rendered incrementally with no flicker.
+A Freebuff-style terminal UI with the EXACT Freebuff dark palette (`#9EFC62`
+green accents, markdown headings H1–H6 all yellow `#facc15`, inline code
+BOLD orange `#FF8534` on a `#374151` chip, links blue `#3B82F6`, fenced
+code `// lang` header `#5b647a` on a `#374151` slab, plain prose — quoted
+from [CodebuffAI/freebuff](https://github.com/CodebuffAI/freebuff)
+theme-system.ts + markdown-renderer.tsx), a compact agent-activity strip
+(⚙ tool calls), and a rounded input box with a block cursor — all rendered
+incrementally with no flicker.
 
 ## Features
 
-- **Interactive TUI** — chat, agent status, tool execution, diff viewer, input. Keyboard driven, mouse-aware, works on 80×24 terminals and survives resize.
+- **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.
 - **Security first** — command policy classifies every shell command (SAFE / ASK / DANGEROUS / BLOCKED), permission prompts before risky actions, `--yolo` mode with warnings, and API keys are never printed or persisted to sessions.
 - **Multi-provider** — OpenAI, Anthropic, Gemini, OpenRouter, Ollama, and any OpenAI-compatible custom endpoint.
-- **Sessions & memory** — conversations persist to `~/.vector/sessions/`; `/continue` resumes them.
+- **Sessions & memory** — conversations persist to `~/.vector/sessions/`; a relaunch in the same project resumes the conversation automatically (agent keeps the last replies in context), `/continue` resumes any session, and `Ctrl+L`/`/clear` starts fresh.
 - **Context management** — only relevant context is sent to the model, with compaction (`/compact`).
 
 ## Installation
@@ -100,6 +109,7 @@ vector
 | `vector "task"` | Start TUI and run the task immediately |
 | `vector --model MODEL` | Set the model |
 | `vector --provider P` | Set provider: `openai`, `anthropic`, `gemini`, `openrouter`, `ollama`, `custom` |
+| `vector --theme NAME` | Set theme: built-in or `~/.vector/themes/<name>.json` |
 | `vector --continue` | Continue the most recent session |
 | `vector --session NAME` | Use/resume session `NAME` |
 | `vector --plan` | Show a plan before executing |
@@ -113,11 +123,14 @@ Type `/` inside VectorHead:
 | Command | Description |
 |---|---|
 | `/model` | Select a model |
+| `/theme` | Select a theme (OpenCode-style) |
 | `/provider` | Select a provider |
+| `/provider-remove` | Remove the stored provider key (and custom URL/name) so you can re-enter fresh values |
 | `/session` | Browse saved sessions |
 | `/settings` | Show configuration |
 | `/status` | Show agent status |
-| `/clear` | Clear the conversation |
+| `/clear` | Clear the conversation (keeps the session) |
+| `/new` | Start a fresh conversation — rotates to a brand-new session (the old one is kept on disk) |
 | `/continue` | Continue the current/last session |
 | `/diff` | Show diff viewer |
 | `/git` | Run `git status` |
@@ -138,7 +151,7 @@ export OPENROUTER_API_KEY=...
 
 Or inside VectorHead: `/provider` → pick provider → paste key (stored masked in `~/.vector/credentials.json`, permissions `0600`).
 
-Generic variables: `VECTOR_API_KEY`, `VECTOR_API_URL`, `VECTOR_MODEL`, `VECTOR_PROVIDER`, `VECTOR_HOME`.
+Generic variables: `VECTOR_API_KEY`, `VECTOR_API_URL`, `VECTOR_MODEL`, `VECTOR_PROVIDER`, `VECTOR_THEME`, `VECTOR_HOME`, `VECTOR_AUTO_APPROVE` (=1 auto-approves ASK-level permission prompts, for automated runs/tests; dangerous actions still prompt).
 
 ### Custom API (OpenAI-compatible)
 
@@ -150,6 +163,128 @@ vector --provider custom --model deepseek-v3
 
 The provider speaks `/v1/chat/completions` (and `/models`). Anthropic and Gemini protocols for custom endpoints are documented as adapters; OpenAI-compatible endpoints are fully supported.
 
+### Multiple custom providers (OpenCode-style)
+
+Any number of OpenAI-compatible providers can be defined side by side in
+`~/.vector/config.json` under `providers` — the same shape OpenCode uses in
+its `provider` section (minus the `npm` field, since every custom endpoint
+here is OpenAI-compatible):
+
+```jsonc
+{
+  "provider": "bitdeer",                  // ACTIVE provider id
+  "model": "deepseek-ai/DeepSeek-V4-Flash",
+  "providers": {
+    "bitdeer": {
+      "name": "BitDeer",
+      "options": {
+        "baseURL": "https://api-inference.bitdeer.ai/v1",
+        "apiKey": "{env:BITDEER_API_KEY}"   // or a plain key, or omit and store via /provider
+      },
+      "models": {
+        "deepseek-ai/DeepSeek-V4-Flash": { "name": "DeepSeek V4 Flash" }
+      }
+    },
+    "groq2": {
+      "name": "Groq 2",
+      "options": { "baseURL": "https://groq2.example.com/v1" }
+    },
+    "agentrouter": {
+      "name": "AgentRouter",
+      "model": "deepseek-v4-flash",          // default model when this provider is active
+      "options": {
+        "baseURL": "https://agentrouter.org/v1",
+        // Gateways that filter by client (AgentRouter only accepts official
+        // AI clients) need a spoofed User-Agent on every request:
+        "headers": {
+          "User-Agent": "codex_cli_rs/0.101.0 (Mac OS 26.0.1; arm64) Apple_Terminal/464",
+          "Originator": "codex_cli_rs"
+        }
+      }
+    }
+  }
+}
+```
+
+- `provider` is the active id — a built-in, the legacy `custom` slot, or any
+  key of `providers`. Keys are **per provider id**: store each under its own
+  id in `~/.vector/credentials.json` (0600) via `/provider`, inline them in
+  `options.apiKey`, or reference an env var with `"{env:NAME}"`.
+- `options.headers` adds extra HTTP headers to every request of that provider
+  (e.g. a `User-Agent` required by a client-filtering gateway like
+  AgentRouter). Values may be plain strings or `"{env:NAME}"` templates;
+  headers referencing a missing env var are dropped.
+- `model` is the **default model** for that provider: when the provider
+  becomes active (`/provider`, `--provider`, or `VECTOR_PROVIDER`), the active
+  model automatically follows it unless an explicit `--model` / `VECTOR_MODEL`
+  was given. Handy when each provider speaks its own model ids (e.g.
+  AgentRouter uses `deepseek-v4-flash` while BitDeer uses
+  `deepseek-ai/DeepSeek-V4-Flash`).
+- `/provider` lists built-ins + every configured custom and offers
+  **➕ Add custom provider** (id → name → base URL → key). `/model` then
+  auto-discovers models from the endpoint's `/models` route and falls back
+  to the `models` map above.
+- The old single-custom setup (`provider: "custom"` + `apiUrl`/`customName`
+  + key under `custom`) keeps working unchanged.
+
+Switch at runtime with `/provider`, or per-run with
+`VECTOR_PROVIDER=bitdeer vector …` / `--provider bitdeer`.
+
+## Themes
+
+VectorHead adopts [OpenCode's theme system](https://opencode.ai/docs/themes/):
+select a built-in theme, or drop your own JSON files into
+`~/.vector/themes/` (same files OpenCode uses work verbatim).
+
+```bash
+vector --theme tokyonight     # one-off
+# or persist it:
+echo '{ "theme": "nord" }' >> ~/.vector/config.json   # (merge manually)
+# or inside the TUI: /theme
+# or env: export VECTOR_THEME=matrix
+```
+
+Built-ins: `vectorhead` (default, the Exact Freebuff dark palette),
+`nord`, `tokyonight`, `gruvbox`, `catppuccin`, `one-dark`, `matrix`.
+
+### Custom themes
+
+A theme is a JSON file with an optional `defs` block of reusable colors
+plus a semantic `theme` block. Color values may be hex (`#88C0D0`), ANSI
+palette indexes (`3` for 0–255), references (`"nord8"` or `"primary"`),
+dark/light variants (`{ "dark": "#000", "light": "#fff" }`), or
+`"none"` (terminal default).
+
+```json
+{
+  "defs": { "brand": "#9EFC62" },
+  "theme": {
+    "primary": "brand",
+    "text": "#f1f5f9",
+    "textMuted": "#acb3bf",
+    "background": "#0b0f14",
+    "backgroundPanel": "#141a21",
+    "border": "#2b3542",
+    "error": "#ff6b6b",
+    "warning": "#ffa500",
+    "success": "#9EFC62"
+  }
+}
+```
+
+Save it as `~/.vector/themes/my-theme.json`, then `/theme` (or
+`vector --theme my-theme`) to use it. Semantic keys adopted from OpenCode
+and their effect here: `primary` (brand accent), `accent`/`markdownHeading`
+(headings, prompt), `text`, `textMuted`, `textFaint`, `markdownCode`,
+`border`/`borderActive`, `error`/`warning`/`success`/`info`, `diffAdded`/
+`diffRemoved`/`diffContext`, `backgroundPanel`/`backgroundElement`.
+Unknown keys and unresolvable colors are ignored, so partial themes keep
+the default palette for anything you don't override.
+
+> Hex colors are emitted as truecolor (24-bit) escapes — terminals need
+> `COLORTERM=truecolor` for full fidelity (most modern terminals). ANSI
+> palette indexes and `vectorhead` work everywhere.
+
 ## Security model
 
 Every shell command is classified:

package/dist/agent/agent.js

@@ -8,9 +8,14 @@ const search_1 = require("../tools/search");
 const shell_1 = require("../tools/shell");
 const git_1 = require("../tools/git");
 const web_1 = require("../tools/web");
+const extras_1 = require("../tools/extras");
+const apply_patch_1 = require("../tools/apply-patch");
 const permissions_1 = require("../security/permissions");
 const config_1 = require("../config/config");
 const loop_1 = require("./loop");
+const rules_1 = require("./rules");
+const skills_1 = require("./skills");
+const skills_tool_1 = require("../tools/skills-tool");
 class Agent {
     config;
     provider;
@@ -20,6 +25,11 @@ class Agent {
     constructor(opts) {
         this.config = (0, config_1.effectiveConfig)(opts.config);
         this.cwd = opts.cwd || process.cwd();
+        // Seed Hermes-style SOUL.md/MEMORY.md/USER.md/SKILL.md on first run
+        // (never overwrites existing user files — see src/agent/rules.ts).
+        (0, rules_1.ensureRuleFiles)();
+        // Seed the bundled skill catalog into ~/.vector/skills/ (never overwrites).
+        (0, skills_1.seedBundledSkills)();
         this.provider = (0, factory_1.createProvider)(this.config);
         this.permissions = new permissions_1.PermissionManager({
             mode: this.config.permissionMode,
@@ -31,7 +41,14 @@ class Agent {
             ...(0, search_1.createSearchTools)(),
             (0, shell_1.createShellTool)(),
             (0, git_1.createGitTool)(),
-            (0, web_1.createWebTool)(),
+            ...(0, web_1.createWebTools)(),
+            // Freebuff-style extras: glob, read_subtree, task_completed,
+            // suggest_followups, render_ui.
+            ...(0, extras_1.createExtrasTools)(),
+            // Unified-diff editing (Freebuff/Codebuff apply_patch format).
+            (0, apply_patch_1.createApplyPatchTool)(),
+            // Hermes-style progressive-disclosure skills (list_skills / read_skill).
+            ...(0, skills_tool_1.createSkillTools)(),
         ]);
     }
     async run(request, signal) {
@@ -79,6 +96,7 @@ class Agent {
         this.callbacks = {
             onStatus: cb.onStatus,
             onDelta: cb.onDelta,
+            onThinking: cb.onThinking,
             onToolCall: cb.onToolCall,
             onToolResult: cb.onToolResult,
             onIteration: cb.onIteration,

package/dist/agent/light.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Light small-talk detection — casual greetings, thanks, and questions about
+ * the agent itself do NOT need project context. Treating these as "light"
+ * saves tokens and, more importantly, stops the agent from inspecting or
+ * listing the whole project just because the user said "hallo" (it should
+ * simply answer back instead of reading the directory).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLightRequest = isLightRequest;
+const LIGHT_PHRASES = new Set([
+    // greetings (id + en)
+    'hi', 'hii', 'hai', 'haii', 'hei', 'hey', 'heyy', 'hello', 'hallo', 'helo',
+    'halo', 'halow', 'hola', 'yo', 'yoo', 'yow', 'sup', 'wassup', 'whats up',
+    "what's up", 'hiya', 'howdy', 'selamat pagi', 'selamat siang', 'selamat sore',
+    'selamat malam', 'good morning', 'good afternoon', 'good evening',
+    'apa kabar', 'apakabar', 'kabar', 'kabar baik', 'how are you',
+    'how are you doing', 'hows it going', "how's it going",
+    // thanks / short acknowledgements
+    'thanks', 'thank you', 'thankyou', 'thx', 'ty', 'makasih', 'makasi',
+    'mkasih', 'mksh', 'terima kasih', 'trims', 'sip', 'siap', 'mantap',
+    'bagus', 'nice', 'oke', 'ok', 'okay', 'okey', 'okee',
+    // questions about the agent itself (no project needed)
+    'kamu siapa', 'siapa kamu', 'kamu sapa', 'who are you',
+    'kamu model apa', 'model apa kamu', 'model kamu apa', 'kamu pakai model apa',
+    'kamu provider apa', 'provider apa kamu', 'provider kamu apa', 'kamu pakai provider apa',
+    'kamu bisa apa', 'bisa apa', 'apa yang bisa kamu lakukan', 'apa yang kamu bisa',
+    'what can you do', 'can you help me', 'bisa bantu', 'boleh bantu',
+    'mau tanya', 'boleh tanya',
+    // skills / capabilities questions (agent, NOT the repository)
+    'apa skill mu', 'skill mu apa', 'skill kamu apa', 'apa skill kamu',
+    'apa aja skill mu', 'apa aja skill kamu', 'apa saja skill mu', 'apa saja skill kamu',
+    'skill apa aja', 'skill apa saja', 'skills apa', 'list skill', 'list skills',
+    'daftar skill', 'daftar skills', 'apa skills mu', 'skills kamu',
+    'keahlian mu apa', 'apa keahlian mu', 'apa aja keahlian mu', 'apa keahlian kamu',
+    'keahlian kamu apa', 'kemampuan mu apa', 'apa kemampuan mu', 'apa aja kemampuan mu',
+    'apa kemampuan kamu', 'kemampuan kamu apa', 'bisa apa aja', 'bisa apa saja',
+    'bisa ngapain', 'bisa ngapain aja', 'ngapain aja', 'kamu ngapain aja',
+    'bisa bantu apa', 'bisa membantu apa', 'bisa bantu apa saja',
+    'what skills do you have', 'list your skills', 'what are your skills',
+    'what are your capabilities', 'what are your abilities', 'your capabilities',
+    // what project are we on (identity of the workspace — brief answer, no
+    // full-project inspection / tool wall)
+    'apa project kita', 'project kita apa', 'project apa ini', 'apa project ini',
+    'ini project apa', 'project ini apa', 'apa proyek kita', 'proyek kita apa',
+    'proyek apa ini', 'apa proyek ini', 'ini proyek apa', 'proyek ini apa',
+    'project kamu apa', 'kamu project apa', 'apa project kamu', 'project apa ya ini',
+]);
+const MAX_LEN = 80;
+/** True for short casual messages that deserve a direct answer, no tools. */
+function isLightRequest(text) {
+    const t = text.trim();
+    if (!t || t.length > MAX_LEN)
+        return false;
+    // Normalize: lowercase, drop trailing punctuation/emoji/symbols.
+    const norm = t
+        .toLowerCase()
+        .replace(/[\s!.,;:?]+$/, '')
+        .replace(/[^\x00-\x7F\s]/g, '')
+        .replace(/[\s!.,;:?]+$/, '')
+        .trim();
+    if (norm.length === 0)
+        return true; // emoji-only / punctuation-only message
+    return LIGHT_PHRASES.has(norm);
+}

package/dist/agent/loop.js

@@ -14,7 +14,10 @@ exports.estimateContextSize = estimateContextSize;
  */
 const provider_1 = require("../providers/provider");
 const context_1 = require("./context");
+const light_1 = require("./light");
 const prompts_1 = require("./prompts");
+const rules_1 = require("./rules");
+const skills_1 = require("./skills");
 async function runAgentLoop(userRequest, opts, callbacks = {}) {
     const { provider, tools, permissions, config, cwd, signal } = opts;
     const maxIterations = config.maxIterations;
@@ -24,11 +27,36 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
     // the folder listing on every turn makes the agent re-explain/echo it.
     const history = (opts.history ?? []).filter((m) => m.role !== 'system');
     const isContinuation = history.length > 0;
-    const context = isContinuation
+    // Casual small talk ("hallo", "hi", "apa kabar", "kamu siapa", …) gets a
+    // plain, direct answer: no project context, no folder listing, no skills
+    // catalog. The model must not read the whole directory just to greet back.
+    const isLight = (0, light_1.isLightRequest)(userRequest);
+    const context = isContinuation || isLight
         ? ''
         : `${(0, context_1.buildProjectContext)(cwd)}\n\n${(0, context_1.listRootEntries)(cwd)}\n\n---\n\n`;
+    // Hermes-style agent rules: SOUL.md (identity) first, then AGENTS.md
+    // project rules, then bounded MEMORY.md / USER.md / SKILL.md. Empty
+    // sections are skipped, so nothing is added until the user/agent fills it.
+    const rulesText = (0, rules_1.rulesToPrompt)((0, rules_1.loadRules)(cwd));
+    // Level 0 of the skills catalog (names + one-line descriptions). Cheap
+    // enough to always include; full instructions load on demand via the
+    // skill/read_skill tools. Scans ALL roots — including the project's
+    // .agents/skills (`npx skills add` layout) — Freebuff parity.
+    const skillsCatalog = (0, skills_1.skillsCatalogText)((0, skills_1.listSkills)(undefined, cwd));
     const messages = [
-        { role: 'system', content: prompts_1.SYSTEM_PROMPT },
+        // 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 }] : []),
+        // 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) },
+        // Skills catalog (Level 0) injected on the first turn; on continuation
+        // the model already saw it and can still list_skills at any time.
+        ...(!isContinuation && !isLight && skillsCatalog
+            ? [{ role: 'system', content: skillsCatalog }]
+            : []),
         ...history,
         { role: 'user', content: `${context}TASK:\n${userRequest}` },
     ];
@@ -37,12 +65,81 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
     let aborted = false;
     let stopped = false;
     let finalContent = '';
+    let lastReasoning = '';
     const checkAbort = () => {
         if (signal?.aborted) {
             aborted = true;
             throw new Error('aborted');
         }
     };
+    /**
+     * One model call. Streams when the provider supports it so tokens appear
+     * live in the TUI (Freebuff-style) instead of a silent freeze while the
+     * model thinks (BitDeer cold starts can be 30–120s). Falls back to chat
+     * for providers that cannot stream.
+     */
+    async function doCall() {
+        const params = { messages, model: config.model, tools: tools.definitions(), signal };
+        if (!provider.capabilities().streaming) {
+            const r = await provider.chat(params);
+            // Non-streaming providers deliver reasoning only in the result —
+            // normalize it into onThinking (once) so the TUI behaves the same.
+            if (r.reasoning) {
+                lastReasoning = r.reasoning;
+                callbacks.onThinking?.(r.reasoning);
+            }
+            return r;
+        }
+        let content = '';
+        const toolStream = [];
+        let final = null;
+        for await (const ev of provider.stream(params)) {
+            if (ev.type === 'delta' && ev.delta) {
+                content += ev.delta;
+                callbacks.onDelta?.(ev.delta);
+            }
+            else if (ev.type === 'delta' && ev.reasoning) {
+                // Model thinking (reasoning_content) — surfaced live to the TUI's
+                // thinking card, kept OUT of the visible answer text.
+                lastReasoning += ev.reasoning;
+                callbacks.onThinking?.(ev.reasoning);
+            }
+            else if (ev.type === 'tool_call' && ev.toolCall) {
+                // The same tool call id can be yielded repeatedly (partial chunks);
+                // keep the latest complete copy.
+                const call = ev.toolCall;
+                const idx = toolStream.findIndex((t) => t.id === call.id);
+                if (idx >= 0)
+                    toolStream[idx] = call;
+                else
+                    toolStream.push(call);
+            }
+            else if (ev.type === 'error') {
+                throw new provider_1.ProviderError(ev.error || 'Streaming error from provider.', 0, false);
+            }
+            else if (ev.type === 'done' && ev.result) {
+                final = ev.result;
+            }
+        }
+        if (final) {
+            if (final.reasoning && !lastReasoning) {
+                // Reasoning appeared ONLY in the final result (no deltas were
+                // streamed): emit once so the TUI still gets the thinking card.
+                lastReasoning = final.reasoning;
+                callbacks.onThinking?.(final.reasoning);
+            }
+            if (lastReasoning && !final.reasoning)
+                final.reasoning = lastReasoning;
+            lastReasoning = '';
+            return final;
+        }
+        return {
+            content,
+            reasoning: lastReasoning || undefined,
+            toolCalls: toolStream,
+            stopReason: toolStream.length > 0 ? 'tool_calls' : 'stop',
+        };
+    }
     while (iterations < maxIterations) {
         try {
             checkAbort();
@@ -57,7 +154,7 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
         callbacks.onStatus?.(iterations === 1 ? 'Thinking' : 'Thinking…');
         let result;
         try {
-            result = await (0, provider_1.withRetry)(() => provider.chat({ messages, model: config.model, tools: tools.definitions(), signal }), { retries: config.maxRetries, signal });
+            result = await (0, provider_1.withRetry)(doCall, { retries: config.maxRetries, signal });
         }
         catch (err) {
             if (err.name === 'AbortError' || err.message === 'aborted') {
@@ -105,7 +202,7 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
                         onActivity: callbacks.onActivity,
                         maxOutput: 30_000,
                     });
-                    callbacks.onToolResult?.(tc.name, toolResult.output);
+                    callbacks.onToolResult?.(tc.name, toolResult.output, toolResult.data);
                     messages.push({
                         role: 'tool',
                         toolCallId: tc.id,
@@ -124,7 +221,8 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
         // No tool calls → final answer
         finalContent = result.content;
         callbacks.onStatus?.('Completed');
-        callbacks.onFinal?.(result);
+        callbacks.onFinal?.({ ...result, reasoning: lastReasoning || result.reasoning });
+        lastReasoning = '';
         return { content: finalContent, iterations, toolCalls, stopped, aborted, messages };
     }
     if (iterations >= maxIterations) {
@@ -136,9 +234,12 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
     return { content: finalContent, iterations, toolCalls, stopped, aborted, messages };
 }
 /** Compact conversation history into a summary to reduce token usage. */
-function compactMessages(messages, summarize) {
+function compactMessages(messages, summarize, config) {
     return summarize(messages).then((summary) => [
         { role: 'system', content: prompts_1.SYSTEM_PROMPT },
+        ...(config
+            ? [{ role: 'system', content: (0, prompts_1.identityPrompt)(config.model, config.provider) }]
+            : []),
         {
             role: 'user',
             content: `[Previous conversation summarized]\n${summary}`,

package/dist/agent/planner.js

@@ -2,8 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generatePlan = generatePlan;
 const context_1 = require("./context");
+const light_1 = require("./light");
 const PLAN_PROMPT = `You are a planning engine. Given the user's task and the project context, produce a concise numbered plan of the steps the agent should take. Output ONLY the numbered steps, one per line. No preamble, no markdown fences.`;
 async function generatePlan(provider, userRequest, cwd, model, signal) {
+    // Casual small talk: answer directly — don't spend an LLM call (or the
+    // project context) on a greeting.
+    if ((0, light_1.isLightRequest)(userRequest)) {
+        return { steps: [userRequest], raw: '' };
+    }
     const projectCtx = (0, context_1.buildProjectContext)(cwd);
     const entries = (0, context_1.listRootEntries)(cwd);
     const messages = [

package/dist/agent/prompts.js

@@ -4,6 +4,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SYSTEM_PROMPT = void 0;
+exports.identityPrompt = identityPrompt;
 exports.taskPrompt = taskPrompt;
 exports.continuationPrompt = continuationPrompt;
 exports.SYSTEM_PROMPT = `You are VectorHead, an AI coding agent operating inside a terminal.
@@ -24,7 +25,44 @@ Rules:
 6. Never print API keys, tokens, or secrets. If you find a secret, say so without revealing it.
 7. When you need more information than you have, use tools to get it instead of asking the user.
 8. Answer in the same language the user used.
-9. Keep responses concise but complete: state what you did, why, and how it was verified.`;
+9. Keep responses concise but complete: state what you did, why, and how it was verified.
+10. Reusable procedures are saved as skills. Run list_skills to see what's installed
+    (names + descriptions), then read_skill with the skill name to load the full
+    instructions the moment you actually follow one. Use a matching skill when a
+    task clearly fits one instead of improvising from scratch. NEVER print the
+    installed-skills list or list_skills output back into your reply — it is only
+    an internal index; use it to pick and load a skill, nothing more.
+11. When the user only greets you or asks about yourself (e.g. "hallo", "hi",
+    "apa kabar", "terima kasih", "kamu siapa?", "kamu model apa", "kamu bisa
+    apa?"), reply briefly and directly. Do NOT inspect the project, list files,
+    or call any tool for such messages — a greeting is not a task.
+12. Whenever you receive a task that needs work (inspect, search, edit, run
+    anything), FIRST open your reply with one very short acknowledgment line
+    about what you are about to do — e.g. "Oke, saya akan cari dulu.",
+    "Baik, saya periksa dulu.", "Siap, saya kerjakan.", "Ok, let me look
+    first." — and only then start using tools. This way the user sees you
+    respond immediately even before the first tool runs. Keep it to one line;
+    do not repeat or pad it. For pure greetings/identity questions (rule 11)
+    skip the acknowledgment and answer directly.
+13. Live task checklist (write_todos tool): the user watches a live ☐/☑
+    checklist while you work, so show it whenever a request needs 2+ tool
+    calls. Hard rule: after your one-line acknowledgment, your FIRST tool
+    call MUST be write_todos with the FULL step list as
+    { task, completed: false } items; then after each step finishes, call
+    write_todos again with the full updated list (finished steps
+    completed: true). Example: for "buat file lalu baca isinya" first call
+    write_todos with ["Buat file", "Baca isinya"] before calling write_file.
+    The ONLY exceptions — greetings, plain questions, small talk, and
+    requests needing just ONE tool call: answer those directly with no
+    write_todos.`;
+/**
+ * Identity line injected into the system prompt so the model can answer
+ * "which model/provider are you?" truthfully (it has no other way to know).
+ */
+function identityPrompt(model, provider) {
+    return `You are currently running as the model "${model}" via the "${provider}" provider (OpenAI-compatible API unless stated otherwise).
+If the user asks which model you are or which provider backs you, answer with exactly this — e.g. "Saya dijalankan oleh model deepseek-ai/DeepSeek-V4-Flash lewat provider custom". Do not invent a different model name.`;
+}
 function taskPrompt(userRequest, cwd) {
     return `Working directory: ${cwd}