vigthoria-cli 1.10.1 → 1.10.37

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/config.d.ts

@@ -10,6 +10,7 @@ export interface VigthoriaCLIConfig {
     refreshToken: string | null;
     userId: string | null;
     email: string | null;
+    v3ServiceKey: string | null;
     subscription: {
         plan: string | null;
         status: string | null;
@@ -27,6 +28,14 @@ export interface VigthoriaCLIConfig {
         rootPath: string | null;
         ignorePatterns: string[];
     };
+    persona: 'default' | 'wiener_grant';
+    hubModelPrefs?: {
+        enabledCloudModels: string[];
+        defaultCloudModel?: string;
+        defaultLocalModel?: string;
+        balance?: number;
+        fetchedAt?: string;
+    };
 }
 export interface AvailableModelDescriptor {
     id: string;
@@ -68,7 +77,9 @@ export declare class Config {
         expiresAt?: string;
     }): void;
     getAvailableModels(): AvailableModelDescriptor[];
+    refreshHubModelPreferences(): Promise<void>;
     isCloudModel(modelId: string): boolean;
+    filterModelsByHubPreferences(models: AvailableModelDescriptor[], enabledCloudModels?: string[]): AvailableModelDescriptor[];
     isComplexTask(prompt: string): boolean;
     shouldUseCloudForHeavyTask(prompt: string): boolean;
 }

package/dist/utils/config.js

