agen-vektor 0.3.11 → 0.3.12

package/README.md

@@ -1,15 +1,23 @@
-# VectorHead
+```
+████████████████████████████████████████████████
+█                                              █
+█           V E C T O R   A G E N T            █
+█                                              █
+████████████████████████████████████████████████
+```
+
+<div align="center">
 
 **AI Coding Agent for Linux & Termux** — a terminal-native coding agent that inspects your project, plans, edits code, runs commands and tests, and iterates until the task is done.
 
-```
-██╗   ██╗███████╗ ██████╗████████╗ ██████╗ ██████╗ ██╗  ██╗███████╗ █████╗ ██████╗
-██║   ██║██╔════╝██╔════╝╚══██╔══╝██╔═══██╗██╔══██╗██║  ██║██╔════╝██╔══██╗██╔══██╗
-██║   ██║█████╗  ██║        ██║   ██║   ██║██████╔╝███████║█████╗  ███████║██║  ██║
-╚██╗ ██╔╝██╔══╝  ██║        ██║   ██║   ██║██╔══██╗██╔══██║██╔══╝  ██╔══██║██║  ██║
- ╚████╔╝ ███████╗╚██████╗   ██║   ╚██████╔╝██║  ██║██║  ██║███████╗██║  ██║██████╔╝
-  ╚═══╝  ╚══════╝ ╚═════╝   ╚═╝    ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚═════╝
-```
+![Platform](https://img.shields.io/badge/platform-Linux%20%7C%20Termux-9EFC62?style=for-the-badge&labelColor=0b0f14)
+![Node](https://img.shields.io/badge/node-20%2B-339933?style=for-the-badge&labelColor=0b0f14)
+![License](https://img.shields.io/badge/license-MIT-3B82F6?style=for-the-badge&labelColor=0b0f14)
+[![Tests](https://img.shields.io/github/actions/workflow/status/clickmamaheti-prog/vector-agent/ci.yml?style=for-the-badge&label=tests&labelColor=0b0f14)](https://github.com/clickmamaheti-prog/vector-agent/actions/workflows/ci.yml)
+
+</div>
+
+---
 
 ```
 VectorHead ● Ready                     deepseek-ai/DeepSeek-V4-Flash
@@ -39,6 +47,12 @@ 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.
 
+## Contents
+
+- [Features](#features) · [Installation](#installation) · [Quick start](#quick-start) · [Command line](#command-line) · [TUI commands](#tui-commands)
+- [Provider configuration](#provider-configuration) · [Themes](#themes) · [Security model](#security-model) · [Architecture](#architecture) · [Development](#development)
+- [Testing](#testing) · [Troubleshooting](#troubleshooting) · [Roadmap](#roadmap) · [License](#license)
+
 ## Features
 
 - **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.
@@ -55,10 +69,13 @@ Requirements: **Node.js 20+** and **npm** (Termux: `pkg install nodejs`).
 
 ### From source
 
-Dari source: clone repo ini, lalu `npm install && npm run build && npm link`
-(membuat `vector` tersedia di PATH).
+Clone this repo, then:
 
-Then:
+```bash
+npm install
+npm run build
+npm link   # makes `vector` available on your PATH
+```
 
 ```bash
 vector
@@ -80,7 +97,7 @@ npm install -g agen-vektor
 vector
 ```
 
-> VectorHead has **zero runtime dependencies** and does not assume `systemd`, `sudo`, `apt`, or a desktop GUI — everything runs in a plain terminal.
+> Vector Agent has **zero runtime dependencies** and does not assume `systemd`, `sudo`, `apt`, or a desktop GUI — everything runs in a plain terminal.
 
 ## Quick start
 

package/dist/cli/index.js

@@ -23,6 +23,12 @@ const paths_1 = require("../utils/paths");
 const logger_1 = require("../utils/logger");
 const keyboard_1 = require("./keyboard");
 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
+ *  flush a phantom newline and scroll the screen (the "dot keluar layar"/
+ *  jitter bug). Restored after every paint so scrollback stays intact. */
+const DECAWM_OFF = '\x1b[?7l';
+const DECAWM_ON = '\x1b[?7h';
 const themes_1 = require("../tui/themes");
 const session_1 = require("../agent/session");
 const paths_2 = require("../utils/paths");
@@ -318,7 +324,7 @@ async function runTui(opts) {
             // the chat to flicker during multi-tool turns.
             if (app.isDirty()) {
                 lastFrameRows = [];
-                process.stdout.write(terminal_1.ANSI.hideCursor + app.render());
+                process.stdout.write(terminal_1.ANSI.hideCursor + DECAWM_OFF + (0, terminal_1.toAsciiSafe)(app.render()) + DECAWM_ON);
                 app.consumeRender();
             }
             return;
@@ -337,7 +343,12 @@ async function runTui(opts) {
             out.push(cursor);
         lastCursorPos = cursor;
         out.push(terminal_1.ANSI.showCursor);
-        process.stdout.write(terminal_1.ANSI.hideCursor + out.join(''));
+        // DECAWM guard: even one exactly-`cols`-wide row (input-box borders,
+        // header at the old width) leaves the cursor in the pending-wrap state;
+        // the NEXT repaint — e.g. the ~480ms blink dot — then auto-wraps first
+        // and the whole screen scrolls up one line. With auto-wrap disabled for
+        // the duration of the paint, that phantom newline is impossible.
+        process.stdout.write(terminal_1.ANSI.hideCursor + DECAWM_OFF + (0, terminal_1.toAsciiSafe)(out.join('')) + DECAWM_ON);
     };
     const onResize = () => {
         app.markDirty();

package/dist/config/config.js

@@ -44,6 +44,7 @@ exports.effectiveConfig = effectiveConfig;
  * credentials.json (0600) or environment variables, never in config.json.
  */
 const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
 const paths_1 = require("../utils/paths");
 const logger_1 = require("../utils/logger");
 const providers_1 = require("./providers");
@@ -51,7 +52,12 @@ exports.DEFAULT_CONFIG = {
     provider: 'openrouter',
     model: 'deepseek/deepseek-chat',
     protocol: 'openai',
-    permissionMode: 'ask',
+    // User request (2026-09-04): the assistant must ACT without permission
+    // prompts — yolo is the default. Dangerous commands (rm, git push, chmod…)
+    // still prompt and blocked ones are always refused (see command-policy),
+    // so the guardrail floor stays intact. Opt back into prompting via
+    // VECTOR_ASK=1 or the /mode toggle in the TUI.
+    permissionMode: 'yolo',
     maxIterations: 25,
     maxRetries: 3,
     requestTimeoutMs: 120_000,
@@ -66,6 +72,22 @@ function loadConfig() {
         if (fs.existsSync(p)) {
             const raw = fs.readFileSync(p, 'utf8');
             const parsed = JSON.parse(raw);
+            // One-time mode migration (2026-09-04): permissionMode became 'yolo'
+            // by default — the assistant must act without prompting. Configs that
+            // still carry the OLD default ('ask') are flipped once; an explicit
+            // /mode toggle afterwards re-persists and is then respected forever.
+            if (parsed.permissionMode === 'ask') {
+                const marker = path.join((0, paths_1.getVectorDir)(), '.mode-migrated');
+                if (!fs.existsSync(marker)) {
+                    parsed.permissionMode = 'yolo';
+                    try {
+                        fs.writeFileSync(marker, new Date().toISOString() + '\n');
+                    }
+                    catch {
+                        /* best-effort */
+                    }
+                }
+            }
             return { ...exports.DEFAULT_CONFIG, ...parsed };
         }
     }
@@ -92,6 +114,9 @@ function effectiveConfig(base) {
         out.theme = process.env.VECTOR_THEME;
     if (process.env.VECTOR_YOLO === '1')
         out.permissionMode = 'yolo';
+    // Opt back into per-action confirmation prompts.
+    if (process.env.VECTOR_ASK === '1')
+        out.permissionMode = 'ask';
     // Per-provider default model: when the provider comes from the environment
     // and no explicit model env was given, follow the provider definition's
     // declared default (config.json providers.<id>.model).

package/dist/providers/anthropic.js

@@ -96,6 +96,19 @@ class AnthropicProvider {
             body.tools = toToolDefs(params.tools);
         if (params.temperature !== undefined)
             body.temperature = params.temperature;
+        // Extended thinking (Anthropic): ask for a reasoning budget so thinking
+        // models (Claude 3.7+/4 family) stream thinking_delta blocks — rendered
+        // as the • Thinking card. Harmless for non-thinking models? No — the API
+        // REJECTS thinking for models without extended-thinking support, so it
+        // is opt-in via VECTOR_ANTHROPIC_THINKING=1 (or a budget explicitly set
+        // here), keeping every other model working unchanged.
+        const wantThinking = process.env.VECTOR_ANTHROPIC_THINKING === '1';
+        const budget = Number(process.env.VECTOR_ANTHROPIC_THINKING_BUDGET || 0);
+        if (wantThinking || budget > 0) {
+            body.thinking = { type: 'enabled', budget_tokens: budget > 0 ? budget : 8_000 };
+            // Anthropic requires temperature unset (or 1) when thinking is on.
+            delete body.temperature;
+        }
         return body;
     }
     async post(body, signal) {
@@ -133,10 +146,13 @@ class AnthropicProvider {
         const data = await this.post(this.buildBody(params, false), params.signal);
         const content = data.content || [];
         let text = '';
+        let thinking = '';
         const toolCalls = [];
         for (const block of content) {
             if (block.type === 'text')
                 text += String(block.text || '');
+            if (block.type === 'thinking')
+                thinking += String(block.thinking || '');
             if (block.type === 'tool_use') {
                 toolCalls.push({
                     id: String(block.id),
@@ -148,6 +164,7 @@ class AnthropicProvider {
         const usage = data.usage;
         return {
             content: text,
+            reasoning: thinking || undefined,
             toolCalls,
             stopReason: String(data.stop_reason || 'end_turn'),
             usage: usage
@@ -181,6 +198,7 @@ class AnthropicProvider {
             const decoder = new TextDecoder();
             let buffer = '';
             let content = '';
+            let thinking = '';
             const toolCalls = [];
             let currentTool = null;
             for (;;) {
@@ -210,12 +228,21 @@ class AnthropicProvider {
                             arguments: '',
                         };
                     }
+                    else if (evtName === 'content_block_start' && contentBlock?.type === 'thinking') {
+                        // Thinking block starts — its deltas carry type thinking_delta.
+                    }
                     else if (evtName === 'content_block_delta') {
                         const delta = json.delta;
                         if (delta?.type === 'text_delta' && typeof delta.text === 'string') {
                             content += delta.text;
                             yield { type: 'delta', delta: delta.text };
                         }
+                        else if (delta?.type === 'thinking_delta' && typeof delta.thinking === 'string') {
+                            // Extended thinking (Claude 3.7+/4): surface as reasoning so
+                            // the • Thinking card renders for these models too.
+                            thinking += delta.thinking;
+                            yield { type: 'delta', reasoning: delta.thinking };
+                        }
                         else if (delta?.type === 'input_json_delta' &&
                             currentTool &&
                             typeof delta.partial_json === 'string') {
@@ -252,7 +279,13 @@ class AnthropicProvider {
                 toolCalls.push(currentTool);
             yield {
                 type: 'done',
-                result: { content, toolCalls, stopReason: 'end_turn', model: params.model },
+                result: {
+                    content,
+                    reasoning: thinking || undefined,
+                    toolCalls,
+                    stopReason: 'end_turn',
+                    model: params.model,
+                },
             };
         }
         finally {

package/dist/providers/gemini.js

@@ -71,10 +71,17 @@ function extractResult(data) {
     const content0 = candidates[0]?.content || {};
     const parts = content0.parts || [];
     let content = '';
+    let reasoning = '';
     const toolCalls = [];
     for (const part of parts) {
-        if (typeof part.text === 'string')
-            content += part.text;
+        // Thinking models (Gemini 2.5/3 family) mark reasoning parts with
+        // thought: true — surface them as reasoning, never as answer text.
+        if (typeof part.text === 'string') {
+            if (part.thought === true)
+                reasoning += part.text;
+            else
+                content += part.text;
+        }
         if (part.functionCall) {
             const raw = part.functionCall;
             const fcs = Array.isArray(raw) ? raw : [raw];
@@ -87,7 +94,7 @@ function extractResult(data) {
             }
         }
     }
-    return { content, toolCalls };
+    return { content, reasoning, toolCalls };
 }
 class GeminiProvider {
     id = 'gemini';
@@ -151,9 +158,10 @@ class GeminiProvider {
             throw new provider_1.ProviderError(`Gemini HTTP ${res.status}: ${text.slice(0, 300)}`, res.status, res.status >= 500);
         }
         const data = JSON.parse(text);
-        const { content, toolCalls } = extractResult(data);
+        const { content, reasoning, toolCalls } = extractResult(data);
         return {
             content,
+            reasoning: reasoning || undefined,
             toolCalls,
             stopReason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
             model: params.model,
@@ -169,6 +177,7 @@ class GeminiProvider {
         const decoder = new TextDecoder();
         let buffer = '';
         let content = '';
+        let reasoning = '';
         const toolCalls = [];
         for (;;) {
             const { done, value } = await reader.read();
@@ -187,7 +196,11 @@ class GeminiProvider {
                 const json = safeJson(payload);
                 if (!json)
                     continue;
-                const { content: deltaText, toolCalls: newCalls } = extractResult(json);
+                const { content: deltaText, reasoning: deltaThought, toolCalls: newCalls } = extractResult(json);
+                if (deltaThought) {
+                    reasoning += deltaThought;
+                    yield { type: 'delta', reasoning: deltaThought };
+                }
                 if (deltaText) {
                     content += deltaText;
                     yield { type: 'delta', delta: deltaText };
@@ -202,6 +215,7 @@ class GeminiProvider {
             type: 'done',
             result: {
                 content,
+                reasoning: reasoning || undefined,
                 toolCalls,
                 stopReason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
                 model: params.model,

package/dist/providers/ollama.js

@@ -94,8 +94,12 @@ class OllamaProvider {
                 arguments: typeof fn.arguments === 'string' ? fn.arguments : JSON.stringify(fn.arguments ?? {}),
             };
         });
+        // Thinking models (Ollama ≥0.9: DeepSeek-R1, Qwen3 …) return the
+        // reasoning in message.thinking when the model supports it.
+        const thinking = typeof message.thinking === 'string' ? message.thinking : '';
         return {
             content: String(message.content || ''),
+            reasoning: thinking || undefined,
             toolCalls,
             stopReason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
             model: String(data.model || params.model),
@@ -118,6 +122,7 @@ class OllamaProvider {
         const decoder = new TextDecoder();
         let buffer = '';
         let content = '';
+        let reasoning = '';
         const toolCalls = [];
         for (;;) {
             const { done, value } = await reader.read();
@@ -138,6 +143,7 @@ class OllamaProvider {
                         type: 'done',
                         result: {
                             content,
+                            reasoning: reasoning || undefined,
                             toolCalls,
                             stopReason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
                             model: params.model,
@@ -146,6 +152,12 @@ class OllamaProvider {
                     return;
                 }
                 const message = (json.message || {});
+                // Thinking models stream reasoning in message.thinking (Ollama ≥0.9,
+                // DeepSeek-R1/Qwen3) — surface it so the • Thinking card renders.
+                if (typeof message.thinking === 'string' && message.thinking) {
+                    reasoning += message.thinking;
+                    yield { type: 'delta', reasoning: message.thinking };
+                }
                 if (typeof message.content === 'string' && message.content) {
                     content += message.content;
                     yield { type: 'delta', delta: message.content };
@@ -165,7 +177,7 @@ class OllamaProvider {
         }
         yield {
             type: 'done',
-            result: { content, toolCalls, stopReason: 'stop', model: params.model },
+            result: { content, reasoning: reasoning || undefined, toolCalls, stopReason: 'stop', model: params.model },
         };
     }
     async models() {

package/dist/providers/openai-compat.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAICompatProvider = void 0;
 exports.stripThinkTags = stripThinkTags;
+exports.createThinkTagStreamSplitter = createThinkTagStreamSplitter;
 /**
  * OpenAI-compatible provider — used by OpenAI, OpenRouter and Custom.
  * Speaks /v1/chat/completions (and /models) with tool calling + streaming.
@@ -59,6 +60,81 @@ function extractReasoning(msg) {
 function stripThinkTags(text) {
     return text.replace(/<think>[\s\S]*?<\/think>/g, '').replace(/^\s*<think>[\s\S]*$/, '').trim();
 }
+/**
+ * Incremental `<think>…</think>` tag splitter for STREAMING: OpenAI-compat
+ * gateways often proxy reasoning models (DeepSeek-R1, QwQ, Qwen3 …) that
+ * inline their thinking into `delta.content` instead of a separate
+ * `reasoning_content` field. Non-streaming already strips via
+ * stripThinkTags — the streaming path needs the same treatment or the
+ * • Thinking card never appears for those models (raw <think> text used to
+ * leak into the visible answer too).
+ */
+function createThinkTagStreamSplitter() {
+    let inside = false;
+    let tail = ''; // partial tag spanning chunk boundaries
+    const flushTail = (emit) => {
+        // Find the highest safe split point: a '<' that MIGHT begin a tag when
+        // more text arrives is kept buffered; everything before it is emitted.
+        const lt = tail.indexOf('<');
+        if (lt === -1) {
+            emit(tail, inside);
+            tail = '';
+            return;
+        }
+        if (lt > 0) {
+            emit(tail.slice(0, lt), inside);
+            tail = tail.slice(lt);
+        }
+        // tail now starts with '<' — wait for more data.
+    };
+    return {
+        /** Feed one content delta; returns {content, reasoning} pieces. */
+        push(chunk) {
+            const content = [];
+            const reasoning = [];
+            const emit = (s, isReasoning) => {
+                if (s)
+                    (isReasoning ? reasoning : content).push(s);
+            };
+            tail += chunk;
+            for (;;) {
+                if (!inside) {
+                    const open = tail.indexOf('<think>');
+                    if (open !== -1) {
+                        emit(tail.slice(0, open), false);
+                        tail = tail.slice(open + 7);
+                        inside = true;
+                        continue;
+                    }
+                    flushTail(emit);
+                    break;
+                }
+                else {
+                    const close = tail.indexOf('</think>');
+                    if (close !== -1) {
+                        emit(tail.slice(0, close), true);
+                        tail = tail.slice(close + 8);
+                        inside = false;
+                        continue;
+                    }
+                    flushTail(emit);
+                    break;
+                }
+            }
+            return { content, reasoning };
+        },
+        /** End of stream: flush any buffered remainder (an unterminated
+         * <think> block counts as reasoning). */
+        finish() {
+            const content = [];
+            const reasoning = [];
+            if (tail)
+                (inside ? reasoning : content).push(tail);
+            tail = '';
+            return { content, reasoning };
+        },
+    };
+}
 function parseToolCalls(raw) {
     const calls = [];
     if (!Array.isArray(raw))
@@ -233,6 +309,10 @@ class OpenAICompatProvider {
             let content = '';
             let reasoning = '';
             const toolCalls = [];
+            // Reasoning models behind OpenAI-compat gateways may inline thinking
+            // into delta.content as <think>…</think> (DeepSeek-R1/QwQ/Qwen3).
+            // Split it out so the • Thinking card works on EVERY model.
+            const thinkSplit = createThinkTagStreamSplitter();
             for (;;) {
                 const { done, value } = await reader.read();
                 if (done)
@@ -246,6 +326,12 @@ class OpenAICompatProvider {
                         continue;
                     const payload = trimmed.slice(5).trim();
                     if (payload === '[DONE]') {
+                        // Flush any <think> splitter remainder before finishing.
+                        const tail = thinkSplit.finish();
+                        for (const r of tail.reasoning)
+                            reasoning += r;
+                        for (const c of tail.content)
+                            content += c;
                         yield {
                             type: 'done',
                             result: {
@@ -276,8 +362,15 @@ class OpenAICompatProvider {
                         yield { type: 'delta', reasoning: rc };
                     }
                     if (typeof delta.content === 'string' && delta.content) {
-                        content += delta.content;
-                        yield { type: 'delta', delta: delta.content };
+                        const pieces = thinkSplit.push(delta.content);
+                        for (const r of pieces.reasoning) {
+                            reasoning += r;
+                            yield { type: 'delta', reasoning: r };
+                        }
+                        for (const c of pieces.content) {
+                            content += c;
+                            yield { type: 'delta', delta: c };
+                        }
                     }
                     const tc = delta.tool_calls;
                     if (Array.isArray(tc)) {
@@ -311,7 +404,12 @@ class OpenAICompatProvider {
                     }
                 }
             }
-            // Stream ended without [DONE]
+            // Stream ended without [DONE] — flush the <think> splitter tail.
+            const tail = thinkSplit.finish();
+            for (const r of tail.reasoning)
+                reasoning += r;
+            for (const c of tail.content)
+                content += c;
             yield {
                 type: 'done',
                 result: {

package/dist/security/command-policy.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.classifyCommand = classifyCommand;
+const sensitive_files_1 = require("./sensitive-files");
 const BLOCKED_PATTERNS = [
     /(^|[;&|]\s*)\s*rm\s+(-[a-z]*[rf][a-z]*\s+)*\/\s*($|[^a-zA-Z])/,
     /(^|[;&|]\s*)\s*rm\s+(-[a-z]*[rf][a-z]*\s+)*~(\/|$)/,
@@ -59,6 +60,12 @@ const ASK_PATTERNS = [
 /** Commands that are safe to run without asking. */
 const SAFE_PATTERNS = [
     /(^|[;&|]\s*)\s*(ls|cat|head|tail|less|more|wc|grep|find|locate|which|type|file|stat|du|df|tree)\s/,
+    // Local dev-server plumbing (compound verification commands like
+    // `cd web && python3 -m http.server 8917 & sleep 1; curl localhost; kill %1`)
+    /(^|[;&|]\s*)\s*cd\s+\S+/,
+    /(^|[;&|]\s*)\s*sleep\s+\d/,
+    /(^|[;&|]\s*)\s*python3?\s+-m\s+http\.server\b/,
+    /(^|[;&|]\s*)\s*kill\s+%\d+/,
     /(^|[;&|]\s*)\s*echo\s/,
     /(^|[;&|]\s*)\s*node\s+(-v|--version)/,
     /(^|[;&|]\s*)\s*npm\s+(-v|--version|ls|list)\s*/,
@@ -78,11 +85,63 @@ function classifyCommand(command) {
             return { level: 'blocked', reason: `command matches blocked pattern: ${re.source}` };
         }
     }
+    // Sensitive-file escalation (Freebuff fileFilter spirit): a shell command
+    // that references a secret (.env, private keys, credentials.json, …) must
+    // be PROMPTED even in yolo mode — `cat .env` / `cp id_rsa /tmp` / piping
+    // secrets into the network is the classic exfiltration path around the
+    // fs-tool guard. Only `cat *.example` template references stay exempt so
+    // agents can still learn the config surface.
+    const tokens = command.split(/\s+/).map((t) => t.replace(/['"`]/g, ''));
+    const touchesSensitive = tokens.some((raw) => {
+        // curl-style --data=@file and @file forms: keep only the path part.
+        const t = raw.split('=').pop() ?? raw;
+        const base = (t.startsWith('@') ? t.slice(1) : t).split('/').pop() ?? '';
+        if (!base)
+            return false;
+        if (base.endsWith('.example') || base.endsWith('.sample'))
+            return false;
+        return (0, sensitive_files_1.isSensitiveFile)(base) || (0, sensitive_files_1.isSensitiveEnvFilePath)(base);
+    });
+    if (touchesSensitive) {
+        return { level: 'dangerous', reason: 'command references a sensitive file (secrets must be prompted even in yolo)' };
+    }
     for (const re of DANGEROUS_PATTERNS) {
         if (re.test(command)) {
             return { level: 'dangerous', reason: `command matches dangerous pattern: ${re.source}` };
         }
     }
+    // Loopback exemption (Freebuff-style smooth local dev): curl/wget whose
+    // EVERY network target is localhost/127.0.0.1 cannot exfiltrate anything
+    // off the machine, so testing a local dev server should not prompt. Runs
+    // AFTER the dangerous/sensitive checks so `curl | bash` and
+    // `curl --data @secrets http://localhost` still escalate. Any remote host
+    // in the same command (or an extra URL) falls through to the ASK pattern.
+    if (/(^|[;&|]\s*)\s*(curl|wget)\s/.test(command)) {
+        const targets = [];
+        for (const seg of command.split(/[;&|]+/)) {
+            const m = seg.trim().match(/^(curl|wget)\s+(.*)$/);
+            if (!m)
+                continue;
+            for (const raw of m[2].split(/\s+/)) {
+                const t = raw.replace(/['"`]/g, '').split('=').pop() ?? '';
+                if (t.startsWith('-'))
+                    continue;
+                // URL/host-shaped token: scheme://host, host:port, or host.tld
+                if (/^https?:\/\//i.test(t) || (/^[\w.\-\[%]+(:\d+)?(\/|$|\?)/.test(t) && /[.:\[%]|localhost/.test(t))) {
+                    targets.push(t);
+                }
+            }
+        }
+        const isLoopback = (tok) => {
+            let s = tok.replace(/^https?:\/\//i, '').toLowerCase();
+            s = (s.split('/')[0] ?? '').split(':')[0] ?? '';
+            return (s === 'localhost' || s === '127.0.0.1' || s === '::1' ||
+                s === '[::1]' || s === '[::]' || s.endsWith('.localhost'));
+        };
+        if (targets.length > 0 && targets.every(isLoopback)) {
+            return { level: 'safe', reason: 'curl/wget targets loopback only (local dev server test, no remote transfer)' };
+        }
+    }
     for (const re of ASK_PATTERNS) {
         if (re.test(command)) {
             return { level: 'ask', reason: `command matches ask pattern: ${re.source}` };