vigthoria-cli 1.6.15 → 1.6.17

package/dist/commands/chat.d.ts

@@ -32,6 +32,7 @@ export declare class ChatCommand {
     private currentModel;
     private modelExplicitlySelected;
     private autoApprove;
+    private agentToolEvidence;
     private operatorMode;
     private workflowTarget;
     private savePlanToVigFlow;
@@ -50,6 +51,9 @@ export declare class ChatCommand {
     private buildTaskShapingInstructions;
     private buildExecutionPrompt;
     private getPromptRuntimeContext;
+    private v3IterationCount;
+    private v3ToolCallCount;
+    private v3LastActivity;
     private describeV3AgentTool;
     private updateV3AgentSpinner;
     private updateOperatorSpinner;

package/dist/commands/chat.js

@@ -47,9 +47,9 @@ const api_js_1 = require("../utils/api.js");
 const tools_js_1 = require("../utils/tools.js");
 const session_js_1 = require("../utils/session.js");
 const DEFAULT_V3_AGENT_TIMEOUT_MS = (() => {
-    const rawValue = process.env.VIGTHORIA_AGENT_TIMEOUT_MS || process.env.V3_AGENT_TIMEOUT_MS || '1200000';
+    const rawValue = process.env.VIGTHORIA_AGENT_TIMEOUT_MS || process.env.V3_AGENT_TIMEOUT_MS || '3900000';
     const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 1200000;
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 3900000;
 })();
 class ChatCommand {
     config;
@@ -67,6 +67,8 @@ class ChatCommand {
     currentModel = 'code';
     modelExplicitlySelected = false;
     autoApprove = false;
+    // Phase 5: Agent quality gate — track tool usage for evidence thresholds
+    agentToolEvidence = { discovery: 0, mutation: 0, searchFailed: 0 };
     operatorMode = false;
     workflowTarget = null;
     savePlanToVigFlow = false;
@@ -195,6 +197,10 @@ class ChatCommand {
     }
     buildTaskShapingInstructions(prompt) {
         const instructions = [];
+        // Platform-aware routing hints
+        if (os.platform() === 'win32') {
+            instructions.push('Platform: Windows. Use list_dir, glob, read_file, and the grep tool for searching.', 'The grep tool handles Windows automatically — do not use bash to call grep, findstr, or Select-String manually.', 'Do not use bash for Unix commands (cat, head, tail, awk, sed, wc).', 'Use read_file to inspect file contents instead of shell commands.', 'All file paths use forward slashes internally.');
+        }
         if (this.isDiagnosticPrompt(prompt)) {
             instructions.push('Diagnostic mode is active.', 'Treat this as a debugging task, not a generic code review or feature request.', 'Start with concrete evidence: logs, runtime errors, config, launch files, and exact symbol references.', 'If log files exist, inspect them before proposing fixes.', 'Do not claim a file, definition, asset, or symbol is missing until you verify that with tools.', 'If a prior diagnosis mentioned a missing symbol or YAML entry, re-check the actual files before repeating it.', 'Prefer grep plus read_file around the exact references involved in the failure.', 'Separate your reasoning into: Evidence, Confirmed Cause, and Remaining Hypotheses.', 'Do not suggest speculative fixes when the current evidence contradicts them.');
         }
@@ -227,37 +233,87 @@ class ChatCommand {
             devtoolsBridgeEndpoint: bridgeStatus.endpoint,
         };
     }
+    v3IterationCount = 0;
+    v3ToolCallCount = 0;
+    v3LastActivity = Date.now();
     describeV3AgentTool(toolName) {
         const normalized = String(toolName || '').toLowerCase();
         if (/read|grep|search|list|find|glob/.test(normalized)) {
-            return 'Planning... gathering project context';
+            return 'Reading project files';
         }
         if (/write|edit|patch|create|delete|replace|rename/.test(normalized)) {
-            return 'Applying changes...';
+            return 'Writing changes';
         }
         if (/test|lint|build|run|exec|terminal/.test(normalized)) {
-            return 'Validating changes...';
+            return 'Running verification';
+        }
+        if (/hyperloop/.test(normalized)) {
+            return 'Hyperloop processing';
         }
-        return 'Working...';
+        return 'Working';
     }
     updateV3AgentSpinner(spinner, event) {
         if (!event || typeof event !== 'object') {
             return;
         }
+        this.v3LastActivity = Date.now();
         if (event.type === 'tool_call') {
-            spinner.text = this.describeV3AgentTool(event.tool || event.name || event.tool_name);
+            this.v3ToolCallCount += 1;
+            const toolDesc = this.describeV3AgentTool(event.tool || event.name || event.tool_name);
+            const toolTarget = event.arguments?.path || event.arguments?.file_path || event.arguments?.pattern || '';
+            const shortTarget = toolTarget ? ` → ${String(toolTarget).split('/').slice(-2).join('/')}` : '';
+            spinner.text = chalk_1.default.cyan(`[${this.v3IterationCount}/${this.v3ToolCallCount}] `) + `${toolDesc}${shortTarget}`;
+            return;
+        }
+        if (event.type === 'tool_result') {
+            const success = event.success !== false;
+            const toolName = event.name || event.tool || '';
+            const indicator = success ? chalk_1.default.green('✓') : chalk_1.default.red('✗');
+            spinner.text = `${indicator} ${toolName} complete — next step...`;
+            return;
+        }
+        if (event.type === 'thinking') {
+            this.v3IterationCount += 1;
+            const iterText = event.content || '';
+            const iterMatch = iterText.match(/Iteration (\d+)/i);
+            const iterNum = iterMatch ? iterMatch[1] : String(this.v3IterationCount);
+            spinner.text = chalk_1.default.cyan(`[Iteration ${iterNum}] `) + 'Analyzing...';
             return;
         }
         if (event.type === 'message') {
-            spinner.text = 'Writing response...';
+            const preview = String(event.content || '').slice(0, 80).replace(/\n/g, ' ');
+            spinner.text = chalk_1.default.cyan('[Response] ') + (preview || 'Writing response...');
             return;
         }
         if (event.type === 'complete') {
-            spinner.text = 'Finishing...';
+            const elapsed = event.elapsed || '';
+            const iters = event.iterations || this.v3IterationCount;
+            const tools = event.tool_calls || this.v3ToolCallCount;
+            spinner.text = chalk_1.default.green('✓ ') + `Complete — ${iters} iterations, ${tools} tool calls${elapsed ? `, ${elapsed}` : ''}`;
+            return;
+        }
+        if (event.type === 'plan') {
+            const planKind = event.plan?.task_kind || event.task_kind || '';
+            spinner.text = chalk_1.default.cyan('[Plan] ') + `Task: ${planKind || 'analyzing'}...`;
+            return;
+        }
+        if (event.type === 'error') {
+            if (event.checkpointed) {
+                spinner.text = chalk_1.default.yellow('[Checkpoint] ') + 'Budget reached — auto-continuing...';
+            }
+            else {
+                spinner.text = chalk_1.default.red('[Error] ') + (event.message || 'Agent error');
+            }
+            return;
+        }
+        if (event.type === 'context') {
+            spinner.text = chalk_1.default.cyan('[Context] ') + 'Workspace bound...';
             return;
         }
-        if (event.type === 'plan' || event.type === 'analysis' || event.type === 'thinking') {
-            spinner.text = 'Planning...';
+        if (event.type === 'start') {
+            this.v3IterationCount = 0;
+            this.v3ToolCallCount = 0;
+            spinner.text = chalk_1.default.cyan('[Start] ') + 'Agent initialized...';
         }
     }
     updateOperatorSpinner(spinner, event) {
@@ -607,10 +663,11 @@ class ChatCommand {
     async runSimplePrompt(prompt) {
         this.lastActionableUserInput = prompt;
         this.messages.push({ role: 'user', content: this.buildExecutionPrompt(prompt) });
-        const spinner = (0, ora_1.default)({ text: 'Thinking...', spinner: 'clock' }).start();
+        const spinner = this.jsonOutput ? null : (0, ora_1.default)({ text: 'Thinking...', spinner: 'clock' }).start();
         try {
             const response = await this.api.chat(this.getMessagesForModel(), this.currentModel);
-            spinner.stop();
+            if (spinner)
+                spinner.stop();
             const finalText = response.message.trim();
             if (finalText) {
                 console.log(finalText);
@@ -619,7 +676,8 @@ class ChatCommand {
             this.saveSession();
         }
         catch (error) {
-            spinner.fail('Failed to get response');
+            if (spinner)
+                spinner.fail('Failed to get response');
             this.logger.error(error.message);
         }
     }
@@ -657,21 +715,37 @@ class ChatCommand {
         }
         this.lastActionableUserInput = prompt;
         this.directToolContinuationCount = 0;
+        this.agentToolEvidence = { discovery: 0, mutation: 0, searchFailed: 0 };
         this.tools.clearSessionApprovals();
         this.ensureAgentSystemPrompt();
         this.messages.push({ role: 'user', content: this.buildScopedUserPrompt(prompt) });
         this.saveSession();
         const maxTurns = 10;
         for (let turn = 0; turn < maxTurns; turn += 1) {
-            const spinner = (0, ora_1.default)({ text: turn === 0 ? 'Planning...' : 'Continuing...', spinner: 'clock' }).start();
+            const spinner = this.jsonOutput ? null : (0, ora_1.default)({ text: turn === 0 ? 'Planning...' : 'Continuing...', spinner: 'clock' }).start();
             try {
                 const response = await this.api.chat(this.getMessagesForModel(), this.currentModel);
-                spinner.stop();
+                if (spinner)
+                    spinner.stop();
                 const assistantMessage = response.message || '';
                 this.messages.push({ role: 'assistant', content: assistantMessage });
                 const toolCalls = this.extractToolCalls(assistantMessage);
                 const visibleText = this.stripToolPayloads(assistantMessage).trim();
                 if (toolCalls.length === 0) {
+                    // Phase 5: Quality gate — if the agent tries to conclude on the first
+                    // turn without any discovery, push it to gather evidence first.
+                    if (turn === 0 && this.agentToolEvidence.discovery === 0 && this.isDiagnosticPrompt(prompt)) {
+                        this.messages.push({
+                            role: 'system',
+                            content: [
+                                'Quality gate: you concluded without using any discovery tools (list_dir, glob, read_file, grep).',
+                                'Before answering a diagnostic or audit question, you MUST inspect the project with tools.',
+                                'Use list_dir and read_file to gather concrete evidence, then provide your answer.',
+                            ].join('\n'),
+                        });
+                        this.directToolContinuationCount += 1;
+                        continue;
+                    }
                     const finalContent = this.resolveDirectModeCompletion(prompt, visibleText);
                     if (this.jsonOutput) {
                         console.log(JSON.stringify({
@@ -700,7 +774,8 @@ class ChatCommand {
                 this.saveSession();
             }
             catch (error) {
-                spinner.fail('Agent request failed');
+                if (spinner)
+                    spinner.fail('Agent request failed');
                 if (this.jsonOutput) {
                     process.exitCode = 1;
                     console.log(JSON.stringify({
@@ -856,6 +931,10 @@ class ChatCommand {
         const runtimeContext = await this.getPromptRuntimeContext(prompt);
         const routingPolicy = this.resolveAgentExecutionPolicy(prompt);
         const rescueEligible = this.isSaaSRescuePrompt(prompt);
+        // Reset streaming counters for new workflow
+        this.v3IterationCount = 0;
+        this.v3ToolCallCount = 0;
+        this.v3LastActivity = Date.now();
         const spinner = this.jsonOutput ? null : (0, ora_1.default)({
             text: routingPolicy.cloudSelected ? 'Routing heavy task to Vigthoria Cloud...' : 'Routing to V3 Agent...',
             spinner: 'clock',
@@ -917,6 +996,18 @@ class ChatCommand {
                 }
                 this.logger.error(errorMessage);
                 this.messages.push({ role: 'assistant', content: errorMessage });
+                if (this.jsonOutput) {
+                    process.exitCode = 1;
+                    console.log(JSON.stringify({
+                        success: false,
+                        mode: 'agent',
+                        model: routingPolicy.selectedModel,
+                        partial: false,
+                        content: '',
+                        error: errorMessage,
+                        metadata: { executionPath: 'v3-agent', previewGate },
+                    }, null, 2));
+                }
                 return true;
             }
             if (!this.jsonOutput && previewGate?.required && previewGate?.passed !== true && workspaceHasOutput) {
@@ -974,6 +1065,18 @@ class ChatCommand {
             const errorMessage = `Agent mode requires the V3 workflow and will not fall back to the legacy CLI loop. ${error.message}`;
             this.logger.error(errorMessage);
             this.messages.push({ role: 'assistant', content: errorMessage });
+            if (this.jsonOutput) {
+                process.exitCode = 1;
+                console.log(JSON.stringify({
+                    success: false,
+                    mode: 'agent',
+                    model: routingPolicy.selectedModel,
+                    partial: false,
+                    content: '',
+                    error: errorMessage,
+                    metadata: { executionPath: 'v3-agent' },
+                }, null, 2));
+            }
             return true;
         }
     }
@@ -1383,10 +1486,20 @@ class ChatCommand {
     }
     buildContinuationPrompt() {
         const diagnosticMode = this.isDiagnosticPrompt(this.lastActionableUserInput);
+        const { discovery, mutation, searchFailed } = this.agentToolEvidence;
+        const evidenceLines = [];
+        if (discovery < 2) {
+            evidenceLines.push(`Quality gate: only ${discovery} discovery tool(s) used so far (list_dir, glob, read_file, grep). Use at least 2 before concluding.`);
+        }
+        if (searchFailed > 0) {
+            evidenceLines.push(`Warning: ${searchFailed} search tool call(s) failed. Do not treat failed searches as evidence that something is missing.`);
+        }
         return [
             `Tool results received for direct mode step ${this.directToolContinuationCount + 1}.`,
             `Original user request: ${this.lastActionableUserInput}`,
             `Project root boundary: ${this.currentProjectPath}`,
+            `Evidence collected: ${discovery} discovery, ${mutation} mutation, ${searchFailed} search failures.`,
+            ...evidenceLines,
             'Do not declare success until the exact user question has been answered with tool-backed evidence.',
             'If a user is asking which file is correct or most recent, keep inspecting until you can justify the answer from actual results.',
             diagnosticMode ? 'Because this is a debugging task, prefer logs, runtime evidence, and exact symbol references over generic fixes.' : 'Keep working from concrete tool results.',
@@ -1550,16 +1663,47 @@ class ChatCommand {
             if (!this.jsonOutput) {
                 console.log(chalk_1.default.cyan(`⚙ Executing: ${call.tool}`));
             }
-            const result = await this.tools.execute(call);
+            let result = await this.tools.execute(call);
+            // Phase 2: If a search tool failed (search_failed), retry with alternate approach
+            const searchStatus = result.metadata?.searchStatus;
+            if (call.tool === 'grep' && searchStatus === 'search_failed') {
+                if (!this.jsonOutput) {
+                    console.log(chalk_1.default.yellow(`⚠ Search backend failed, retrying with alternate method...`));
+                }
+                // Force Node-native fallback by re-executing with a note
+                const fallbackResult = await this.tools.execute({
+                    tool: 'grep',
+                    args: { ...call.args, _fallback: 'node-native' },
+                });
+                if (fallbackResult.success || fallbackResult.metadata?.searchStatus !== 'search_failed') {
+                    result = fallbackResult;
+                }
+            }
             const summary = this.formatToolResult(call, result);
             if (!this.jsonOutput) {
                 console.log(result.success ? chalk_1.default.gray(summary) : chalk_1.default.red(summary));
             }
             this.messages.push({ role: 'system', content: summary });
+            // Phase 5: Track tool evidence for quality gates
+            const finalStatus = result.metadata?.searchStatus;
+            if (finalStatus === 'search_failed') {
+                this.agentToolEvidence.searchFailed += 1;
+            }
+            else if (/^(read_file|list_dir|glob|grep|git|repo|fetch_url)$/.test(call.tool)) {
+                this.agentToolEvidence.discovery += 1;
+            }
+            else if (/^(write_file|edit_file|bash|ssh_exec)$/.test(call.tool)) {
+                this.agentToolEvidence.mutation += 1;
+            }
         }
     }
     formatToolResult(call, result) {
-        const parts = [`Tool ${call.tool} ${result.success ? 'succeeded' : 'failed'}.`];
+        const parts = [`Tool ${call.tool} ${result.success ? 'succeeded' : 'FAILED'}.`];
+        // Include search status classification for the agent to reason about
+        const searchStatus = result.metadata?.searchStatus;
+        if (searchStatus) {
+            parts.push(`Search status: ${searchStatus}`);
+        }
         if (result.output) {
             parts.push(`Output:\n${this.truncateText(result.output)}`);
         }

package/dist/utils/api.d.ts

@@ -188,6 +188,7 @@ export declare class APIClient {
     private getAccessToken;
     getV3AgentBaseUrls(preferLocal?: boolean): string[];
     getV3AgentRunUrl(baseUrl: string): string;
+    getV3AgentContinueUrl(baseUrl: string): string;
     getOperatorBaseUrls(): string[];
     getOperatorStreamUrl(baseUrl: string): string;
     getMcpBaseUrls(): string[];

package/dist/utils/api.js

@@ -26,9 +26,9 @@ const DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS = (() => {
     return Number.isFinite(parsed) && parsed > 0 ? parsed : 90000;
 })();
 const DEFAULT_OPERATOR_TIMEOUT_MS = (() => {
-    const rawValue = process.env.VIGTHORIA_OPERATOR_TIMEOUT_MS || process.env.OPERATOR_TIMEOUT_MS || '1200000';
+    const rawValue = process.env.VIGTHORIA_OPERATOR_TIMEOUT_MS || process.env.OPERATOR_TIMEOUT_MS || '3900000';
     const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 1200000;
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 3900000;
 })();
 class APIClient {
     client;
@@ -276,6 +276,12 @@ class APIClient {
         }
         return `${baseUrl}/api/v3-agent/run`;
     }
+    getV3AgentContinueUrl(baseUrl) {
+        if (/127\.0\.0\.1:8030|localhost:8030/.test(baseUrl)) {
+            return `${baseUrl}/api/agent/continue`;
+        }
+        return `${baseUrl}/api/v3-agent/continue`;
+    }
     getOperatorBaseUrls() {
         const configuredModelsApiUrl = String(this.config.get('modelsApiUrl') || 'https://api.vigthoria.io').replace(/\/$/, '');
         const urls = [
@@ -2234,6 +2240,19 @@ document.addEventListener('DOMContentLoaded', () => {
                     }
                 }
                 if (event.type === 'error') {
+                    if (event.checkpointed && event.task_id) {
+                        // Agent checkpointed — return data so caller can auto-continue
+                        return {
+                            task_id: event.task_id,
+                            context_id: contextId,
+                            result: final || event,
+                            events,
+                            files: streamedFiles,
+                            partial: true,
+                            checkpointed: true,
+                            checkpointed_task_id: event.task_id,
+                        };
+                    }
                     if (this.hasAgentWorkspaceOutput(context)) {
                         return {
                             task_id: events.find((entry) => entry && entry.task_id)?.task_id || null,
@@ -2312,6 +2331,66 @@ document.addEventListener('DOMContentLoaded', () => {
                         throw new Error(`V3 agent ${response.status}: ${errorText.slice(0, 200)}`);
                     }
                     const data = await this.collectV3AgentStream(response, requestExecutionContext);
+                    // Auto-continuation: if the agent checkpointed (budget exceeded), continue automatically
+                    if (data.checkpointed && data.checkpointed_task_id) {
+                        const maxContinuations = 10;
+                        let continuationData = data;
+                        let continuations = 0;
+                        while (continuationData.checkpointed && continuationData.checkpointed_task_id && continuations < maxContinuations) {
+                            continuations++;
+                            if (typeof requestExecutionContext.onStreamEvent === 'function') {
+                                try {
+                                    requestExecutionContext.onStreamEvent({
+                                        type: 'message',
+                                        content: `Auto-continuing task (phase ${continuations + 1})...`,
+                                    });
+                                }
+                                catch { /* ignore */ }
+                            }
+                            const continueBody = {
+                                task_id: continuationData.checkpointed_task_id,
+                                context: requestBody.context,
+                                context_id: requestBody.context_id,
+                                mcp_context_id: requestBody.mcp_context_id,
+                                stream: true,
+                            };
+                            const continueController = new AbortController();
+                            const continueTimeoutId = setTimeout(() => continueController.abort(), timeoutMs);
+                            try {
+                                const continueHeaders = await this.getV3AgentHeaders();
+                                const continueResponse = await fetch(this.getV3AgentContinueUrl(baseUrl), {
+                                    method: 'POST',
+                                    headers: { ...continueHeaders, 'Content-Type': 'application/json' },
+                                    body: JSON.stringify(continueBody),
+                                    signal: continueController.signal,
+                                });
+                                if (!continueResponse.ok) {
+                                    break; // Fall through to normal completion with partial data
+                                }
+                                continuationData = await this.collectV3AgentStream(continueResponse, requestExecutionContext);
+                            }
+                            catch {
+                                break; // Fall through to normal completion with partial data
+                            }
+                            finally {
+                                clearTimeout(continueTimeoutId);
+                            }
+                        }
+                        // Use the final continuation data for workspace recovery
+                        this.recoverAgentWorkspaceFiles(executionContext, continuationData.files || {}, expectedFiles);
+                        await this.waitForAgentWorkspaceSettle(executionContext, { expectedFiles });
+                        await this.ensureAgentFrontendPolish(message, executionContext);
+                        const previewGate = await this.runTemplateServicePreviewGate(message, executionContext);
+                        const finalContextId = continuationData.context_id || data.context_id || response.headers.get('x-context-id') || requestExecutionContext.contextId || null;
+                        return {
+                            content: this.formatV3AgentResponse(continuationData) || this.formatV3AgentResponse(data),
+                            taskId: continuationData.task_id || data.task_id || null,
+                            contextId: finalContextId,
+                            backendUrl: baseUrl,
+                            partial: continuationData.checkpointed === true,
+                            metadata: { source: 'v3-agent', mode: 'agent', contextId: finalContextId, continuations, previewGate },
+                        };
+                    }
                     const contextId = data.context_id || response.headers.get('x-context-id') || requestExecutionContext.contextId || null;
                     const mcpContextId = response.headers.get('x-mcp-context-id') || requestExecutionContext.mcpContextId || null;
                     this.recoverAgentWorkspaceFiles(executionContext, data.files || {}, expectedFiles);

package/dist/utils/tools.d.ts

@@ -15,6 +15,7 @@
  */
 import { Logger } from './logger.js';
 export type RiskLevel = 'low' | 'medium' | 'high' | 'critical';
+export type SearchStatus = 'search_matches_found' | 'search_no_matches' | 'search_failed';
 export interface ToolResult {
     success: boolean;
     output?: string;
@@ -23,6 +24,7 @@ export interface ToolResult {
     canRetry?: boolean;
     undoable?: boolean;
     metadata?: {
+        searchStatus?: SearchStatus;
         [key: string]: any;
     };
 }
@@ -145,6 +147,26 @@ export declare class AgenticTools {
      */
     private bash;
     private grep;
+    /**
+     * Windows grep: rg > Select-String > Node-native
+     */
+    private grepWindows;
+    /**
+     * Unix grep: rg > system grep (BSD/GNU)
+     */
+    private grepUnix;
+    /**
+     * Search using ripgrep (rg) — works on all platforms
+     */
+    private grepWithRg;
+    /**
+     * Search using PowerShell Select-String (Windows)
+     */
+    private grepWithSelectString;
+    /**
+     * Pure Node.js recursive file search — reliable on all platforms, no external deps
+     */
+    private grepNodeNative;
     private listDir;
     private glob;
     private git;

package/dist/utils/tools.js

@@ -995,48 +995,270 @@ class AgenticTools {
     }
     grep(args) {
         const searchPath = args.path ? this.resolvePath(args.path) : this.cwd;
-        const include = args.include || '*';
-        const os = require('os');
-        // macOS uses BSD grep which has different options than GNU grep
-        const isMac = os.platform() === 'darwin';
+        const osModule = require('os');
+        const platform = osModule.platform();
+        // If forced fallback, go directly to Node-native
+        if (args._fallback === 'node-native') {
+            return this.grepNodeNative(args, searchPath);
+        }
+        // Try external search tools first (rg > grep/Select-String), fall back to Node-native
+        if (platform === 'win32') {
+            return this.grepWindows(args, searchPath);
+        }
+        return this.grepUnix(args, searchPath, platform);
+    }
+    /**
+     * Windows grep: rg > Select-String > Node-native
+     */
+    grepWindows(args, searchPath) {
+        // 1. Try ripgrep (rg) first — best cross-platform search tool
+        try {
+            (0, child_process_1.execSync)('rg --version', { encoding: 'utf-8', timeout: 5000, stdio: 'pipe' });
+            return this.grepWithRg(args, searchPath);
+        }
+        catch { /* rg not available */ }
+        // 2. Try PowerShell Select-String
+        try {
+            return this.grepWithSelectString(args, searchPath);
+        }
+        catch { /* Select-String failed */ }
+        // 3. Fall back to Node-native recursive file scanner
+        return this.grepNodeNative(args, searchPath);
+    }
+    /**
+     * Unix grep: rg > system grep (BSD/GNU)
+     */
+    grepUnix(args, searchPath, platform) {
+        // Try ripgrep first if available
+        try {
+            (0, child_process_1.execSync)('rg --version', { encoding: 'utf-8', timeout: 5000, stdio: 'pipe' });
+            return this.grepWithRg(args, searchPath);
+        }
+        catch { /* rg not available, fall through to system grep */ }
+        const isMac = platform === 'darwin';
         let cmd;
         if (isMac) {
-            // BSD grep: use -r for recursive, -n for line numbers
-            // Note: BSD grep doesn't support --color=never, just omit it
-            if (args.include) {
-                cmd = `grep -rn --include="${args.include}" "${args.pattern}" "${searchPath}"`;
-            }
-            else {
-                cmd = `grep -rn "${args.pattern}" "${searchPath}"`;
-            }
+            cmd = args.include
+                ? `grep -rn --include="${args.include}" "${args.pattern}" "${searchPath}"`
+                : `grep -rn "${args.pattern}" "${searchPath}"`;
         }
         else {
-            // GNU grep (Linux)
-            if (args.include) {
-                cmd = `grep -rn --color=never --include="${args.include}" "${args.pattern}" "${searchPath}"`;
-            }
-            else {
-                cmd = `grep -rn --color=never "${args.pattern}" "${searchPath}"`;
+            cmd = args.include
+                ? `grep -rn --color=never --include="${args.include}" "${args.pattern}" "${searchPath}"`
+                : `grep -rn --color=never "${args.pattern}" "${searchPath}"`;
+        }
+        try {
+            const output = (0, child_process_1.execSync)(cmd, {
+                cwd: this.cwd,
+                encoding: 'utf-8',
+                maxBuffer: 5 * 1024 * 1024,
+                timeout: 30000,
+                env: { ...process.env, GREP_OPTIONS: '' },
+            });
+            return {
+                success: true,
+                output: output.trim(),
+                metadata: { searchStatus: 'search_matches_found' },
+            };
+        }
+        catch (error) {
+            // Distinguish real "no matches" (exit 1 + no stderr) from command failure
+            const stderr = (error.stderr || '').toString();
+            if (error.status === 1 && !stderr.trim()) {
+                return {
+                    success: true,
+                    output: 'No matches found',
+                    metadata: { searchStatus: 'search_no_matches' },
+                };
             }
+            // Real failure: command not found, permission denied, etc.
+            return {
+                success: false,
+                error: stderr || error.message,
+                suggestion: 'The grep command failed. Install ripgrep (rg) for best cross-platform search.',
+                canRetry: true,
+                metadata: { searchStatus: 'search_failed' },
+            };
+        }
+    }
+    /**
+     * Search using ripgrep (rg) — works on all platforms
+     */
+    grepWithRg(args, searchPath) {
+        let cmd = `rg -n --no-heading`;
+        if (args.include) {
+            cmd += ` -g "${args.include}"`;
         }
+        cmd += ` "${args.pattern}" "${searchPath}"`;
         try {
             const output = (0, child_process_1.execSync)(cmd, {
                 cwd: this.cwd,
                 encoding: 'utf-8',
                 maxBuffer: 5 * 1024 * 1024,
                 timeout: 30000,
-                env: { ...process.env, GREP_OPTIONS: '' }, // Prevent user's grep options from interfering
             });
-            return { success: true, output: output.trim() };
+            return {
+                success: true,
+                output: output.trim(),
+                metadata: { searchStatus: 'search_matches_found', backend: 'ripgrep' },
+            };
         }
         catch (error) {
-            if (error.status === 1) {
-                // No matches found
-                return { success: true, output: 'No matches found' };
+            if (error.status === 1 && !(error.stderr || '').toString().trim()) {
+                return {
+                    success: true,
+                    output: 'No matches found',
+                    metadata: { searchStatus: 'search_no_matches', backend: 'ripgrep' },
+                };
             }
-            return { success: false, error: error.message };
+            throw error; // Let caller try next backend
         }
     }
+    /**
+     * Search using PowerShell Select-String (Windows)
+     */
+    grepWithSelectString(args, searchPath) {
+        // Normalize path for PowerShell
+        const psPath = searchPath.replace(/\//g, '\\');
+        const includeFilter = args.include
+            ? `-Include "${args.include}"`
+            : `-Include *`;
+        const escapedPattern = args.pattern.replace(/'/g, "''");
+        const cmd = `powershell -NoProfile -Command "Get-ChildItem -Path '${psPath}' -Recurse -File ${includeFilter} | Select-String -Pattern '${escapedPattern}' | ForEach-Object { $_.Path + ':' + $_.LineNumber + ':' + $_.Line }"`;
+        try {
+            const output = (0, child_process_1.execSync)(cmd, {
+                cwd: this.cwd,
+                encoding: 'utf-8',
+                maxBuffer: 5 * 1024 * 1024,
+                timeout: 60000,
+            });
+            const trimmed = output.trim();
+            if (!trimmed) {
+                return {
+                    success: true,
+                    output: 'No matches found',
+                    metadata: { searchStatus: 'search_no_matches', backend: 'select-string' },
+                };
+            }
+            return {
+                success: true,
+                output: trimmed,
+                metadata: { searchStatus: 'search_matches_found', backend: 'select-string' },
+            };
+        }
+        catch (error) {
+            const stderr = (error.stderr || '').toString();
+            // Select-String returns exit code 1 for no matches when used in pipeline
+            if (error.status === 1 && !stderr.trim()) {
+                return {
+                    success: true,
+                    output: 'No matches found',
+                    metadata: { searchStatus: 'search_no_matches', backend: 'select-string' },
+                };
+            }
+            throw error; // Let caller try next backend
+        }
+    }
+    /**
+     * Pure Node.js recursive file search — reliable on all platforms, no external deps
+     */
+    grepNodeNative(args, searchPath) {
+        const { minimatch } = (() => {
+            try {
+                return require('minimatch');
+            }
+            catch {
+                return { minimatch: null };
+            }
+        })();
+        const results = [];
+        let regex;
+        try {
+            regex = new RegExp(args.pattern, 'i');
+        }
+        catch {
+            // If pattern is not valid regex, treat as literal
+            regex = new RegExp(args.pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i');
+        }
+        const includeGlob = args.include || null;
+        const maxResults = 500;
+        const skipDirs = new Set(['node_modules', '.git', 'dist', 'build', '__pycache__', '.next', 'vendor', '.venv']);
+        const walk = (dir) => {
+            if (results.length >= maxResults)
+                return;
+            let entries;
+            try {
+                entries = fs.readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return; // Permission denied or inaccessible
+            }
+            for (const entry of entries) {
+                if (results.length >= maxResults)
+                    break;
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (!skipDirs.has(entry.name)) {
+                        walk(fullPath);
+                    }
+                    continue;
+                }
+                if (!entry.isFile())
+                    continue;
+                // Check include pattern
+                if (includeGlob) {
+                    const matches = minimatch
+                        ? minimatch(entry.name, includeGlob)
+                        : entry.name.endsWith(includeGlob.replace('*', ''));
+                    if (!matches)
+                        continue;
+                }
+                // Skip binary files by extension
+                const ext = path.extname(entry.name).toLowerCase();
+                const binaryExts = new Set(['.png', '.jpg', '.jpeg', '.gif', '.ico', '.woff', '.woff2', '.ttf', '.eot', '.zip', '.tar', '.gz', '.exe', '.dll', '.so', '.dylib', '.pdf', '.mp3', '.mp4', '.wav', '.avi', '.mov']);
+                if (binaryExts.has(ext))
+                    continue;
+                try {
+                    const content = fs.readFileSync(fullPath, 'utf-8');
+                    const lines = content.split('\n');
+                    for (let i = 0; i < lines.length; i++) {
+                        if (regex.test(lines[i])) {
+                            const relativePath = path.relative(this.cwd, fullPath).replace(/\\/g, '/');
+                            results.push(`${relativePath}:${i + 1}:${lines[i]}`);
+                            if (results.length >= maxResults)
+                                break;
+                        }
+                    }
+                }
+                catch {
+                    // Skip files that can't be read (binary, encoding issues, etc.)
+                }
+            }
+        };
+        try {
+            walk(searchPath);
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `File search failed: ${error.message}`,
+                metadata: { searchStatus: 'search_failed', backend: 'node-native' },
+            };
+        }
+        if (results.length === 0) {
+            return {
+                success: true,
+                output: 'No matches found',
+                metadata: { searchStatus: 'search_no_matches', backend: 'node-native' },
+            };
+        }
+        const truncationNote = results.length >= maxResults ? `\n...[truncated at ${maxResults} matches]` : '';
+        return {
+            success: true,
+            output: results.join('\n') + truncationNote,
+            metadata: { searchStatus: 'search_matches_found', backend: 'node-native' },
+        };
+    }
     listDir(args) {
         const dirPath = this.resolvePath(args.path);
         if (!fs.existsSync(dirPath)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.6.15",
+  "version": "1.6.17",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "main": "dist/index.js",
   "files": [