vigthoria-cli 1.10.36 → 1.10.37

package/dist/commands/chat.d.ts

@@ -26,6 +26,7 @@ export declare class ChatCommand {
     private tools;
     private sessionManager;
     private projectMemory;
+    private workspaceBrain;
     private currentSession;
     private agentMode;
     private currentProjectPath;
@@ -103,6 +104,10 @@ export declare class ChatCommand {
     private isProjectBrainRuntimeDisabled;
     private buildProjectBrainRuntimeContext;
     private rememberBrainEvent;
+    private initializeWorkspaceBrain;
+    private bootstrapWorkspaceBrain;
+    private reindexWorkspaceBrain;
+    private showBrainIndexStatus;
     private getPromptRuntimeContext;
     private v3IterationCount;
     private v3ToolCallCount;
@@ -167,6 +172,7 @@ export declare class ChatCommand {
     private buildLocalAgentChatOptions;
     private printChatModelPreflight;
     private runLocalAgentLoop;
+    private primeAgentWorkspaceDiscovery;
     private primeBypassedTargetFileContext;
     private tryDirectSingleFileFlow;
     private isConfirmationFollowUp;

package/dist/commands/chat.js

@@ -11,6 +11,7 @@ import { BridgeClient, getBridgeClient } from '../utils/bridge-client.js';
 import { WorkspaceWatcher, WorkspaceWSClient } from '../utils/workspace-stream.js';
 import { TaskDisplay } from '../utils/task-display.js';
 import { ProjectMemoryService } from '../utils/project-memory.js';
+import { WorkspaceBrainService } from '../utils/workspace-brain-service.js';
 import { buildPersonaOverlay, normalizePersonaMode } from '../utils/persona.js';
 const DEFAULT_V3_AGENT_TIMEOUT_MS = (() => {
     const rawValue = process.env.VIGTHORIA_AGENT_TIMEOUT_MS || process.env.V3_AGENT_TIMEOUT_MS;
@@ -44,6 +45,7 @@ export class ChatCommand {
     tools = null;
     sessionManager;
     projectMemory = null;
+    workspaceBrain = null;
     currentSession = null;
     agentMode = false;
     currentProjectPath = process.cwd();
@@ -333,6 +335,17 @@ export class ChatCommand {
                 messages.splice(insertionIndex, 0, memoryMessage);
             }
         }
+        const codebaseContext = this.workspaceBrain?.buildCodebaseContext(this.getLastUserPrompt()) || '';
+        if (codebaseContext && !messages.some((message) => message.role === 'system' && message.content.includes('Vigthoria codebase index context.'))) {
+            const insertionIndex = messages.findIndex((message) => message.role !== 'system');
+            const codebaseMessage = { role: 'system', content: codebaseContext };
+            if (insertionIndex === -1) {
+                messages.push(codebaseMessage);
+            }
+            else {
+                messages.splice(insertionIndex, 0, codebaseMessage);
+            }
+        }
         if (options?.compact) {
             const compactLimit = 6000;
             const systemMessages = messages.filter((message) => message.role === 'system').map((message) => ({
@@ -879,6 +892,82 @@ export class ChatCommand {
             // Project Brain memory must not break chat, GoA, or operator execution.
         }
     }
+    initializeWorkspaceBrain() {
+        if (this.isProjectBrainRuntimeDisabled()) {
+            return;
+        }
+        this.workspaceBrain = new WorkspaceBrainService({
+            workspacePath: this.currentProjectPath,
+            apiBase: String(this.config.get('apiUrl') || 'https://coder.vigthoria.io'),
+            getAuthToken: () => this.config.get('authToken'),
+        });
+        this.tools?.setIndexedCodebaseSearch((query, maxResults) => (this.workspaceBrain?.searchCodebase(query, maxResults) || ''));
+    }
+    async bootstrapWorkspaceBrain(interactive) {
+        if (!this.workspaceBrain) {
+            return;
+        }
+        const promptIfMissing = interactive
+            && !this.jsonOutput
+            && process.stdin.isTTY
+            && !/^(0|false|no)$/i.test(String(process.env.VIGTHORIA_PROMPT_INDEX || '1'));
+        const result = await this.workspaceBrain.ensureIndexed({
+            promptIfMissing,
+            askToIndex: promptIfMissing
+                ? async (fileCount, workspaceName) => new Promise((resolve) => {
+                    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+                    rl.question(chalk.cyan(`Index "${workspaceName}" for Vigthoria Brain? (~${fileCount} source files) [Y/n] `), (answer) => {
+                        rl.close();
+                        const normalized = answer.trim().toLowerCase();
+                        resolve(normalized === 'n' || normalized === 'no' ? 'later' : 'index_now');
+                    });
+                })
+                : undefined,
+        });
+        if (result.indexed && result.fileCount > 0 && !this.jsonOutput) {
+            console.log(chalk.gray(`Brain index ready: ${result.fileCount} files, ${result.chunkCount} chunks`));
+        }
+        else if (result.prompted === 'later' && !this.jsonOutput) {
+            console.log(chalk.gray('Workspace indexing skipped. Use /index anytime.'));
+        }
+    }
+    async reindexWorkspaceBrain() {
+        if (!this.workspaceBrain) {
+            this.initializeWorkspaceBrain();
+        }
+        if (!this.workspaceBrain) {
+            console.log(chalk.yellow('Workspace Brain is disabled.'));
+            return;
+        }
+        const spinner = createSpinner({ text: 'Indexing workspace for Vigthoria Brain...', spinner: 'clock' }).start();
+        try {
+            const meta = await this.workspaceBrain.reindexWorkspace();
+            spinner.stop();
+            console.log(chalk.green(`Indexed ${meta.indexedFileCount} files (${meta.totalChunks} chunks). Brain Hub sync attempted.`));
+        }
+        catch (error) {
+            spinner.stop();
+            this.logger.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+    showBrainIndexStatus() {
+        if (!this.workspaceBrain) {
+            console.log(chalk.yellow('Workspace Brain is disabled (VIGTHORIA_NO_BRAIN=1).'));
+            return;
+        }
+        const status = this.workspaceBrain.getStatus();
+        console.log();
+        console.log(chalk.white('Workspace Brain Index:'));
+        console.log(chalk.gray(`Workspace: ${status.workspacePath}`));
+        console.log(chalk.gray(`Files indexed: ${status.indexedFileCount}`));
+        console.log(chalk.gray(`Chunks: ${status.totalChunks}`));
+        if (status.meta?.indexedAt) {
+            console.log(chalk.gray(`Last indexed: ${status.meta.indexedAt}`));
+        }
+        if (status.meta?.indexHash) {
+            console.log(chalk.gray(`Index hash: ${status.meta.indexHash}`));
+        }
+    }
     async getPromptRuntimeContext(prompt) {
         const runtimeContext = {
             agentRuntime: this.getRuntimeEnvironmentContext(),
@@ -887,6 +976,22 @@ export class ChatCommand {
         if (brainContext) {
             runtimeContext.vigthoriaBrain = brainContext;
         }
+        if (this.workspaceBrain) {
+            const accountBrain = await this.workspaceBrain.fetchAccountBrainContext();
+            if (accountBrain) {
+                runtimeContext.accountBrainContext = accountBrain;
+            }
+            const indexStatus = this.workspaceBrain.getStatus();
+            runtimeContext.codebaseIndex = {
+                indexedFileCount: indexStatus.indexedFileCount,
+                totalChunks: indexStatus.totalChunks,
+                indexHash: indexStatus.meta?.indexHash || null,
+            };
+            const indexedContext = this.workspaceBrain.buildCodebaseContext(prompt);
+            if (indexedContext) {
+                runtimeContext.codebaseContext = indexedContext;
+            }
+        }
         if (!this.isBrowserTaskPrompt(prompt)) {
             return runtimeContext;
         }
@@ -1508,6 +1613,8 @@ export class ChatCommand {
         this.directToolContinuationCount = 0;
         this.tools = new AgenticTools(this.logger, this.currentProjectPath, async (action) => this.requestPermission(action), this.autoApprove);
         this.initializeSession(options.resume === true);
+        this.initializeWorkspaceBrain();
+        await this.bootstrapWorkspaceBrain(!options.prompt);
         // ── Commando Bridge: connect if --bridge was specified ──────────
         if (options.bridge) {
             const bridgeClient = new BridgeClient({
@@ -2344,7 +2451,9 @@ export class ChatCommand {
         this.tools.clearSessionApprovals();
         getBridgeClient()?.emitPrompt({ prompt, mode: this.operatorMode ? 'operator' : 'agent', model: this.currentModel });
         this.ensureAgentSystemPrompt();
-        this.messages.push({ role: 'user', content: this.buildScopedUserPrompt(prompt) });
+        const scopedPrompt = this.buildScopedUserPrompt(this.buildContextualAgentPrompt(prompt));
+        this.messages.push({ role: 'user', content: scopedPrompt });
+        await this.primeAgentWorkspaceDiscovery(prompt);
         this.saveSession();
         const preflightSpinner = this.jsonOutput
             ? null
@@ -2511,18 +2620,25 @@ export class ChatCommand {
                     // Detect resignation: model gives up saying files/things were "not found"
                     // without having tried list_dir to discover the correct path.
                     const isResignation = /(?:not found|cannot be (?:determined|compared|completed)|do not exist|does not exist|unable to locate|neither.*exist|could not (?:find|locate)|no (?:such|matching) file)/i.test(sanitized) && this.agentToolEvidence.discovery < 4;
+                    const actionablePrompt = this.lastActionableUserInput || prompt;
+                    const needsRepoWork = this.isDiagnosticPrompt(actionablePrompt) || this.isImplementationPrompt(actionablePrompt);
                     // Gate 1: First turn with no discovery at all
-                    const gate1 = turn === 0 && this.agentToolEvidence.discovery === 0 && (this.isDiagnosticPrompt(prompt) || this.directPromptMode || isPolicyAck);
+                    const gate1 = turn === 0 && this.agentToolEvidence.discovery === 0 && (needsRepoWork || this.directPromptMode || this.agentMode || isPolicyAck);
                     // Gate 2: Any turn where the response is just a follow-up question,
                     // tool-failure echoes, or premature resignation (the model gave up
                     // instead of retrying with list_dir to find the correct paths)
-                    const gate2 = this.directPromptMode && turn < 6 && (isPolicyAck || isFollowUp || isEmptyAfterSanitize || isResignation);
+                    const gate2 = (this.directPromptMode || this.agentMode) && turn < 6 && (isPolicyAck || isFollowUp || isEmptyAfterSanitize || isResignation);
+                    const gateNoToolsNoWork = needsRepoWork
+                        && this.agentToolEvidence.discovery === 0
+                        && this.agentToolEvidence.mutation === 0
+                        && turn < maxTurns - 1
+                        && (isEmptyAfterSanitize || isPolicyAck || isFollowUp);
                     // Gate 3: Model outputs code blocks as text instead of using write_file.
                     // If the response contains ``` code fences but no write_file was called,
                     // reject and instruct the model to use write_file.
                     const hasCodeBlocks = (sanitized.match(/```/g) || []).length >= 2;
                     const gate3 = hasCodeBlocks && this.agentToolEvidence.mutation === 0 && turn < 6;
-                    if (gate1 || gate2 || gate3) {
+                    if (gate1 || gate2 || gate3 || gateNoToolsNoWork) {
                         // Remove the useless response from history
                         if (isPolicyAck || isFollowUp || isEmptyAfterSanitize || isResignation || gate3) {
                             this.messages.pop();
@@ -2618,6 +2734,36 @@ export class ChatCommand {
         this.saveSession();
         return true;
     }
+    async primeAgentWorkspaceDiscovery(prompt) {
+        if (!this.tools || this.agentToolEvidence.discovery > 0) {
+            return;
+        }
+        const actionablePrompt = this.buildContextualAgentPrompt(prompt);
+        if (!this.isDiagnosticPrompt(actionablePrompt) && !this.isImplementationPrompt(actionablePrompt)) {
+            return;
+        }
+        const listCall = {
+            tool: 'list_dir',
+            args: { path: '.' },
+        };
+        if (!this.jsonOutput) {
+            console.log(chalk.cyan('⚙ Executing: list_dir → workspace root (agent bootstrap)'));
+        }
+        const result = await this.tools.execute(listCall);
+        const summary = this.formatToolResult(listCall, result);
+        if (!this.jsonOutput) {
+            console.log(result.success ? chalk.gray(summary) : chalk.red(summary));
+        }
+        this.messages.push({ role: 'system', content: summary });
+        getBridgeClient()?.emitToolResult({
+            tool: listCall.tool,
+            success: result.success,
+            preview: (result.output || result.error || '').slice(0, 300),
+        });
+        if (result.success) {
+            this.agentToolEvidence.discovery += 1;
+        }
+    }
     async primeBypassedTargetFileContext(prompt) {
         if (!this.directPromptMode || !this.tools) {
             return;
@@ -2763,7 +2909,7 @@ export class ChatCommand {
     }
     isConfirmationFollowUp(prompt) {
         const normalized = prompt.trim().toLowerCase().replace(/[.!?]+$/g, '').replace(/\s+/g, ' ');
-        return /^(ja|ja bitte|ja bitte mach das|mach das|bitte mach das|genau|ok|okay|yes|yes please|please do|do it|go ahead|continue|proceed|make it so)$/.test(normalized);
+        return /^(ja|ja bitte|ja bitte mach das|mach das|bitte mach das|genau|ok|okay|yes|yes please|please do|do it|go ahead|go on|continue|proceed|make it so|keep going|next)$/.test(normalized);
     }
     getPreviousActionablePrompt() {
         if (this.lastActionableUserInput && !this.isConfirmationFollowUp(this.lastActionableUserInput)) {
@@ -3481,6 +3627,14 @@ export class ChatCommand {
                 this.showProjectMemory();
                 continue;
             }
+            if (trimmed === '/index') {
+                await this.reindexWorkspaceBrain();
+                continue;
+            }
+            if (trimmed === '/brain') {
+                this.showBrainIndexStatus();
+                continue;
+            }
             if (trimmed === '/compact') {
                 this.compactCurrentSession();
                 continue;
@@ -3629,6 +3783,8 @@ export class ChatCommand {
         console.log('  /operator      Toggle BMAD operator mode');
         console.log('  /context       Show current session and project memory');
         console.log('  /memory        Show Vigthoria project brain status');
+        console.log('  /brain         Show workspace codebase index status');
+        console.log('  /index         Re-index workspace and sync to Brain Hub');
         console.log('  /compact       Compact current session into memory summary');
         console.log('  /clear         Clear conversation');
         console.log('  /save          Save session');
@@ -4357,6 +4513,15 @@ Now implement the missing fixes by editing the local workspace files. Use write/
         if (fallback) {
             return fallback;
         }
+        if (this.agentToolEvidence.discovery === 0 && this.agentToolEvidence.mutation === 0) {
+            if (this.isImplementationPrompt(prompt) || this.isDiagnosticPrompt(prompt)) {
+                return [
+                    'The agent did not inspect the workspace or run any tools before finishing.',
+                    'This usually means the model backend returned an empty response.',
+                    'Try the request again. If it keeps happening, check Vigthoria Coder / vLLM logs on the server.',
+                ].join(' ');
+            }
+        }
         return sanitized || 'Task complete.';
     }
     /**

package/dist/utils/brain-hub-client.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Brain Hub client — sync workspace index + fetch account brain context
+ * via coder.vigthoria.io (JWT-authenticated).
+ */
+export type BrainSyncPayload = {
+    workspaceName: string;
+    workspacePath: string;
+    fileCount: number;
+    chunkCount: number;
+    topFiles: string[];
+    summary: string;
+    indexHash: string;
+};
+export type BrainContextResponse = {
+    ok: boolean;
+    formattedText?: string;
+    memories?: Array<Record<string, unknown>>;
+    error?: string;
+    skipped?: boolean;
+    reason?: string;
+};
+export declare class BrainHubClient {
+    private apiBase;
+    private getAuthToken;
+    constructor(options: {
+        apiBase?: string;
+        getAuthToken: () => string | null | Promise<string | null>;
+    });
+    private headers;
+    syncWorkspaceIndex(payload: BrainSyncPayload): Promise<Record<string, unknown>>;
+    fetchAccountContext(limit?: number): Promise<BrainContextResponse>;
+}

package/dist/utils/brain-hub-client.js

@@ -0,0 +1,48 @@
+/**
+ * Brain Hub client — sync workspace index + fetch account brain context
+ * via coder.vigthoria.io (JWT-authenticated).
+ */
+export class BrainHubClient {
+    apiBase;
+    getAuthToken;
+    constructor(options) {
+        this.apiBase = (options.apiBase || 'https://coder.vigthoria.io').replace(/\/$/, '');
+        this.getAuthToken = options.getAuthToken;
+    }
+    async headers() {
+        const headers = { 'Content-Type': 'application/json' };
+        const token = await this.getAuthToken();
+        if (token) {
+            headers.Authorization = `Bearer ${token}`;
+        }
+        return headers;
+    }
+    async syncWorkspaceIndex(payload) {
+        const headers = await this.headers();
+        if (!headers.Authorization) {
+            return { ok: false, skipped: true, reason: 'not_authenticated' };
+        }
+        const resp = await fetch(`${this.apiBase}/api/brain/sync-index`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(payload),
+        });
+        const data = await resp.json().catch(() => ({}));
+        if (!resp.ok) {
+            return { ok: false, error: data.error || `HTTP ${resp.status}` };
+        }
+        return data;
+    }
+    async fetchAccountContext(limit = 25) {
+        const headers = await this.headers();
+        if (!headers.Authorization) {
+            return { ok: false, formattedText: '', memories: [] };
+        }
+        const resp = await fetch(`${this.apiBase}/api/brain/context?limit=${limit}`, { headers });
+        const data = await resp.json().catch(() => ({}));
+        if (!resp.ok) {
+            return { ok: false, formattedText: '', error: data.error || `HTTP ${resp.status}` };
+        }
+        return data;
+    }
+}

package/dist/utils/codebase-indexer.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Local TF-IDF codebase indexer for CLI (mirrors Vigthoria Code extension indexer).
+ */
+export type CodebaseSearchResult = {
+    filePath: string;
+    relativePath: string;
+    startLine: number;
+    endLine: number;
+    content: string;
+    language: string;
+    score: number;
+    symbol: string | null;
+};
+export type IndexMeta = {
+    indexedFileCount: number;
+    totalChunks: number;
+    indexHash: string;
+    topFiles: string[];
+    indexedAt: string;
+};
+export declare class CodebaseIndexer {
+    private workspaceRoot;
+    private index;
+    private invertedIndex;
+    private chunkStore;
+    private fileHashes;
+    private indexedFileCount;
+    private totalChunks;
+    private isIndexing;
+    private readonly maxFileSize;
+    private readonly chunkSize;
+    private readonly chunkOverlap;
+    private readonly maxResults;
+    private readonly ignorePatterns;
+    private readonly supportedExtensions;
+    constructor(workspaceRoot: string);
+    getStatus(): {
+        indexedFileCount: number;
+        totalChunks: number;
+        isIndexing: boolean;
+    };
+    static metaPath(workspaceRoot: string): string;
+    static loadMeta(workspaceRoot: string): IndexMeta | null;
+    private saveMeta;
+    hasLocalIndex(): boolean;
+    countCandidateFiles(): number;
+    countIndexableFiles(): number;
+    indexWorkspace(): Promise<IndexMeta>;
+    search(query: string, maxResults?: number): CodebaseSearchResult[];
+    getContextForQuery(query: string, maxTokens?: number): string;
+    formatSearchResults(query: string, maxResults?: number): string;
+    private findFiles;
+    private indexFile;
+    private chunkFile;
+    private tokenize;
+    private isStopWord;
+    private getLanguage;
+    private shouldIgnore;
+}

package/dist/utils/codebase-indexer.js

@@ -0,0 +1,314 @@
+/**
+ * Local TF-IDF codebase indexer for CLI (mirrors Vigthoria Code extension indexer).
+ */
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+export class CodebaseIndexer {
+    workspaceRoot;
+    index = new Map();
+    invertedIndex = new Map();
+    chunkStore = new Map();
+    fileHashes = new Map();
+    indexedFileCount = 0;
+    totalChunks = 0;
+    isIndexing = false;
+    maxFileSize = 1024 * 1024;
+    chunkSize = 50;
+    chunkOverlap = 5;
+    maxResults = 10;
+    ignorePatterns = [
+        'node_modules', '.git', 'dist', 'build', 'out', '.next',
+        '__pycache__', '.pytest_cache', '.mypy_cache', 'venv', 'env',
+        '.DS_Store', 'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml',
+        '.vsix', '.map', '.min.js', '.min.css', 'coverage',
+        '.cache', '.tmp', 'tmp', 'temp', '.idea', '.vscode',
+    ];
+    supportedExtensions = new Set([
+        '.js', '.ts', '.jsx', '.tsx', '.py', '.java', '.go', '.rs',
+        '.c', '.cpp', '.h', '.hpp', '.cs', '.rb', '.php', '.swift',
+        '.kt', '.scala', '.vue', '.svelte', '.astro',
+        '.html', '.css', '.scss', '.less', '.sass',
+        '.json', '.yaml', '.yml', '.toml', '.xml',
+        '.md', '.txt', '.rst', '.sh', '.bash', '.zsh',
+        '.sql', '.graphql', '.prisma', '.env',
+        '.dockerfile', '.tf', '.hcl',
+    ]);
+    constructor(workspaceRoot) {
+        this.workspaceRoot = path.resolve(workspaceRoot);
+    }
+    getStatus() {
+        return {
+            indexedFileCount: this.indexedFileCount,
+            totalChunks: this.totalChunks,
+            isIndexing: this.isIndexing,
+        };
+    }
+    static metaPath(workspaceRoot) {
+        return path.join(workspaceRoot, '.vigthoria', 'index', 'meta.json');
+    }
+    static loadMeta(workspaceRoot) {
+        try {
+            const metaPath = CodebaseIndexer.metaPath(workspaceRoot);
+            if (fs.existsSync(metaPath)) {
+                return JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+            }
+        }
+        catch {
+            // fresh workspace
+        }
+        return null;
+    }
+    saveMeta(meta) {
+        const dir = path.join(this.workspaceRoot, '.vigthoria', 'index');
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(CodebaseIndexer.metaPath(this.workspaceRoot), `${JSON.stringify(meta, null, 2)}\n`);
+    }
+    hasLocalIndex() {
+        const meta = CodebaseIndexer.loadMeta(this.workspaceRoot);
+        return !!(meta && meta.indexedFileCount > 0) || this.totalChunks > 0;
+    }
+    countCandidateFiles() {
+        return this.findFiles(this.workspaceRoot).length;
+    }
+    countIndexableFiles() {
+        return this.findFiles(this.workspaceRoot).length;
+    }
+    async indexWorkspace() {
+        if (this.isIndexing) {
+            return {
+                indexedFileCount: this.indexedFileCount,
+                totalChunks: this.totalChunks,
+                indexHash: '',
+                topFiles: [],
+                indexedAt: new Date().toISOString(),
+            };
+        }
+        this.isIndexing = true;
+        this.index.clear();
+        this.invertedIndex.clear();
+        this.chunkStore.clear();
+        this.fileHashes.clear();
+        this.indexedFileCount = 0;
+        this.totalChunks = 0;
+        try {
+            const files = this.findFiles(this.workspaceRoot);
+            for (const filePath of files) {
+                this.indexFile(filePath);
+            }
+            const indexHash = crypto.createHash('sha256')
+                .update(`${this.indexedFileCount}:${this.totalChunks}:${files.length}`)
+                .digest('hex')
+                .slice(0, 16);
+            const topFiles = files.slice(0, 12).map((filePath) => path.relative(this.workspaceRoot, filePath));
+            const meta = {
+                indexedFileCount: this.indexedFileCount,
+                totalChunks: this.totalChunks,
+                indexHash,
+                topFiles,
+                indexedAt: new Date().toISOString(),
+            };
+            this.saveMeta(meta);
+            return meta;
+        }
+        finally {
+            this.isIndexing = false;
+        }
+    }
+    search(query, maxResults = this.maxResults) {
+        if (this.totalChunks === 0) {
+            return [];
+        }
+        const queryTerms = this.tokenize(query.toLowerCase());
+        const scores = new Map();
+        for (const term of queryTerms) {
+            const matchingChunks = this.invertedIndex.get(term);
+            if (!matchingChunks)
+                continue;
+            const idf = Math.log(this.totalChunks / matchingChunks.size);
+            for (const chunkId of matchingChunks) {
+                const chunk = this.chunkStore.get(chunkId);
+                if (!chunk)
+                    continue;
+                const tf = (chunk.terms.get(term) || 0) / chunk.totalTerms;
+                scores.set(chunkId, (scores.get(chunkId) || 0) + tf * idf);
+            }
+        }
+        for (const [chunkId, score] of scores) {
+            const chunk = this.chunkStore.get(chunkId);
+            if (!chunk)
+                continue;
+            const fileName = path.basename(chunk.filePath).toLowerCase();
+            for (const term of queryTerms) {
+                if (fileName.includes(term)) {
+                    scores.set(chunkId, score * 1.5);
+                }
+            }
+        }
+        return Array.from(scores.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, maxResults)
+            .map(([chunkId, score]) => {
+            const chunk = this.chunkStore.get(chunkId);
+            return {
+                filePath: chunk.filePath,
+                relativePath: chunk.relativePath,
+                startLine: chunk.startLine,
+                endLine: chunk.endLine,
+                content: chunk.content,
+                language: chunk.language,
+                score: Math.round(score * 1000) / 1000,
+                symbol: chunk.symbol,
+            };
+        });
+    }
+    getContextForQuery(query, maxTokens = 4000) {
+        const results = this.search(query, 15);
+        if (results.length === 0) {
+            return '';
+        }
+        let context = '### Relevant code from workspace:\n\n';
+        let currentTokens = 0;
+        const avgCharsPerToken = 4;
+        for (const result of results) {
+            const entry = `**${result.relativePath}** (lines ${result.startLine}-${result.endLine}):\n\`\`\`${result.language}\n${result.content}\n\`\`\`\n\n`;
+            const entryTokens = Math.ceil(entry.length / avgCharsPerToken);
+            if (currentTokens + entryTokens > maxTokens)
+                break;
+            context += entry;
+            currentTokens += entryTokens;
+        }
+        return context;
+    }
+    formatSearchResults(query, maxResults = 30) {
+        const results = this.search(query, Math.min(maxResults, 20));
+        if (results.length === 0) {
+            return 'No indexed codebase matches found. Run /index or wait for workspace indexing to finish.';
+        }
+        return results.map((result) => (`[indexed:${result.score}] ${result.relativePath}:${result.startLine}-${result.endLine}`
+            + (result.symbol ? ` (${result.symbol})` : '')
+            + `\n${result.content.split('\n').slice(0, 8).join('\n')}`)).join('\n\n');
+    }
+    findFiles(rootPath) {
+        const files = [];
+        const walk = (currentDir, depth) => {
+            if (depth > 14 || files.length >= 10000)
+                return;
+            let entries;
+            try {
+                entries = fs.readdirSync(currentDir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (this.shouldIgnore(entry.name, path.join(currentDir, entry.name)))
+                    continue;
+                const fullPath = path.join(currentDir, entry.name);
+                if (entry.isDirectory()) {
+                    walk(fullPath, depth + 1);
+                }
+                else if (entry.isFile()) {
+                    const ext = path.extname(entry.name).toLowerCase();
+                    if (this.supportedExtensions.has(ext)) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+        };
+        walk(rootPath, 0);
+        return files;
+    }
+    indexFile(filePath) {
+        try {
+            const stat = fs.statSync(filePath);
+            if (!stat.isFile() || stat.size > this.maxFileSize || stat.size === 0)
+                return;
+            const content = fs.readFileSync(filePath, 'utf8');
+            const hash = crypto.createHash('md5').update(content).digest('hex');
+            if (this.fileHashes.get(filePath) === hash)
+                return;
+            this.fileHashes.set(filePath, hash);
+            const relativePath = path.relative(this.workspaceRoot, filePath);
+            const language = this.getLanguage(filePath);
+            const lines = content.split('\n');
+            const chunks = this.chunkFile(lines, filePath, relativePath, language);
+            const chunkIds = [];
+            for (const chunk of chunks) {
+                const chunkId = `${relativePath}:${chunk.startLine}-${chunk.endLine}`;
+                const terms = new Map();
+                const tokens = this.tokenize(chunk.content.toLowerCase());
+                let totalTerms = 0;
+                for (const token of tokens) {
+                    terms.set(token, (terms.get(token) || 0) + 1);
+                    totalTerms += 1;
+                    if (!this.invertedIndex.has(token)) {
+                        this.invertedIndex.set(token, new Set());
+                    }
+                    this.invertedIndex.get(token).add(chunkId);
+                }
+                this.chunkStore.set(chunkId, { ...chunk, terms, totalTerms });
+                chunkIds.push(chunkId);
+                this.totalChunks += 1;
+            }
+            this.index.set(filePath, chunkIds);
+            this.indexedFileCount += 1;
+        }
+        catch {
+            // skip unreadable files
+        }
+    }
+    chunkFile(lines, filePath, relativePath, language) {
+        const chunks = [];
+        for (let i = 0; i < lines.length; i += this.chunkSize - this.chunkOverlap) {
+            const endLine = Math.min(i + this.chunkSize, lines.length);
+            const chunkLines = lines.slice(i, endLine);
+            if (chunkLines.join('').trim().length === 0)
+                continue;
+            chunks.push({
+                filePath,
+                relativePath,
+                startLine: i + 1,
+                endLine,
+                content: chunkLines.join('\n'),
+                language,
+                symbol: null,
+            });
+        }
+        return chunks;
+    }
+    tokenize(text) {
+        return text
+            .replace(/[^a-zA-Z0-9_$]/g, ' ')
+            .split(/\s+/)
+            .filter((token) => token.length > 2)
+            .filter((token) => !this.isStopWord(token));
+    }
+    isStopWord(word) {
+        const stopWords = new Set([
+            'the', 'and', 'for', 'that', 'this', 'with', 'from', 'are',
+            'was', 'were', 'been', 'have', 'has', 'had', 'not', 'but',
+            'its', 'can', 'will', 'would', 'could', 'should', 'may',
+            'var', 'let', 'const', 'function', 'return', 'true', 'false',
+            'null', 'undefined', 'new', 'class', 'import', 'export',
+            'require', 'module', 'exports', 'default', 'async', 'await',
+        ]);
+        return stopWords.has(word);
+    }
+    getLanguage(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        const map = {
+            '.js': 'javascript', '.jsx': 'javascript',
+            '.ts': 'typescript', '.tsx': 'typescript',
+            '.py': 'python', '.html': 'html', '.css': 'css', '.json': 'json',
+            '.md': 'markdown', '.sh': 'shell', '.go': 'go', '.rs': 'rust',
+        };
+        return map[ext] || 'text';
+    }
+    shouldIgnore(name, fullPath) {
+        if (name.startsWith('.') && name !== '.env')
+            return true;
+        const lowerPath = fullPath.toLowerCase();
+        return this.ignorePatterns.some((pattern) => lowerPath.includes(pattern));
+    }
+}

package/dist/utils/tools.d.ts

@@ -95,12 +95,14 @@ export declare class AgenticTools {
     private requireNonEmptyString;
     private requireArgsObject;
     private sessionApprovedTools;
+    private indexedCodebaseSearch;
     private static permissionsFile;
     constructor(logger: Logger, cwd: string, permissionCallback: (action: string, options?: {
         batchApproval?: boolean;
     }) => Promise<boolean | 'batch' | 'persist'>, autoApprove?: boolean);
     /** Rebind tool execution to a different local workspace root (e.g. prompt path override). */
     setWorkspaceRoot(cwd: string): void;
+    setIndexedCodebaseSearch(handler: ((query: string, maxResults: number) => string) | null): void;
     getWorkspaceRoot(): string;
     private getErrorMessage;
     private assertToolCall;

package/dist/utils/tools.js

@@ -433,6 +433,7 @@ export class AgenticTools {
     }
     // Session-based tool approvals - remembers which tools user approved for this turn
     sessionApprovedTools = new Set();
+    indexedCodebaseSearch = null;
     // Persistent permissions - tool allowlists per project
     static permissionsFile = path.join(process.env.HOME || process.env.USERPROFILE || '~', '.vigthoria', 'permissions.json');
     constructor(logger, cwd, permissionCallback, autoApprove = false) {
@@ -460,6 +461,9 @@ export class AgenticTools {
         }
         this.cwd = path.resolve(cwd);
     }
+    setIndexedCodebaseSearch(handler) {
+        this.indexedCodebaseSearch = handler;
+    }
     getWorkspaceRoot() {
         return this.cwd;
     }
@@ -2815,6 +2819,16 @@ export class AgenticTools {
         const scope = args.scope || 'all';
         const includePattern = args.include || '';
         const maxResults = Math.min(parseInt(args.max_results || '30', 10), 100);
+        if (this.indexedCodebaseSearch && (scope === 'all' || scope === 'content')) {
+            const indexedOutput = this.indexedCodebaseSearch(query, maxResults);
+            if (indexedOutput && !indexedOutput.includes('No indexed codebase matches found')) {
+                return {
+                    success: true,
+                    output: indexedOutput,
+                    metadata: { searchStatus: 'search_matches_found', source: 'tfidf-index' },
+                };
+            }
+        }
         const results = [];
         const seen = new Set();
         // Helper: collect files recursively respecting gitignore-like patterns

package/dist/utils/workspace-brain-service.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Workspace Brain — local codebase index + Brain Hub sync for CLI.
+ */
+import { CodebaseIndexer, IndexMeta } from './codebase-indexer.js';
+export type WorkspaceBrainOptions = {
+    workspacePath: string;
+    apiBase?: string;
+    getAuthToken: () => string | null | Promise<string | null>;
+    autoIndex?: boolean;
+    brainSyncEnabled?: boolean;
+};
+export type EnsureIndexedResult = {
+    indexed: boolean;
+    fileCount: number;
+    chunkCount: number;
+    prompted?: 'index_now' | 'later' | 'skipped';
+};
+export declare class WorkspaceBrainService {
+    private workspacePath;
+    private indexer;
+    private brainClient;
+    private autoIndex;
+    private brainSyncEnabled;
+    private accountContextCache;
+    constructor(options: WorkspaceBrainOptions);
+    getIndexer(): CodebaseIndexer;
+    getStatus(): {
+        workspacePath: string;
+        indexedFileCount: number;
+        totalChunks: number;
+        isIndexing: boolean;
+        meta: IndexMeta | null;
+    };
+    ensureIndexed(options?: {
+        promptIfMissing?: boolean;
+        askToIndex?: (fileCount: number, workspaceName: string) => Promise<'index_now' | 'later'>;
+    }): Promise<EnsureIndexedResult>;
+    reindexWorkspace(): Promise<IndexMeta>;
+    buildCodebaseContext(prompt: string): string;
+    searchCodebase(query: string, maxResults?: number): string;
+    fetchAccountBrainContext(force?: boolean): Promise<string>;
+    private syncIndexToHub;
+}

package/dist/utils/workspace-brain-service.js

@@ -0,0 +1,121 @@
+/**
+ * Workspace Brain — local codebase index + Brain Hub sync for CLI.
+ */
+import * as path from 'path';
+import { BrainHubClient } from './brain-hub-client.js';
+import { CodebaseIndexer } from './codebase-indexer.js';
+export class WorkspaceBrainService {
+    workspacePath;
+    indexer;
+    brainClient;
+    autoIndex;
+    brainSyncEnabled;
+    accountContextCache = null;
+    constructor(options) {
+        this.workspacePath = path.resolve(options.workspacePath);
+        this.indexer = new CodebaseIndexer(this.workspacePath);
+        this.brainClient = new BrainHubClient({
+            apiBase: options.apiBase,
+            getAuthToken: options.getAuthToken,
+        });
+        this.autoIndex = options.autoIndex ?? !/^(1|true|yes)$/i.test(String(process.env.VIGTHORIA_NO_AUTO_INDEX || ''));
+        this.brainSyncEnabled = options.brainSyncEnabled ?? !/^(1|true|yes)$/i.test(String(process.env.VIGTHORIA_NO_BRAIN_SYNC || ''));
+    }
+    getIndexer() {
+        return this.indexer;
+    }
+    getStatus() {
+        const status = this.indexer.getStatus();
+        return {
+            workspacePath: this.workspacePath,
+            indexedFileCount: status.indexedFileCount,
+            totalChunks: status.totalChunks,
+            isIndexing: status.isIndexing,
+            meta: CodebaseIndexer.loadMeta(this.workspacePath),
+        };
+    }
+    async ensureIndexed(options = {}) {
+        if (this.indexer.hasLocalIndex() && this.indexer.getStatus().totalChunks === 0) {
+            const meta = await this.indexer.indexWorkspace();
+            await this.syncIndexToHub(meta);
+            return { indexed: true, fileCount: meta.indexedFileCount, chunkCount: meta.totalChunks };
+        }
+        if (this.indexer.hasLocalIndex()) {
+            const meta = CodebaseIndexer.loadMeta(this.workspacePath);
+            return {
+                indexed: true,
+                fileCount: meta?.indexedFileCount || this.indexer.getStatus().indexedFileCount,
+                chunkCount: meta?.totalChunks || this.indexer.getStatus().totalChunks,
+            };
+        }
+        if (!this.autoIndex && !options.promptIfMissing) {
+            return { indexed: false, fileCount: 0, chunkCount: 0, prompted: 'skipped' };
+        }
+        if (options.promptIfMissing && options.askToIndex) {
+            const wsName = path.basename(this.workspacePath);
+            const fileCount = this.indexer.countIndexableFiles();
+            if (fileCount === 0) {
+                return { indexed: false, fileCount: 0, chunkCount: 0, prompted: 'skipped' };
+            }
+            const choice = await options.askToIndex(fileCount, wsName);
+            if (choice === 'later') {
+                return { indexed: false, fileCount: 0, chunkCount: 0, prompted: 'later' };
+            }
+        }
+        const meta = await this.indexer.indexWorkspace();
+        await this.syncIndexToHub(meta);
+        return {
+            indexed: true,
+            fileCount: meta.indexedFileCount,
+            chunkCount: meta.totalChunks,
+            prompted: options.promptIfMissing ? 'index_now' : undefined,
+        };
+    }
+    async reindexWorkspace() {
+        const meta = await this.indexer.indexWorkspace();
+        await this.syncIndexToHub(meta);
+        return meta;
+    }
+    buildCodebaseContext(prompt) {
+        if (!prompt.trim() || !this.indexer.hasLocalIndex()) {
+            return '';
+        }
+        const context = this.indexer.getContextForQuery(prompt, 3500);
+        if (!context) {
+            return '';
+        }
+        return `Vigthoria codebase index context.\n${context}`;
+    }
+    searchCodebase(query, maxResults = 30) {
+        return this.indexer.formatSearchResults(query, maxResults);
+    }
+    async fetchAccountBrainContext(force = false) {
+        if (!this.brainSyncEnabled) {
+            return '';
+        }
+        const cacheTtlMs = 5 * 60 * 1000;
+        if (!force && this.accountContextCache && Date.now() - this.accountContextCache.fetchedAt < cacheTtlMs) {
+            return this.accountContextCache.text;
+        }
+        const response = await this.brainClient.fetchAccountContext(25);
+        const text = String(response.formattedText || '').trim();
+        this.accountContextCache = { text, fetchedAt: Date.now() };
+        return text;
+    }
+    async syncIndexToHub(meta) {
+        if (!this.brainSyncEnabled) {
+            return;
+        }
+        const wsName = path.basename(this.workspacePath);
+        const summary = `Workspace "${wsName}" indexed in Vigthoria CLI: ${meta.indexedFileCount} files, ${meta.totalChunks} chunks. Key paths: ${meta.topFiles.slice(0, 6).join(', ')}`;
+        await this.brainClient.syncWorkspaceIndex({
+            workspaceName: wsName,
+            workspacePath: this.workspacePath,
+            fileCount: meta.indexedFileCount,
+            chunkCount: meta.totalChunks,
+            topFiles: meta.topFiles,
+            summary,
+            indexHash: meta.indexHash,
+        }).catch(() => undefined);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.10.36",
+  "version": "1.10.37",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "type": "module",
   "main": "dist/index.js",

package/scripts/release/validate-no-go-gates.sh

@@ -46,7 +46,7 @@ import('./dist/utils/context-ranker.js').then((m)=>{
 EOF2
 
 echo "[2.1/2.4] tsc validator emits passing result"
-node - << 'EOF2'
+node --input-type=module - << 'EOF2'
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';