agen-vektor 0.3.8 → 0.3.10

package/README.md

@@ -12,33 +12,41 @@
 ```
 
 ```
-VectorHead ● Ready                     custom · deepseek-ai/DeepSeek-V4-Flash
-Project: ~/my-project                         Mode: ask
-───────────────────────────────────────────────────────────────────────────────
-│ Perbaiki error authentication pada project ini
-VectorHead akan memeriksa file auth, memperbaiki, lalu menjalankan test.
+VectorHead ● Ready                     deepseek-ai/DeepSeek-V4-Flash
+[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
@@ -47,13 +55,8 @@ Requirements: **Node.js 20+** and **npm** (Termux: `pkg install nodejs`).
 
 ### From source
 
-```bash
-git clone https://github.com/clickmamaheti-prog/vector-agent.git
-cd vector-agent
-npm install
-npm run build
-npm link          # makes `vector` available on PATH
-```
+Dari source: clone repo ini, lalu `npm install && npm run build && npm link`
+(membuat `vector` tersedia di PATH).
 
 Then:
 
@@ -100,6 +103,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 +117,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 +145,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 +157,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,15 @@ 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");
+const background_1 = require("../tools/background");
 class Agent {
     config;
     provider;
@@ -20,6 +26,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 +42,17 @@ 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)(),
+            // Parallelism: non-blocking background shell jobs (run_in_background /
+            // output_from_background / stop_background_job).
+            ...(0, background_1.createBackgroundTools)(),
         ]);
     }
     async run(request, signal) {
@@ -79,6 +100,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') {
@@ -93,25 +190,68 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
             toolCalls: result.toolCalls,
         });
         if (hasToolCalls) {
+            // Parallel execution for READ-ONLY tools (Freebuff-style: when the
+            // model requests several independent reads at once — read_file,
+            // search, glob — run them concurrently instead of one-by-one).
+            // Anything that mutates, prompts for permission, or starts background
+            // work stays sequential so side effects keep their order.
+            const PARALLEL_TOOLS = new Set([
+                'read_file',
+                'list_directory',
+                'search_files',
+                'glob',
+                'read_subtree',
+                'list_skills',
+                'output_from_background',
+            ]);
+            const runOne = async (tc) => {
+                callbacks.onToolCall?.(tc.name, tc.arguments, tc.id);
+                const toolResult = await tools.execute(tc.name, tc.arguments, {
+                    cwd,
+                    permissions,
+                    onActivity: callbacks.onActivity,
+                    maxOutput: 30_000,
+                });
+                return { tc, toolResult };
+            };
             try {
+                const batches = [];
+                let current = [];
                 for (const tc of result.toolCalls) {
+                    if (current.length > 0 && !PARALLEL_TOOLS.has(tc.name)) {
+                        batches.push(current);
+                        current = [];
+                    }
+                    current.push(tc);
+                    if (!PARALLEL_TOOLS.has(tc.name)) {
+                        batches.push(current);
+                        current = [];
+                    }
+                }
+                if (current.length > 0)
+                    batches.push(current);
+                for (const batch of batches) {
                     checkAbort();
-                    toolCalls++;
-                    callbacks.onToolCall?.(tc.name, tc.arguments);
-                    callbacks.onStatus?.(`Running ${tc.name}`);
-                    const toolResult = await tools.execute(tc.name, tc.arguments, {
-                        cwd,
-                        permissions,
-                        onActivity: callbacks.onActivity,
-                        maxOutput: 30_000,
-                    });
-                    callbacks.onToolResult?.(tc.name, toolResult.output);
-                    messages.push({
-                        role: 'tool',
-                        toolCallId: tc.id,
-                        name: tc.name,
-                        content: toolResult.output.slice(0, 40_000),
-                    });
+                    const parallel = batch.length > 1 && batch.every((tc) => PARALLEL_TOOLS.has(tc.name));
+                    toolCalls += batch.length;
+                    if (!parallel) {
+                        callbacks.onStatus?.(`Running ${batch[0].name}`);
+                    }
+                    else {
+                        callbacks.onStatus?.(`Running ${batch.length}× ${batch[0].name} (parallel)`);
+                    }
+                    const results = parallel
+                        ? await Promise.all(batch.map(runOne))
+                        : [await runOne(batch[0])];
+                    for (const { tc, toolResult } of results) {
+                        callbacks.onToolResult?.(tc.name, toolResult.output, toolResult.data, tc.id);
+                        messages.push({
+                            role: 'tool',
+                            toolCallId: tc.id,
+                            name: tc.name,
+                            content: toolResult.output.slice(0, 40_000),
+                        });
+                    }
                 }
             }
             catch {
@@ -124,7 +264,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 +277,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 = [