@@ -12,19 +12,21 @@ const defaultConfig = {
     refreshToken: null,
     userId: null,
     email: null,
+    v3ServiceKey: null,
     subscription: {
         plan: null,
         status: null,
         expiresAt: null,
     },
     preferences: {
-        defaultModel: 'agent',
+        defaultModel: 'code',
         theme: 'dark',
         autoApplyFixes: false,
         showDiffs: true,
         contextLines: 3,
         maxTokens: 4096,
     },
+    persona: 'default',
     project: {
         rootPath: null,
         ignorePatterns: [
@@ -63,6 +65,7 @@ export class Config {
                 refreshToken: { type: ['string', 'null'] },
                 userId: { type: ['string', 'null'] },
                 email: { type: ['string', 'null'] },
+                v3ServiceKey: { type: ['string', 'null'] },
                 subscription: {
                     type: 'object',
                     properties: {
@@ -82,6 +85,7 @@ export class Config {
                         maxTokens: { type: 'number' },
                     },
                 },
+                persona: { type: 'string', enum: ['default', 'wiener_grant'] },
                 project: {
                     type: 'object',
                     properties: {
@@ -182,30 +186,64 @@ export class Config {
         const sub = this.store.get('subscription');
         const plan = (sub.plan || '').toLowerCase();
         // ═══════════════════════════════════════════════════════════════
-        // VIGTHORIA LOCAL - Self-hosted operational models
+        // Vigthoria server infrastructure operational models
         // ═══════════════════════════════════════════════════════════════
         const models = [
-            { id: 'agent', name: 'Vigthoria V3 Code Agent', description: 'Blackwell autonomous agent workflow', tier: 'local', backendModel: 'vigthoria-v3-code-35b' },
-            { id: 'code', name: 'Vigthoria v3 Code 35B', description: 'Native 35B coding model on Blackwell', tier: 'local', backendModel: 'vigthoria-v3-code-35b' },
+            { id: 'code', name: 'Vigthoria v3 Code 35B', description: 'Native 35B coding model on Blackwell (V3 pipeline)', tier: 'local', backendModel: 'vigthoria-v3-code-35b' },
             { id: 'code-35b', name: 'Vigthoria v3 Code 35B', description: 'Same flagship model as code', tier: 'local', backendModel: 'vigthoria-v3-code-35b' },
             { id: 'code-9b', name: 'Vigthoria v3 Code 9B', description: 'Efficient coding specialist for quick tasks', tier: 'local', backendModel: 'vigthoria-v3-code-9b' },
             { id: 'balanced', name: 'Vigthoria Balanced 4B', description: 'Balanced general-purpose local model', tier: 'local', backendModel: 'vigthoria-v3-balanced-4b' },
             { id: 'balanced-4b', name: 'Vigthoria Balanced 4B', description: 'Efficient 4B general-purpose model (Qwen3.5-4B based)', tier: 'local', backendModel: 'vigthoria-v3-balanced-4b' },
         ];
-        // ═══════════════════════════════════════════════════════════════
-        // VIGTHORIA CLOUD - Premium cloud models (Pro subscription)
-        // For complex multi-file tasks, large refactoring, architecture
-        // ═══════════════════════════════════════════════════════════════
         if (this.hasCloudAccess()) {
-            models.push({ id: 'cloud', name: 'Vigthoria Cloud Pro', description: 'High-capability cloud model for complex tasks', tier: 'cloud', backendModel: 'vigthoria-cloud-pro' }, { id: 'cloud-reason', name: 'Vigthoria Cloud K2', description: 'Reasoning-focused cloud model', tier: 'cloud', backendModel: 'vigthoria-cloud-k2' }, { id: 'ultra', name: 'Vigthoria Cloud Ultra', description: 'Maximum capability cloud routing', tier: 'cloud', backendModel: 'vigthoria-cloud-ultra' });
+            models.push({ id: 'cloud-fast', name: 'Vigthoria Cloud Fast', description: 'Fast cloud responses for lighter work', tier: 'cloud', backendModel: 'vigthoria-cloud-fast' }, { id: 'cloud-balanced', name: 'Vigthoria Cloud Balanced', description: 'Default quality/cost balance for chat and coding', tier: 'cloud', backendModel: 'vigthoria-cloud-balanced' }, { id: 'cloud-code', name: 'Vigthoria Cloud Code', description: 'Economical cloud coding and completion', tier: 'cloud', backendModel: 'vigthoria-cloud-code' }, { id: 'cloud-power', name: 'Vigthoria Cloud Power', description: 'Premium general intelligence for demanding work', tier: 'cloud', backendModel: 'vigthoria-cloud-power' }, { id: 'cloud-maximum', name: 'Vigthoria Cloud Maximum', description: 'Maximum power for complex architecture and reviews', tier: 'cloud', backendModel: 'vigthoria-cloud-maximum' }, 
+            // Legacy aliases
+            { id: 'cloud', name: 'Vigthoria Cloud Balanced', description: 'Legacy alias for cloud-balanced', tier: 'cloud', backendModel: 'vigthoria-cloud-balanced' }, { id: 'cloud-reason', name: 'Vigthoria Cloud Balanced', description: 'Legacy alias for cloud-balanced', tier: 'cloud', backendModel: 'vigthoria-cloud-balanced' }, { id: 'ultra', name: 'Vigthoria Cloud Maximum', description: 'Legacy alias for cloud-maximum', tier: 'cloud', backendModel: 'vigthoria-cloud-maximum' });
+        }
+        const hubPrefs = this.store.get('hubModelPrefs');
+        if (hubPrefs?.enabledCloudModels?.length) {
+            return this.filterModelsByHubPreferences(models, hubPrefs.enabledCloudModels);
         }
         return models;
     }
+    async refreshHubModelPreferences() {
+        const token = this.store.get('authToken');
+        const apiUrl = String(this.store.get('apiUrl') || '').replace(/\/$/, '');
+        if (!token || !apiUrl)
+            return;
+        try {
+            const response = await fetch(`${apiUrl}/api/user/credits/model-preferences`, {
+                headers: { Authorization: `Bearer ${token}` },
+                signal: AbortSignal.timeout(8000),
+            });
+            if (!response.ok)
+                return;
+            const prefs = await response.json();
+            if (prefs?.success === false)
+                return;
+            this.store.set('hubModelPrefs', {
+                enabledCloudModels: Array.isArray(prefs.enabledCloudModels) ? prefs.enabledCloudModels : [],
+                defaultCloudModel: typeof prefs.defaultCloudModel === 'string' ? prefs.defaultCloudModel : undefined,
+                defaultLocalModel: typeof prefs.defaultLocalModel === 'string' ? prefs.defaultLocalModel : undefined,
+                balance: typeof prefs.balance === 'number' ? prefs.balance : undefined,
+                fetchedAt: new Date().toISOString(),
+            });
+        }
+        catch {
+            // Non-fatal: CLI can still run with default model catalog.
+        }
+    }
     // Check if a model is a "Cloud" tier model
     isCloudModel(modelId) {
-        const cloudModels = ['cloud', 'cloud-reason', 'ultra'];
+        const cloudModels = ['cloud-fast', 'cloud-balanced', 'cloud-code', 'cloud-power', 'cloud-maximum', 'cloud', 'cloud-reason', 'ultra'];
         return cloudModels.includes(modelId) || modelId.includes('cloud');
     }
+    filterModelsByHubPreferences(models, enabledCloudModels) {
+        if (!enabledCloudModels || !enabledCloudModels.length)
+            return models;
+        const enabled = new Set(enabledCloudModels);
+        return models.filter((model) => model.tier !== 'cloud' || enabled.has(model.backendModel));
+    }
     // Check if task is complex enough to suggest Cloud upgrade
     isComplexTask(prompt) {
         const complexIndicators = [
@@ -221,6 +259,9 @@ export class Config {
         return complexIndicators.some(pattern => pattern.test(prompt));
     }
     shouldUseCloudForHeavyTask(prompt) {
-        return this.hasOperatorAccess() && this.hasCloudAccess() && this.isComplexTask(prompt);
+        // DISABLED: Cloud routing is now EXPLICIT ONLY (--model cloud or /cloud command)
+        // Do NOT auto-route based on keywords. User must opt-in.
+        // If user wants cloud: they'll use --model cloud or request it explicitly.
+        return false;
     }
 }

package/dist/utils/persona.d.ts

@@ -0,0 +1,4 @@
+export type PersonaMode = 'default' | 'wiener_grant';
+export declare function normalizePersonaMode(value: unknown): PersonaMode | null;
+export declare function isToneDownPrompt(prompt: string): boolean;
+export declare function buildPersonaOverlay(mode: PersonaMode, prompt?: string): string;

package/dist/utils/persona.js

@@ -0,0 +1,34 @@
+const WIENER_GRANT_PROMPT = [
+    'Optional persona overlay: Wiener Grantler mode.',
+    'You remain Vigthoria: technically precise, helpful, safe, and comprehensive.',
+    'Persona: theatrical Viennese grumpiness with dry humor, mild sarcasm, impatient charm, and light Austrian dialect flavor.',
+    'Rules:',
+    '- Never reduce technical quality, completeness, or safety.',
+    '- Never use slurs, hate, racist or sexist stereotypes, protected-class insults, or demeaning nationality/ethnicity jokes.',
+    '- Do not seriously demean the user. Keep the bite playful and aimed at messy code, vague prompts, broken configs, or tooling chaos.',
+    '- Use dialect flavor sparingly enough that instructions, commands, and code remain fully readable.',
+    '- Always provide the actual fix, commands, code, or next steps.',
+].join('\n');
+const TONE_DOWN_PROMPT = [
+    'Tone-down rule active: this request appears safety-sensitive, destructive, auth/billing-related, security-related, legal/medical/financial, or production-critical.',
+    'Use only a very light flavor line if appropriate, then prioritize plain clarity, caution, and exact steps.',
+].join('\n');
+export function normalizePersonaMode(value) {
+    const normalized = String(value || '').trim().toLowerCase().replace(/_/g, '-');
+    if (!normalized || normalized === 'default' || normalized === 'off' || normalized === 'none')
+        return 'default';
+    if (normalized === 'wiener-grant' || normalized === 'wiener-grantler' || normalized === 'grant' || normalized === 'grantler')
+        return 'wiener_grant';
+    return null;
+}
+export function isToneDownPrompt(prompt) {
+    return /\b(delete|drop|destroy|wipe|rm\s+-rf|format|credential|secret|token|auth|login|billing|payment|wallet|security|vulnerability|exploit|incident|production|prod|deploy|legal|medical|financial|bank|tax)\b/i.test(prompt);
+}
+export function buildPersonaOverlay(mode, prompt = '') {
+    if (mode !== 'wiener_grant')
+        return '';
+    const parts = [WIENER_GRANT_PROMPT];
+    if (isToneDownPrompt(prompt))
+        parts.push(TONE_DOWN_PROMPT);
+    return parts.join('\n\n');
+}