@bonginkan/maria 4.1.15 → 4.2.1

package/dist/bin/maria.cjs

@@ -454,8 +454,8 @@ var init_startup_display = __esm({
 var DEFAULT_PROVIDER2, DEFAULT_MODEL2;
 var init_config = __esm({
   "src/providers/config.ts"() {
-    DEFAULT_PROVIDER2 = "openai";
-    DEFAULT_MODEL2 = process.env.MARIA_DEFAULT_MODEL || "gpt-5-mini-2025-08-07";
+    DEFAULT_PROVIDER2 = process.env.DEFAULT_PROVIDER || "openai";
+    DEFAULT_MODEL2 = process.env.MARIA_DEFAULT_MODEL || process.env.LMSTUDIO_MODEL || "gpt-5-mini-2025-08-07";
   }
 });
 
@@ -7099,8 +7099,404 @@ var init_base_provider = __esm({
   }
 });
 
+// src/services/intelligent-model-selector/SecretManagerIntegration.ts
+var SecretManagerIntegration_exports = {};
+__export(SecretManagerIntegration_exports, {
+  SecretManagerIntegration: () => SecretManagerIntegration
+});
+var import_secret_manager, SecretManagerIntegration;
+var init_SecretManagerIntegration = __esm({
+  "src/services/intelligent-model-selector/SecretManagerIntegration.ts"() {
+    import_secret_manager = require("@google-cloud/secret-manager");
+    SecretManagerIntegration = class {
+      // 1 hour
+      constructor(config2) {
+        this.config = config2;
+        this.client = new import_secret_manager.SecretManagerServiceClient();
+      }
+      client;
+      cache = /* @__PURE__ */ new Map();
+      cacheExpiry = /* @__PURE__ */ new Map();
+      CACHE_TTL = 36e5;
+      /**
+       * Get API key from Secret Manager with caching
+       */
+      async getApiKey(provider) {
+        const secretName = this.getSecretName(provider);
+        if (!secretName) {
+          return void 0;
+        }
+        const cached = this.getCachedSecret(secretName);
+        if (cached) {
+          return cached;
+        }
+        try {
+          const name2 = `projects/${this.config.projectId}/secrets/${secretName}/versions/latest`;
+          const [version] = await this.client.accessSecretVersion({ name: name2 });
+          const payload = version.payload?.data;
+          if (!payload) {
+            console.error(`Secret ${secretName} has no payload`);
+            return void 0;
+          }
+          const secret = payload.toString();
+          this.cacheSecret(secretName, secret);
+          return secret;
+        } catch (error2) {
+          if (error2.code !== 5) {
+            console.error(`Failed to access secret ${secretName}:`, error2);
+          }
+          return this.getFallbackFromEnv(provider);
+        }
+      }
+      /**
+       * Get all API keys
+       */
+      async getAllApiKeys() {
+        const [googleApiKey, openaiApiKey, anthropicApiKey, groqApiKey] = await Promise.all([
+          this.getApiKey("google"),
+          this.getApiKey("openai"),
+          this.getApiKey("anthropic"),
+          this.getApiKey("groq")
+        ]);
+        return {
+          googleApiKey,
+          openaiApiKey,
+          anthropicApiKey,
+          groqApiKey
+        };
+      }
+      /**
+       * Verify that required secrets exist
+       */
+      async verifySecrets() {
+        const available = [];
+        const missing = [];
+        const providers = ["google", "openai", "anthropic", "groq"];
+        for (const provider of providers) {
+          const secretName = this.getSecretName(provider);
+          if (!secretName) continue;
+          try {
+            const name2 = `projects/${this.config.projectId}/secrets/${secretName}`;
+            await this.client.getSecret({ name: name2 });
+            available.push(provider);
+          } catch (error2) {
+            missing.push(provider);
+          }
+        }
+        return { available, missing };
+      }
+      /**
+       * Create or update a secret
+       */
+      async createOrUpdateSecret(provider, apiKey) {
+        const secretName = this.getSecretName(provider);
+        if (!secretName) {
+          return false;
+        }
+        const secretId = `projects/${this.config.projectId}/secrets/${secretName}`;
+        try {
+          let secretExists = false;
+          try {
+            await this.client.getSecret({ name: secretId });
+            secretExists = true;
+          } catch {
+            secretExists = false;
+          }
+          if (!secretExists) {
+            await this.client.createSecret({
+              parent: `projects/${this.config.projectId}`,
+              secretId: secretName,
+              secret: {
+                replication: {
+                  automatic: {}
+                },
+                labels: {
+                  service: "ims",
+                  provider
+                }
+              }
+            });
+          }
+          await this.client.addSecretVersion({
+            parent: secretId,
+            payload: {
+              data: Buffer.from(apiKey, "utf8")
+            }
+          });
+          this.cache.delete(secretName);
+          this.cacheExpiry.delete(secretName);
+          return true;
+        } catch (error2) {
+          console.error(`Failed to create/update secret ${secretName}:`, error2);
+          return false;
+        }
+      }
+      /**
+       * Get secret name for provider
+       */
+      getSecretName(provider) {
+        switch (provider) {
+          case "google":
+            return this.config.secrets.googleAI || "google-ai-api-key";
+          case "openai":
+            return this.config.secrets.openAI || "openai-api-key";
+          case "anthropic":
+            return this.config.secrets.anthropic || "anthropic-api-key";
+          case "groq":
+            return this.config.secrets.groq || "groq-api-key";
+          default:
+            return void 0;
+        }
+      }
+      /**
+       * Get cached secret if valid
+       */
+      getCachedSecret(secretName) {
+        const expiry = this.cacheExpiry.get(secretName);
+        if (!expiry || Date.now() > expiry) {
+          this.cache.delete(secretName);
+          this.cacheExpiry.delete(secretName);
+          return void 0;
+        }
+        return this.cache.get(secretName);
+      }
+      /**
+       * Cache a secret
+       */
+      cacheSecret(secretName, value) {
+        this.cache.set(secretName, value);
+        this.cacheExpiry.set(secretName, Date.now() + this.CACHE_TTL);
+      }
+      /**
+       * Get fallback from environment variable
+       */
+      getFallbackFromEnv(provider) {
+        switch (provider) {
+          case "google":
+            return process.env.GOOGLE_AI_API_KEY;
+          case "openai":
+            return process.env.OPENAI_API_KEY;
+          case "anthropic":
+            return process.env.ANTHROPIC_API_KEY;
+          case "groq":
+            return process.env.GROQ_API_KEY;
+          default:
+            return void 0;
+        }
+      }
+      /**
+       * Clear cache
+       */
+      clearCache() {
+        this.cache.clear();
+        this.cacheExpiry.clear();
+      }
+    };
+  }
+});
+
+// src/providers/groq-provider.ts
+var groq_provider_exports = {};
+__export(groq_provider_exports, {
+  GroqProvider: () => GroqProvider
+});
+var GroqProvider;
+var init_groq_provider = __esm({
+  "src/providers/groq-provider.ts"() {
+    init_base_provider();
+    GroqProvider = class extends UnifiedBaseProvider {
+      name = "groq";
+      modelsCache;
+      constructor(apiKey) {
+        super({
+          apiKey,
+          apiBase: "https://api.groq.com/openai/v1"
+        });
+      }
+      async isAvailable() {
+        if (!this.apiKey || this.apiKey.startsWith("gsk_your-groq-")) {
+          return false;
+        }
+        try {
+          await this.makeRequest(`${this.apiBase}/models`, {
+            method: "GET",
+            headers: {
+              Authorization: `Bearer ${this.apiKey}`
+            }
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async getModels() {
+        if (this.modelsCache) {
+          return this.modelsCache;
+        }
+        const models = [
+          {
+            id: "llama-3.3-70b-versatile",
+            name: "Llama 3.3 70B",
+            provider: this.name,
+            description: "Most capable Llama _model with versatile performance",
+            contextLength: 32768,
+            capabilities: ["text", "reasoning", "code"],
+            _pricing: { input: 59e-5, output: 79e-5 },
+            available: await this.isAvailable(),
+            recommendedFor: ["complex_reasoning", "coding", "analysis"]
+          },
+          {
+            id: "llama-3.2-90b-vision-preview",
+            name: "Llama 3.2 90B Vision",
+            provider: this.name,
+            description: "Vision-capable Llama _model for multimodal tasks",
+            contextLength: 128e3,
+            capabilities: ["text", "vision", "reasoning"],
+            _pricing: { input: 9e-4, output: 9e-4 },
+            available: await this.isAvailable(),
+            recommendedFor: ["vision_tasks", "multimodal", "analysis"]
+          },
+          {
+            id: "mixtral-8x7b-32768",
+            name: "Mixtral 8x7B",
+            provider: this.name,
+            description: "Mixture of experts _model for balanced performance",
+            contextLength: 32768,
+            capabilities: ["text", "reasoning", "code"],
+            _pricing: { input: 24e-5, output: 24e-5 },
+            available: await this.isAvailable(),
+            recommendedFor: ["balanced_performance", "multilingual"]
+          },
+          {
+            id: "gemma2-9b-it",
+            name: "Gemma 2 9B",
+            provider: this.name,
+            description: "Google's efficient open _model",
+            contextLength: 8192,
+            capabilities: ["text", "reasoning"],
+            _pricing: { input: 2e-4, output: 2e-4 },
+            available: await this.isAvailable(),
+            recommendedFor: ["quick_tasks", "cost_effective"]
+          }
+        ];
+        this.modelsCache = models;
+        return models;
+      }
+      async chat(request) {
+        if (!await this.isAvailable()) {
+          throw new Error("Groq API not available");
+        }
+        const _model = request._model || "mixtral-8x7b-32768";
+        const _startTime = Date.now();
+        const _payload = {
+          _model,
+          messages: request.messages,
+          temperature: request.temperature || 0.7,
+          maxtokens: request.maxTokens || 4e3,
+          _stream: request._stream || false
+        };
+        if (request._stream) {
+          const _stream = await this.makeStreamRequest(
+            `${this.apiBase}/chat/completions`,
+            {
+              method: "POST",
+              headers: {
+                Authorization: `Bearer ${this.apiKey}`
+              },
+              body: JSON.stringify(_payload)
+            }
+          );
+          return {
+            _stream,
+            _model,
+            provider: this.name,
+            responseTime: Date.now() - _startTime
+          };
+        }
+        const _response = await this.makeRequest(
+          `${this.apiBase}/chat/completions`,
+          {
+            method: "POST",
+            headers: {
+              Authorization: `Bearer ${this.apiKey}`
+            },
+            body: JSON.stringify(_payload)
+          }
+        );
+        return {
+          content: _response.choices[0]?.message?.content || "",
+          _model,
+          provider: this.name,
+          usage: {
+            promptTokens: _response.usage?.prompt_tokens || 0,
+            completionTokens: _response.usage?.completion_tokens || 0,
+            totalTokens: _response.usage?.total_tokens || 0
+          },
+          responseTime: Date.now() - _startTime
+        };
+      }
+      async vision(_image, prompt) {
+        if (!await this.isAvailable()) {
+          throw new Error("Groq API not available");
+        }
+        const _base64Image = _image.toString("base64");
+        const _startTime = Date.now();
+        const _payload = {
+          _model: "llama-3.2-90b-vision-preview",
+          messages: [
+            {
+              role: "user",
+              content: [
+                { type: "text", text: prompt },
+                {
+                  type: "image_url",
+                  imageurl: {
+                    url: `data:image/jpeg;base64,${_base64Image}`
+                  }
+                }
+              ]
+            }
+          ],
+          maxtokens: 4e3
+        };
+        const _response = await this.makeRequest(
+          `${this.apiBase}/chat/completions`,
+          {
+            method: "POST",
+            headers: {
+              Authorization: `Bearer ${this.apiKey}`
+            },
+            body: JSON.stringify(_payload)
+          }
+        );
+        return {
+          content: _response.choices[0]?.message?.content || "",
+          _model: "llama-3.2-90b-vision-preview",
+          provider: this.name,
+          usage: {
+            promptTokens: _response.usage?.prompt_tokens || 0,
+            completionTokens: _response.usage?.completion_tokens || 0,
+            totalTokens: _response.usage?.total_tokens || 0
+          },
+          responseTime: Date.now() - _startTime
+        };
+      }
+      estimateCost(_tokens, _model = "mixtral-8x7b-32768") {
+        const _pricing = {
+          "llama-3.3-70b-versatile": { input: 59e-5, output: 79e-5 },
+          "llama-3.2-90b-vision-preview": { input: 9e-4, output: 9e-4 },
+          "mixtral-8x7b-32768": { input: 24e-5, output: 24e-5 },
+          "gemma2-9b-it": { input: 2e-4, output: 2e-4 }
+        };
+        const _modelPricing = _pricing[_model] || _pricing["mixtral-8x7b-32768"];
+        return _tokens * 0.75 * _modelPricing.input + _tokens * 0.25 * _modelPricing.output;
+      }
+    };
+  }
+});
+
 // src/providers/manager.ts
-var UnifiedAIProviderManager, UnifiedOpenAIProvider, UnifiedAnthropicProvider, UnifiedGoogleProvider, UnifiedGrokProvider, UnifiedOllamaProvider, UnifiedLMStudioProvider, UnifiedVLLMProvider;
+var UnifiedAIProviderManager, UnifiedOpenAIProvider, UnifiedAnthropicProvider, UnifiedGoogleProvider, UnifiedGroqProvider, UnifiedGrokProvider, UnifiedOllamaProvider, UnifiedLMStudioProvider, UnifiedVLLMProvider;
 var init_manager = __esm({
   "src/providers/manager.ts"() {
     init_config();
@@ -7285,15 +7681,36 @@ var init_manager = __esm({
           })
         );
       }
-      /** Register adapters based on env keys (OpenAI is real, others placeholder but safe) */
+      /** Register adapters based on Secret Manager or env keys */
       async initializeProviders() {
-        const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
-        const ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;
-        const GOOGLE_API_KEY = process.env.GOOGLE_API_KEY || process.env.GOOGLE_AI_API_KEY;
+        let OPENAI_API_KEY = process.env.OPENAI_API_KEY;
+        let ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;
+        let GOOGLE_API_KEY = process.env.GOOGLE_API_KEY || process.env.GOOGLE_AI_API_KEY;
+        let GROQ_API_KEY = process.env.GROQ_API_KEY;
         const GROK_API_KEY = process.env.GROK_API_KEY || process.env.XAI_API_KEY;
+        try {
+          const { SecretManagerIntegration: SecretManagerIntegration2 } = await Promise.resolve().then(() => (init_SecretManagerIntegration(), SecretManagerIntegration_exports));
+          const secretManager = new SecretManagerIntegration2({
+            projectId: process.env.GOOGLE_CLOUD_PROJECT || "maria-code-470602",
+            secrets: {
+              openAI: "openai-api-key",
+              anthropic: "anthropic-api-key",
+              googleAI: "google-ai-api-key",
+              groq: "groq-api-key"
+            }
+          });
+          const keys = await secretManager.getAllApiKeys();
+          OPENAI_API_KEY = keys.openaiApiKey || OPENAI_API_KEY;
+          ANTHROPIC_API_KEY = keys.anthropicApiKey || ANTHROPIC_API_KEY;
+          GOOGLE_API_KEY = keys.googleApiKey || GOOGLE_API_KEY;
+          GROQ_API_KEY = keys.groqApiKey || GROQ_API_KEY;
+        } catch (error2) {
+          console.debug("Secret Manager not available, using environment variables");
+        }
         if (OPENAI_API_KEY) this.register(new UnifiedOpenAIProvider(OPENAI_API_KEY));
         if (ANTHROPIC_API_KEY) this.register(new UnifiedAnthropicProvider(ANTHROPIC_API_KEY));
         if (GOOGLE_API_KEY) this.register(new UnifiedGoogleProvider(GOOGLE_API_KEY));
+        if (GROQ_API_KEY) this.register(new UnifiedGroqProvider(GROQ_API_KEY));
         if (GROK_API_KEY) this.register(new UnifiedGrokProvider(GROK_API_KEY));
         this.register(new UnifiedOllamaProvider());
         this.register(new UnifiedLMStudioProvider());
@@ -7454,6 +7871,75 @@ var init_manager = __esm({
         ];
       }
     };
+    UnifiedGroqProvider = class extends UnifiedBaseProvider {
+      id = "groq";
+      name = "Groq";
+      groqProvider;
+      constructor(apiKey) {
+        super({ apiKey });
+      }
+      async getProvider() {
+        if (!this.groqProvider) {
+          const { GroqProvider: GroqProvider2 } = await Promise.resolve().then(() => (init_groq_provider(), groq_provider_exports));
+          this.groqProvider = new GroqProvider2(this.apiKey);
+        }
+        return this.groqProvider;
+      }
+      async isAvailable() {
+        try {
+          const provider = await this.getProvider();
+          return await provider.isAvailable();
+        } catch {
+          return false;
+        }
+      }
+      async health() {
+        const startTime = Date.now();
+        const isHealthy = await this.isAvailable();
+        return {
+          ok: isHealthy,
+          latencyMs: Date.now() - startTime,
+          timestamp: Date.now()
+        };
+      }
+      async complete(prompt, req) {
+        const provider = await this.getProvider();
+        const response2 = await provider.chat({
+          messages: [{ role: "user", content: prompt }],
+          model: req.model || "mixtral-8x7b-32768",
+          temperature: req.temperature,
+          maxTokens: req.maxTokens,
+          stream: false
+        });
+        return {
+          content: response2.content || "",
+          model: response2.model,
+          usage: response2.usage
+        };
+      }
+      async stream(prompt, req) {
+        const provider = await this.getProvider();
+        const response2 = await provider.chat({
+          messages: [{ role: "user", content: prompt }],
+          model: req.model || "mixtral-8x7b-32768",
+          temperature: req.temperature,
+          maxTokens: req.maxTokens,
+          stream: true
+        });
+        if (response2.stream) {
+          return response2.stream;
+        }
+        async function* fallback() {
+          yield { content: response2.content || "" };
+        }
+        return fallback();
+      }
+      async getModels() {
+        const provider = await this.getProvider();
+        const models = await provider.getModels();
+        return models.map((m2) => m2.id);
+      }
+    };
     UnifiedGrokProvider = class extends UnifiedBaseProvider {
       id = "grok";
       name = "xAI Grok";
@@ -7537,7 +8023,43 @@ var init_manager = __esm({
         return { ok: available, timestamp: Date.now(), reason: available ? void 0 : "LM Studio not running" };
       }
       async complete(prompt, req) {
-        return { content: `LM Studio (local) \u2192 ${prompt.slice(0, 60)}` };
+        try {
+          const apiBase = process.env.LMSTUDIO_API_BASE || "http://localhost:1234/v1";
+          const model = req.model || process.env.LMSTUDIO_MODEL || "local-model";
+          const response2 = await fetch(`${apiBase}/chat/completions`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": "Bearer lm-studio"
+            },
+            body: JSON.stringify({
+              model,
+              messages: [
+                { role: "user", content: prompt }
+              ],
+              temperature: req.temperature || 0.7,
+              max_tokens: req.maxTokens || 2e3,
+              stream: false
+            })
+          });
+          if (!response2.ok) {
+            throw new Error(`LM Studio API error: ${response2.statusText}`);
+          }
+          const data2 = await response2.json();
+          const content = data2.choices?.[0]?.message?.content || "";
+          return {
+            content,
+            model: data2.model,
+            usage: data2.usage ? {
+              promptTokens: data2.usage.prompt_tokens,
+              completionTokens: data2.usage.completion_tokens,
+              totalTokens: data2.usage.total_tokens
+            } : void 0
+          };
+        } catch (error2) {
+          console.error("LM Studio error:", error2);
+          return { content: `[LM Studio offline] Mock response for: ${prompt.slice(0, 60)}` };
+        }
       }
       async stream(prompt, req) {
         async function* g() {
@@ -21245,8 +21767,8 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@bonginkan/maria",
-      version: "4.1.15",
-      description: "\u{1F680} MARIA v4.1.4 - Complete Multimodal AI Integration & Enterprise Platform. Revolutionary voice-to-code, image-to-code, and 73 production-ready commands with advanced memory systems. World's first TypeScript AST-powered code generation with GraphRAG intelligence, multilingual support, and dual-architecture cognitive memory. Features zero-error development, OAuth2.0 + PKCE authentication, and military-grade security. Delivers next-generation multimodal development experience with enterprise-grade performance.",
+      version: "4.2.1",
+      description: "\u{1F680} MARIA v4.2.0 - Enterprise AI Development Platform with 100% Command Availability. Features 74 production-ready commands with comprehensive fallback implementation, local LLM support, and zero external dependencies. Includes natural language coding, AI safety evaluation, intelligent evolution system, episodic memory with PII masking, and real-time monitoring dashboard. Built with TypeScript AST-powered code generation, OAuth2.0 + PKCE authentication, quantum-resistant cryptography, and enterprise-grade performance.",
       keywords: [
         "ai",
         "cli",
@@ -21497,6 +22019,10 @@ var init_package = __esm({
         "test:deps": "cross-env MOCK_DEPS=true vitest run tests/contract/**/*.test.ts",
         "generate:manifest": "tsx scripts/generate-ready-manifest.ts",
         "health:report": "tsx scripts/command-health-report.ts",
+        "ims:deploy": "tsx scripts/deploy-ims-config.ts",
+        "ims:secrets": "tsx scripts/setup-ims-secrets.ts",
+        "ims:test": "tsx scripts/test-ims-integration.ts",
+        "ims:dashboard": "tsx scripts/ims-dashboard.ts",
         "ci:smoke": "pnpm -s build && pnpm -s test:smoke",
         "verify:build": "tsx scripts/verify-manifest-inclusion.ts",
         lint: "eslint --cache 'src/**/*.{ts,tsx}'",
@@ -21597,6 +22123,9 @@ var init_package = __esm({
       dependencies: {
         "@anthropic-ai/sdk": "^0.20.0",
         "@babel/traverse": "^7.28.3",
+        "@google-cloud/bigquery": "^8.1.1",
+        "@google-cloud/firestore": "^7.11.3",
+        "@google-cloud/secret-manager": "^6.1.0",
         "@google/genai": "^1.16.0",
         "@google/generative-ai": "^0.1.0",
         "@langchain/core": "^0.1.0",
@@ -24921,7 +25450,7 @@ var init_ai_response_service = __esm({
       _conversationPersistence;
       telemetry;
       initialized = false;
-      // V2 providers
+      // providers
       providerManager;
       constructor() {
         this.chatContext = ChatContextService.getInstance();
@@ -25335,10 +25864,15 @@ var init_command_groups = __esm({
       // Code Quality
       "/bug": {
         name: "/bug",
-        description: "Bug analysis and fix suggestions",
+        description: "AI-powered error analysis and solution recommendation system (Enhanced POC #4)",
         category: "quality",
-        usage: "/bug [description]",
-        examples: ["/bug Function returns undefined", "/bug Memory leak in component"]
+        usage: '/bug "<error message>" [--from-output] [--solution-id <id>] [--dry-run] [--verbose]',
+        examples: [
+          `/bug "Property 'name' does not exist on type 'User'"`,
+          `/bug "Cannot read property 'id' of undefined" --file src/user.ts`,
+          "/bug --from-output --verbose",
+          "/bug --solution-id typescript-fix-0 --dry-run"
+        ]
       },
       "/lint": {
         name: "/lint",
@@ -25468,6 +26002,17 @@ var init_command_groups = __esm({
         examples: ["/signout", "/signout github"]
       },
       // Workflow Automation
+      "/nl": {
+        name: "/nl",
+        description: "Natural language command translation - Convert plain English to executable commands (POC)",
+        category: "workflow",
+        usage: '/nl "<natural language description>" [options]',
+        examples: [
+          '/nl "commit my changes and run tests"',
+          '/nl "fix typescript errors" --dry-run',
+          '/nl "show system status" --explain'
+        ]
+      },
       "/chain": {
         name: "/chain",
         description: "Execute command chains",
@@ -26131,6 +26676,65 @@ var init_command_groups = __esm({
           "/design web --profile=landing --a11y --perf",
           "/design web --profile=site --out ./docs/web-sow.md"
         ]
+      },
+      // POC Commands (Production Ready)
+      "/nl-poc": {
+        name: "/nl-poc",
+        description: "Natural Language Command Translation (POC #1) - Production ready with 0.2ms response time",
+        category: "workflow",
+        usage: '/nl-poc "<natural language description>" [options]',
+        examples: [
+          '/nl-poc "commit my changes and run tests"',
+          '/nl-poc "fix typescript errors" --dry-run',
+          '/nl-poc "show system status" --explain --verbose'
+        ]
+      },
+      "/bug-poc": {
+        name: "/bug-poc",
+        description: "AI-powered error analysis and solution system (POC #4) - 80% accuracy, 0.2ms response time",
+        category: "quality",
+        usage: '/bug-poc "<error message>" [options]',
+        examples: [
+          `/bug-poc "Property 'name' does not exist on type 'User'"`,
+          `/bug-poc "Cannot read property 'id' of undefined" --file src/user.ts`,
+          "/bug-poc --from-output --verbose",
+          "/bug-poc --solution-id typescript-fix-0 --dry-run"
+        ]
+      },
+      // Intelligence System Commands
+      "/intelligence-dashboard": {
+        name: "/intelligence-dashboard",
+        description: "Start real-time MARIA Intelligence monitoring dashboard",
+        category: "intelligence",
+        usage: "/intelligence-dashboard [--format=ascii|html|json] [--duration=<minutes>] [--export=<file>]",
+        examples: [
+          "/intelligence-dashboard",
+          "/intelligence-dashboard --format html --export report.html",
+          "/intelligence-dashboard --duration 5 --format ascii"
+        ]
+      },
+      "/canary": {
+        name: "/canary",
+        description: "Manage MARIA Intelligence canary deployments for zero-downtime releases",
+        category: "intelligence",
+        usage: "/canary <action> [options]",
+        examples: [
+          "/canary deploy v4.2.0 --traffic 20 --duration 15",
+          "/canary status",
+          "/canary stop",
+          "/canary test"
+        ]
+      },
+      "/quality-gate": {
+        name: "/quality-gate",
+        description: "Run MARIA Intelligence quality gate validation with automated testing",
+        category: "intelligence",
+        usage: "/quality-gate [--threshold=<score>] [--verbose] [--report=<file>]",
+        examples: [
+          "/quality-gate",
+          "/quality-gate --threshold 85 --verbose",
+          "/quality-gate --report results.json"
+        ]
       }
     };
     _normToken = (s2) => s2.trim().toLowerCase();
@@ -26750,10 +27354,7 @@ var LEGACY_COMMANDS;
 var init_legacy_shield = __esm({
   "src/slash-commands/shared/legacy-shield.ts"() {
     LEGACY_COMMANDS = /* @__PURE__ */ new Set([
-      "/battlecard",
-      "/sales-dashboard",
-      "/status",
-      "/doctor"
+      // Currently no legacy commands - all have been migrated
     ]);
   }
 });
@@ -27329,9 +27930,334 @@ var init_quick_persistence = __esm({
   }
 });
 
+// src/services/telemetry/bigquery-telemetry.ts
+async function loadBigQuery() {
+  if (bigQueryLoadAttempted) return BigQuery;
+  bigQueryLoadAttempted = true;
+  try {
+    const bigqueryModule = await import("@google-cloud/bigquery");
+    BigQuery = bigqueryModule.BigQuery;
+  } catch {
+  }
+  return BigQuery;
+}
+var import_events, BigQuery, bigQueryLoadAttempted, BigQueryTelemetryService, bigQueryTelemetry;
+var init_bigquery_telemetry = __esm({
+  "src/services/telemetry/bigquery-telemetry.ts"() {
+    import_events = require("events");
+    BigQuery = null;
+    bigQueryLoadAttempted = false;
+    BigQueryTelemetryService = class _BigQueryTelemetryService extends import_events.EventEmitter {
+      static instance;
+      bigquery = null;
+      telemetryQueue = [];
+      flushTimer = null;
+      isEnabled;
+      httpEndpoint = null;
+      config = {
+        projectId: process.env.GOOGLE_CLOUD_PROJECT || "maria-code-470602",
+        datasetId: "cli",
+        tableName: "command_executions",
+        batchSize: 100,
+        flushIntervalMs: 3e4,
+        // 30 seconds
+        maxRetries: 3
+      };
+      constructor() {
+        super();
+        this.isEnabled = process.env.TELEMETRY_DISABLED !== "true";
+        this.httpEndpoint = process.env.TELEMETRY_ENDPOINT || null;
+        if (this.isEnabled) {
+          this.initialize().catch((error2) => {
+            console.error("[Telemetry] Initialization error:", error2);
+          });
+        }
+      }
+      /**
+       * Get singleton instance
+       */
+      static getInstance() {
+        if (!_BigQueryTelemetryService.instance) {
+          _BigQueryTelemetryService.instance = new _BigQueryTelemetryService();
+        }
+        return _BigQueryTelemetryService.instance;
+      }
+      /**
+       * Initialize BigQuery client or HTTP fallback
+       */
+      async initialize() {
+        const LoadedBigQuery = await loadBigQuery();
+        if (LoadedBigQuery && this.config.projectId) {
+          try {
+            this.bigquery = new LoadedBigQuery({
+              projectId: this.config.projectId,
+              keyFilename: process.env.GOOGLE_APPLICATION_CREDENTIALS
+            });
+            console.log("[Telemetry] BigQuery client initialized");
+          } catch (error2) {
+            console.error("[Telemetry] Failed to initialize BigQuery:", error2);
+          }
+        }
+        this.startFlushTimer();
+        this.setupGracefulShutdown();
+      }
+      /**
+       * Track command execution
+       */
+      async trackCommandExecution(data2) {
+        if (!this.isEnabled) return;
+        const telemetryData = {
+          ...data2,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          version: process.env.npm_package_version || process.env.CLI_VERSION,
+          environment: process.env.NODE_ENV || "production",
+          buildId: process.env.BUILD_ID,
+          region: process.env.REGION,
+          // Limit args to 3 for privacy
+          args: data2.args?.slice(0, 3)
+        };
+        this.telemetryQueue.push(telemetryData);
+        this.emit("command:tracked", telemetryData);
+        if (this.telemetryQueue.length >= this.config.batchSize) {
+          await this.flush();
+        }
+      }
+      /**
+       * Flush telemetry data to BigQuery or HTTP endpoint
+       */
+      async flush() {
+        if (this.telemetryQueue.length === 0) return;
+        const dataToFlush = [...this.telemetryQueue];
+        this.telemetryQueue = [];
+        try {
+          if (this.bigquery) {
+            await this.flushToBigQuery(dataToFlush);
+          } else if (this.httpEndpoint) {
+            await this.flushToHttpEndpoint(dataToFlush);
+          } else {
+            console.debug(`[Telemetry] Discarding ${dataToFlush.length} events (no backend)`);
+          }
+        } catch (error2) {
+          console.error("[Telemetry] Flush failed:", error2);
+          if (this.telemetryQueue.length < this.config.batchSize * 2) {
+            this.telemetryQueue = [...dataToFlush, ...this.telemetryQueue];
+          }
+        }
+      }
+      /**
+       * Flush data to BigQuery
+       */
+      async flushToBigQuery(data2) {
+        if (!this.bigquery) return;
+        const dataset = this.bigquery.dataset(this.config.datasetId);
+        const table = dataset.table(this.config.tableName);
+        const rows = data2.map((item) => ({
+          cmd: item.cmd,
+          status: item.status,
+          latencyMs: item.latencyMs,
+          plan: item.plan,
+          quotaLeft: item.quotaLeft || null,
+          errorType: item.errorType || null,
+          args: item.args || [],
+          timestamp: item.timestamp,
+          version: item.version || null,
+          environment: item.environment || null,
+          buildId: item.buildId || null,
+          region: item.region || null
+        }));
+        let retries = 0;
+        while (retries < this.config.maxRetries) {
+          try {
+            await table.insert(rows, {
+              ignoreUnknownValues: true,
+              skipInvalidRows: false
+            });
+            console.log(`[Telemetry] Flushed ${rows.length} events to BigQuery`);
+            return;
+          } catch (error2) {
+            retries++;
+            if (retries >= this.config.maxRetries) {
+              throw error2;
+            }
+            await new Promise((resolve4) => setTimeout(resolve4, Math.pow(2, retries) * 1e3));
+          }
+        }
+      }
+      /**
+       * Flush data to HTTP endpoint (fallback)
+       */
+      async flushToHttpEndpoint(data2) {
+        if (!this.httpEndpoint) return;
+        const response2 = await fetch(this.httpEndpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-Telemetry-Version": "1.0",
+            "X-CLI-Version": process.env.npm_package_version || "unknown"
+          },
+          body: JSON.stringify({
+            events: data2,
+            metadata: {
+              flushTime: (/* @__PURE__ */ new Date()).toISOString(),
+              eventCount: data2.length
+            }
+          })
+        }).catch((error2) => {
+          console.error("[Telemetry] HTTP flush failed:", error2);
+          throw error2;
+        });
+        if (!response2.ok) {
+          throw new Error(`HTTP flush failed: ${response2.status}`);
+        }
+        console.log(`[Telemetry] Flushed ${data2.length} events via HTTP`);
+      }
+      /**
+       * Start flush timer
+       */
+      startFlushTimer() {
+        if (this.flushTimer) return;
+        this.flushTimer = setInterval(() => {
+          this.flush().catch((error2) => {
+            console.error("[Telemetry] Timer flush failed:", error2);
+          });
+        }, this.config.flushIntervalMs);
+      }
+      /**
+       * Stop flush timer
+       */
+      stopFlushTimer() {
+        if (this.flushTimer) {
+          clearInterval(this.flushTimer);
+          this.flushTimer = null;
+        }
+      }
+      /**
+       * Setup graceful shutdown
+       */
+      setupGracefulShutdown() {
+        const shutdown = async () => {
+          console.log("[Telemetry] Shutting down...");
+          this.stopFlushTimer();
+          await this.flush();
+          process.exit(0);
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+      }
+      /**
+       * Get analytics queries for dashboard
+       */
+      getAnalyticsQueries() {
+        const dataset = `${this.config.projectId}.${this.config.datasetId}`;
+        const table = `${dataset}.${this.config.tableName}`;
+        return {
+          topErrorCommands: `
+        SELECT 
+          cmd,
+          COUNT(*) as total_executions,
+          COUNTIF(status = 'error') as error_count,
+          ROUND(COUNTIF(status = 'error') * 100.0 / COUNT(*), 2) as error_rate_pct,
+          STRING_AGG(DISTINCT errorType ORDER BY errorType) as error_types
+        FROM \`${table}\`
+        WHERE timestamp >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 7 DAY)
+        GROUP BY cmd
+        HAVING error_count > 0
+        ORDER BY error_rate_pct DESC
+        LIMIT 10
+      `,
+          p95LatencyByCommand: `
+        SELECT 
+          cmd,
+          COUNT(*) as executions,
+          ROUND(AVG(latencyMs), 1) as avg_latency_ms,
+          ROUND(APPROX_QUANTILES(latencyMs, 100)[OFFSET(50)], 1) as p50_latency_ms,
+          ROUND(APPROX_QUANTILES(latencyMs, 100)[OFFSET(95)], 1) as p95_latency_ms,
+          ROUND(MAX(latencyMs), 1) as max_latency_ms
+        FROM \`${table}\`
+        WHERE timestamp >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 7 DAY)
+          AND status = 'success'
+        GROUP BY cmd
+        ORDER BY p95_latency_ms DESC
+        LIMIT 15
+      `,
+          rateLimitAnalysis: `
+        SELECT 
+          DATE(timestamp) as date,
+          COUNT(*) as total_requests,
+          COUNTIF(status = 'rate_limited') as rate_limited_count,
+          ROUND(COUNTIF(status = 'rate_limited') * 100.0 / COUNT(*), 2) as rate_limit_pct,
+          COUNT(DISTINCT cmd) as unique_commands_hit
+        FROM \`${table}\`
+        WHERE timestamp >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 14 DAY)
+        GROUP BY date
+        ORDER BY date DESC
+      `,
+          planUsageDistribution: `
+        SELECT 
+          plan,
+          COUNT(*) as executions,
+          COUNT(DISTINCT cmd) as unique_commands,
+          ROUND(COUNT(*) * 100.0 / SUM(COUNT(*)) OVER(), 2) as execution_share_pct,
+          ROUND(AVG(quotaLeft), 0) as avg_quota_remaining
+        FROM \`${table}\`
+        WHERE timestamp >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 7 DAY)
+        GROUP BY plan
+        ORDER BY executions DESC
+      `,
+          cliVersionHealth: `
+        SELECT 
+          version,
+          COUNT(*) as total_executions,
+          COUNTIF(status = 'success') as success_count,
+          COUNTIF(status = 'error') as error_count,
+          ROUND(COUNTIF(status = 'error') * 100.0 / COUNT(*), 2) as error_rate_pct,
+          MIN(timestamp) as first_seen,
+          MAX(timestamp) as last_seen
+        FROM \`${table}\`
+        WHERE timestamp >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 30 DAY)
+        GROUP BY version
+        ORDER BY first_seen DESC
+        LIMIT 5
+      `
+        };
+      }
+      /**
+       * Check if telemetry is enabled
+       */
+      isActive() {
+        return this.isEnabled;
+      }
+      /**
+       * Disable telemetry
+       */
+      disable() {
+        this.isEnabled = false;
+        this.stopFlushTimer();
+      }
+      /**
+       * Enable telemetry
+       */
+      enable() {
+        this.isEnabled = true;
+        this.startFlushTimer();
+      }
+    };
+    bigQueryTelemetry = BigQueryTelemetryService.getInstance();
+  }
+});
+
 // src/slash-commands/shared/telemetry-helper.ts
 async function trackCommand(data2) {
   try {
+    await bigQueryTelemetry.trackCommandExecution({
+      cmd: data2.cmd,
+      status: data2.status,
+      latencyMs: data2.latencyMs,
+      plan: data2.plan,
+      quotaLeft: data2.quotaLeft,
+      errorType: data2.errorType,
+      args: data2.args
+    });
     fetch("/v1/telemetry", {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -27361,6 +28287,7 @@ function getNextMonthStart() {
 }
 var init_telemetry_helper = __esm({
   "src/slash-commands/shared/telemetry-helper.ts"() {
+    init_bigquery_telemetry();
   }
 });
 
@@ -28064,9 +28991,9 @@ var init_SlashCommandManager = __esm({
       "/exit": true,
       // ✅ Phase 4 - Core commands migrated
       "/status": true,
-      // ✅ Phase 2 - V2 stub implemented
+      // ✅ Phase 2 - standard stub implemented
       "/doctor": true,
-      // ✅ Phase 2 - V2 stub implemented
+      // ✅ Phase 2 - standard stub implemented
       "/config": true,
       // ✅ Configuration commands migrated
       "/model": true,
@@ -28974,13 +29901,14 @@ __export(HelpCommand_exports, {
   HelpCommand: () => HelpCommand,
   meta: () => meta
 });
-var HelpCommand, meta;
+var import_chalk17, HelpCommand, meta;
 var init_HelpCommand = __esm({
   "src/slash-commands/categories/core/handlers/HelpCommand.ts"() {
     init_base_command();
     init_ReadyCommandsService();
     init_telemetry_helper();
     init_subscription_manager();
+    import_chalk17 = __toESM(require("chalk"), 1);
     HelpCommand = class extends BaseCommand {
       name = "help";
       category = "core";
@@ -29095,9 +30023,9 @@ var init_HelpCommand = __esm({
         const stats = await this.readyService.getStatistics();
         const lines = [];
         lines.push("\u2550".repeat(60));
-        lines.push("**" + stats.totalReady + " READY Commands**  | **" + stats.categoriesCount + " Categories**");
+        lines.push(import_chalk17.default.bold(`${stats.totalReady} READY Commands  |  ${stats.categoriesCount} Categories`));
         lines.push("");
-        lines.push("**Quick Access:**");
+        lines.push(import_chalk17.default.bold("Quick Access:"));
         lines.push("  /help <command>      - Detailed help for specific command");
         lines.push("  /help --quickstart   - Essential commands for new users");
         lines.push("  /help --stats        - Performance statistics");
@@ -29112,22 +30040,19 @@ var init_HelpCommand = __esm({
         }
         globalMaxNameLength = Math.max(globalMaxNameLength, 18) + 1;
         for (const category of categories) {
-          lines.push(`**${category.name.toUpperCase()} (${category.count})**`);
+          lines.push(import_chalk17.default.bold(`${category.name.toUpperCase()} (${category.count})`));
           const showCommands = category.commands.slice(0, 4);
           for (const cmd of showCommands) {
             const needsGpu = this.hasGpuRequirement(cmd.description);
             let description = cmd.description;
+            description = description.replace(
+              /\*GPU needed - Local LLM only \(Pro\+ members only\)/g,
+              ""
+            ).trim();
+            const paddedName = `/${cmd.name}`.padEnd(globalMaxNameLength);
+            lines.push(`  ${paddedName} - ${description}`);
             if (needsGpu) {
-              description = description.replace(
-                /\*GPU needed - Local LLM only \(Pro\+ members only\)/g,
-                ""
-              ).trim();
-              const paddedName = `/${cmd.name}`.padEnd(globalMaxNameLength + 5);
-              lines.push(`  ${paddedName} - ${description}`);
-              lines.push(`  *GPU needed - Local LLM (Pro+ only)`);
-            } else {
-              const paddedName = `/${cmd.name}`.padEnd(globalMaxNameLength + 5);
-              lines.push(`  ${paddedName} - ${description}`);
+              lines.push(`    GPU needed - Local LLM (Pro+ only)`);
             }
           }
           if (category.count > 4) {
@@ -29135,7 +30060,7 @@ var init_HelpCommand = __esm({
           }
           lines.push("");
         }
-        lines.push("**Pro Tips:**");
+        lines.push(import_chalk17.default.bold("Pro Tips:"));
         lines.push("  \u2022 All listed commands are production-ready");
         lines.push("  \u2022 Use fuzzy search: /help --search confi \u2192 finds /config");
         lines.push("  \u2022 Categories ordered by importance");
@@ -29174,33 +30099,33 @@ var init_HelpCommand = __esm({
       formatCommandHelp(command) {
         const lines = [];
         lines.push("");
-        lines.push(`\u{1F4D6} **/${command.name}** - ${command.description}`);
+        lines.push(`\u{1F4D6} ${import_chalk17.default.bold(`/${command.name}`)} - ${command.description}`);
         lines.push("\u2550".repeat(50));
         lines.push("");
-        lines.push("**\u2139\uFE0F Information:**");
+        lines.push(import_chalk17.default.bold("\u2139\uFE0F Information:"));
         lines.push(`  Category: ${this.readyService["getCategoryEmoji"](command.category)} ${command.category}`);
         lines.push(`  Status: \u2705 READY (contract validated)`);
         if (command.aliases && command.aliases.length > 0) {
           lines.push(`  Aliases: ${command.aliases.map((a2) => `/${a2}`).join(", ")}`);
         }
         lines.push("");
-        lines.push("**\u{1F3AF} Usage:**");
+        lines.push(import_chalk17.default.bold("\u{1F3AF} Usage:"));
         lines.push(`  ${command.usage}`);
         lines.push("");
-        lines.push("**\u{1F4CB} Contract Validation:**");
+        lines.push(import_chalk17.default.bold("\u{1F4CB} Contract Validation:"));
         lines.push(`  \u26A1 Performance: ${command.contract.maxResponseTime}ms (tested)`);
         lines.push(`  \u{1F4BB} TTY Mode: ${command.contract.tty ? "\u2705 Supported" : "\u274C Not supported"}`);
         lines.push(`  \u{1F527} Non-TTY Mode: ${command.contract.nonTty ? "\u2705 Supported" : "\u274C Not supported"}`);
         lines.push(`  \u{1F500} Pipe Mode: ${command.contract.pipe ? "\u2705 Supported" : "\u274C Not supported"}`);
         lines.push("");
         if (command.examples && command.examples.length > 0) {
-          lines.push("**\u{1F4DD} Examples:**");
+          lines.push(import_chalk17.default.bold("\u{1F4DD} Examples:"));
           for (const example of command.examples) {
             lines.push(`  ${example}`);
           }
           lines.push("");
         }
-        lines.push("**\u{1F4A1} Quick Tips:**");
+        lines.push(import_chalk17.default.bold("\u{1F4A1} Quick Tips:"));
         lines.push(`  \u2022 This command is production-ready and fully tested`);
         lines.push(`  \u2022 Try /${command.name} --help for additional options`);
         if (command.category !== "core") {
@@ -29251,31 +30176,18 @@ var init_HelpCommand = __esm({
         };
         const emoji = emojiMap[categoryName.toLowerCase()] || "\u{1F4CB}";
         lines.push("");
-        lines.push(`${emoji} **${categoryName.toUpperCase()} COMMANDS** (${commands.length} READY)`);
+        lines.push(`${emoji} ${import_chalk17.default.bold(categoryName.toUpperCase() + " COMMANDS")} (${commands.length} READY)`);
         lines.push("\u2550".repeat(50));
         lines.push("");
-        const responseTimes = commands.map((c) => c.contract.maxResponseTime);
-        const avgTime = Math.round(responseTimes.reduce((a2, b) => a2 + b, 0) / responseTimes.length);
-        const minTime = Math.min(...responseTimes);
-        const maxTime = Math.max(...responseTimes);
-        lines.push(`**\u{1F4CA} Performance:** ${avgTime}ms avg (${minTime}-${maxTime}ms range)`);
-        lines.push("");
+        const maxNameLength = Math.max(...commands.map((c) => c.name.length)) + 1;
         for (const command of commands) {
-          lines.push(`**/${command.name}** [${command.contract.maxResponseTime}ms]`);
-          lines.push(`  ${command.description}`);
+          const paddedName = `/${command.name}`.padEnd(maxNameLength + 8);
+          lines.push(`  ${paddedName} - ${command.description}`);
           if (command.aliases && command.aliases.length > 0) {
-            lines.push(`  Aliases: ${command.aliases.map((a2) => `/${a2}`).join(", ")}`);
-          }
-          const compat = [
-            command.contract.tty ? "\u{1F4BB}" : "",
-            command.contract.nonTty ? "\u{1F527}" : "",
-            command.contract.pipe ? "\u{1F500}" : ""
-          ].filter(Boolean).join(" ");
-          if (compat) {
-            lines.push(`  Modes: ${compat}`);
+            lines.push(`    Aliases: ${command.aliases.map((a2) => `/${a2}`).join(", ")}`);
           }
-          lines.push("");
         }
+        lines.push("");
         return lines.join("\n");
       }
       /**
@@ -29298,20 +30210,20 @@ var init_HelpCommand = __esm({
       formatSearchResults(searchTerm, results) {
         const lines = [];
         lines.push("");
-        lines.push(`\u{1F50D} **SEARCH RESULTS** for "${searchTerm}" (${results.length} matches)`);
+        lines.push(`\u{1F50D} ${import_chalk17.default.bold("SEARCH RESULTS")} for "${searchTerm}" (${results.length} matches)`);
         lines.push("\u2550".repeat(50));
         lines.push("");
         for (const result of results) {
           const cmd = result.command;
           const matchInfo = `[${result.matchScore}] ${result.matchReasons[0] || "match"}`;
-          lines.push(`**/${cmd.name}** (${cmd.category}) ${matchInfo}`);
-          lines.push(`  ${cmd.description} [${cmd.contract.maxResponseTime}ms]`);
+          lines.push(`/${cmd.name} (${cmd.category}) ${matchInfo}`);
+          lines.push(`  ${cmd.description}`);
           if (result.matchReasons.length > 1) {
             lines.push(`  Matches: ${result.matchReasons.join(", ")}`);
           }
           lines.push("");
         }
-        lines.push("**\u{1F4A1} Tip:** Higher scores indicate better matches");
+        lines.push(import_chalk17.default.bold("\u{1F4A1} Tip:") + " Higher scores indicate better matches");
         lines.push("");
         return lines.join("\n");
       }
@@ -29322,38 +30234,38 @@ var init_HelpCommand = __esm({
         const quickCommands = await this.readyService.getQuickStartCommands();
         const lines = [];
         lines.push("");
-        lines.push("\u{1F680} **MARIA QUICKSTART** - Essential Commands");
+        lines.push(`\u{1F680} ${import_chalk17.default.bold("MARIA QUICKSTART")} - Essential Commands`);
         lines.push("\u2550".repeat(50));
         lines.push("");
-        lines.push("**\u{1F3AF} Get Started in 3 Steps:**");
+        lines.push(import_chalk17.default.bold("\u{1F3AF} Get Started in 3 Steps:"));
         lines.push("");
-        lines.push("**1\uFE0F\u20E3 Configure Your AI Provider**");
+        lines.push(import_chalk17.default.bold("1\uFE0F\u20E3 Configure Your AI Provider"));
         const modelCmd = quickCommands.find((c) => c.name === "model");
         if (modelCmd) {
           lines.push(`   /${modelCmd.name} - ${modelCmd.description}`);
           lines.push(`   Try: /model set provider=openai key=sk-...`);
         }
         lines.push("");
-        lines.push("**2\uFE0F\u20E3 Check System Status**");
+        lines.push(import_chalk17.default.bold("2\uFE0F\u20E3 Check System Status"));
         const statusCmd = quickCommands.find((c) => c.name === "status");
         if (statusCmd) {
           lines.push(`   /${statusCmd.name} - ${statusCmd.description}`);
           lines.push(`   Try: /status`);
         }
         lines.push("");
-        lines.push("**3\uFE0F\u20E3 Start Coding**");
+        lines.push(import_chalk17.default.bold("3\uFE0F\u20E3 Start Coding"));
         const codeCmd = quickCommands.find((c) => c.name === "code");
         if (codeCmd) {
           lines.push(`   /${codeCmd.name} - ${codeCmd.description}`);
           lines.push(`   Try: /code create a hello world function`);
         }
         lines.push("");
-        lines.push("**\u{1F527} Essential Commands:**");
+        lines.push(import_chalk17.default.bold("\u{1F527} Essential Commands:"));
         for (const cmd of quickCommands) {
-          lines.push(`  /${cmd.name.padEnd(12)} - ${cmd.description} [${cmd.contract.maxResponseTime}ms]`);
+          lines.push(`  /${cmd.name.padEnd(12)} - ${cmd.description}`);
         }
         lines.push("");
-        lines.push("**\u{1F4A1} Next Steps:**");
+        lines.push(import_chalk17.default.bold("\u{1F4A1} Next Steps:"));
         lines.push("  \u2022 /help --category <name> - Explore command categories");
         lines.push("  \u2022 /help --search <term> - Find specific functionality");
         lines.push("  \u2022 /help <command> - Get detailed command help");
@@ -29368,20 +30280,20 @@ var init_HelpCommand = __esm({
         const categories = await this.readyService.getCategories();
         const lines = [];
         lines.push("");
-        lines.push("\u{1F4CA} **READY COMMANDS STATISTICS**");
+        lines.push(`\u{1F4CA} ${import_chalk17.default.bold("READY COMMANDS STATISTICS")}`);
         lines.push("\u2550".repeat(40));
         lines.push("");
-        lines.push("**\u{1F3AF} Overall:**");
+        lines.push(import_chalk17.default.bold("\u{1F3AF} Overall:"));
         lines.push(`  Total READY Commands: ${stats.totalReady}`);
         lines.push(`  Categories: ${stats.categoriesCount}`);
         lines.push(`  Last Updated: ${stats.lastUpdated?.toLocaleString() || "Unknown"}`);
         lines.push("");
-        lines.push("**\u26A1 Performance:**");
+        lines.push(import_chalk17.default.bold("\u26A1 Performance:"));
         lines.push(`  Average Response Time: ${stats.avgResponseTime}ms`);
         lines.push(`  Fastest Command: /${stats.fastestCommand}`);
         lines.push(`  Slowest Command: /${stats.slowestCommand}`);
         lines.push("");
-        lines.push("**\u{1F4CB} By Category:**");
+        lines.push(import_chalk17.default.bold("\u{1F4CB} By Category:"));
         for (const category of categories) {
           const avgTime = Math.round(
             category.commands.reduce((sum, cmd) => sum + cmd.contract.maxResponseTime, 0) / category.commands.length
@@ -29389,7 +30301,7 @@ var init_HelpCommand = __esm({
           lines.push(`  ${category.emoji} ${category.name.padEnd(15)}: ${category.count.toString().padStart(2)} commands (${avgTime}ms avg)`);
         }
         lines.push("");
-        lines.push("**\u2705 Contract Validation:**");
+        lines.push(import_chalk17.default.bold("\u2705 Contract Validation:"));
         lines.push("  All commands tested for:");
         lines.push("  \u2022 Basic execution without crashes");
         lines.push("  \u2022 TTY/non-TTY/pipe compatibility");
@@ -29606,11 +30518,11 @@ var init_LoginCommand = __esm({
 });
 
 // src/services/model-selector-ui.ts
-var readline4, import_chalk17, ModelSelectorUI;
+var readline4, import_chalk18, ModelSelectorUI;
 var init_model_selector_ui = __esm({
   "src/services/model-selector-ui.ts"() {
     readline4 = __toESM(require("readline"), 1);
-    import_chalk17 = __toESM(require("chalk"), 1);
+    import_chalk18 = __toESM(require("chalk"), 1);
     ModelSelectorUI = class {
       models = [];
       selectedIndex = 0;
@@ -29637,7 +30549,7 @@ var init_model_selector_ui = __esm({
             output: process.stdout,
             terminal: true
           });
-          console.log(import_chalk17.default.green(
+          console.log(import_chalk18.default.green(
             "\u250C\u2500[ MODEL MATRIX ]\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"
           ));
           process.stdout.write("\x1B7");
@@ -29705,14 +30617,14 @@ var init_model_selector_ui = __esm({
       }
       renderFromSavedPosition() {
         if (this.isDestroyed) return;
-        console.log(import_chalk17.default.green(
-          "\u2502 " + import_chalk17.default.greenBright("SELECT MODEL:") + " ".repeat(62) + "\u2502"
+        console.log(import_chalk18.default.green(
+          "\u2502 " + import_chalk18.default.greenBright("SELECT MODEL:") + " ".repeat(62) + "\u2502"
         ));
         this.renderContent();
         const scrollInfo = `[${this.selectedIndex + 1}/${this.models.length}]`;
         const helpText = `\u2193:NEXT  \u2191:PREV  ENTER:EXEC  ESC:ABORT ${scrollInfo}`;
-        console.log(import_chalk17.default.green("\u2502 ") + import_chalk17.default.dim.green(helpText.padEnd(76)) + import_chalk17.default.green(" \u2502"));
-        console.log(import_chalk17.default.green(
+        console.log(import_chalk18.default.green("\u2502 ") + import_chalk18.default.dim.green(helpText.padEnd(76)) + import_chalk18.default.green(" \u2502"));
+        console.log(import_chalk18.default.green(
           "\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518"
         ));
       }
@@ -29753,19 +30665,19 @@ var init_model_selector_ui = __esm({
           const item = displayItems[i2];
           if (item.type === "group") {
             console.log(
-              import_chalk17.default.green("\u2502") + import_chalk17.default.dim.green("  \u2501\u2501\u2501 ") + import_chalk17.default.greenBright(item.content.substring(2, item.content.indexOf(" \u2500"))) + import_chalk17.default.dim.green(" " + "\u2501".repeat(71 - item.content.indexOf(" \u2500"))) + import_chalk17.default.green("\u2502")
+              import_chalk18.default.green("\u2502") + import_chalk18.default.dim.green("  \u2501\u2501\u2501 ") + import_chalk18.default.greenBright(item.content.substring(2, item.content.indexOf(" \u2500"))) + import_chalk18.default.dim.green(" " + "\u2501".repeat(71 - item.content.indexOf(" \u2500"))) + import_chalk18.default.green("\u2502")
             );
           } else {
             const isSelected = item.modelIndex === this.selectedIndex;
-            const prefix = isSelected ? import_chalk17.default.greenBright("\u25B6 ") : "  ";
+            const prefix = isSelected ? import_chalk18.default.greenBright("\u25B6 ") : "  ";
             const modelText = item.content;
             if (isSelected) {
               console.log(
-                import_chalk17.default.green("\u2502") + prefix + import_chalk17.default.black.bgGreen(modelText.padEnd(75)) + import_chalk17.default.green("\u2502")
+                import_chalk18.default.green("\u2502") + prefix + import_chalk18.default.black.bgGreen(modelText.padEnd(75)) + import_chalk18.default.green("\u2502")
               );
             } else {
               console.log(
-                import_chalk17.default.green("\u2502") + prefix + import_chalk17.default.green(modelText.substring(0, 75).padEnd(75)) + import_chalk17.default.green("\u2502")
+                import_chalk18.default.green("\u2502") + prefix + import_chalk18.default.green(modelText.substring(0, 75).padEnd(75)) + import_chalk18.default.green("\u2502")
               );
             }
           }
@@ -29836,7 +30748,7 @@ var init_ModelCommand = __esm({
       usage = "[list|set|info|test|benchmark|cost|current|recommend|ui|session|stats] [model-id] [options]";
       providerManager;
       configManager;
-      // V2 Progressive Enhancement Properties
+      // standard Progressive Enhancement Properties
       isV2Enabled = false;
       advancedFeatures;
       examples = [
@@ -29861,7 +30773,7 @@ var init_ModelCommand = __esm({
           input: "/model list --provider openai",
           description: "List models from specific provider"
         },
-        // V2 Enhanced functionality (when enabled)
+        // standard Enhanced functionality (when enabled)
         {
           input: "/model recommend --task code",
           description: "AI-powered model recommendations (v2)"
@@ -29889,26 +30801,26 @@ var init_ModelCommand = __esm({
         this.configManager = new ConfigManager();
         this.providerManager = getProviderManager();
         this.initializeV2Features().catch((error2) => {
-          logger.warn("V2 features initialization failed:", error2);
+          logger.warn("standard features initialization failed:", error2);
         });
       }
       /**
-       * Initialize V2 features if enabled via feature flags (disabled for now)
+       * Initialize standard features if enabled via feature flags (disabled for now)
        */
       async initializeV2Features() {
         try {
           this.isV2Enabled = false;
-          logger.debug("\u{1F4E6} ModelCommand running in V1 compatibility mode (V2 disabled)");
+          logger.debug("\u{1F4E6} ModelCommand running in V1 compatibility mode (standard disabled)");
         } catch (error2) {
-          logger.warn("\u26A0\uFE0F V2 feature initialization failed, falling back to V1", error2);
+          logger.warn("\u26A0\uFE0F standard feature initialization failed, falling back to V1", error2);
           this.isV2Enabled = false;
         }
       }
       /**
-       * Dynamically load V2 modules (disabled for now)
+       * Dynamically load standard modules (disabled for now)
        */
       async loadAdvancedFeatures() {
-        logger.debug("V2 features disabled, skipping advanced feature loading");
+        logger.debug("standard features disabled, skipping advanced feature loading");
         this.isV2Enabled = false;
         this.advancedFeatures = void 0;
       }
@@ -30291,10 +31203,10 @@ var init_ModelCommand = __esm({
         }
       }
       // ========================================
-      // V2 Progressive Enhancement Methods
+      // standard Progressive Enhancement Methods
       // ========================================
       /**
-       * Determine if advanced V2 features should be used
+       * Determine if advanced standard features should be used
        */
       shouldUseAdvanced(action, args) {
         if (!this.isV2Enabled) return false;
@@ -30304,12 +31216,12 @@ var init_ModelCommand = __esm({
         return false;
       }
       /**
-       * Execute advanced V2 features
+       * Execute advanced standard features
        */
       async executeAdvanced(action, args, context2) {
         if (!this.advancedFeatures) {
           return this.error(
-            "V2 features are enabled but not available. Please check your installation.",
+            "standard features are enabled but not available. Please check your installation.",
             "V2_UNAVAILABLE"
           );
         }
@@ -30324,12 +31236,12 @@ var init_ModelCommand = __esm({
             case "stats":
               return await this.executeStatistics(args, context2);
             default:
-              return this.error(`Unknown V2 action: ${action}`);
+              return this.error(`Unknown standard action: ${action}`);
           }
         } catch (error2) {
-          logger.error("V2 feature execution failed:", error2);
+          logger.error("standard feature execution failed:", error2);
           return this.error(
-            `V2 feature failed: ${error2 instanceof Error ? error2.message : "Unknown error"}`,
+            `standard feature failed: ${error2 instanceof Error ? error2.message : "Unknown error"}`,
             "V2_EXECUTION_ERROR",
             error2
           );
@@ -32017,8 +32929,8 @@ async function loadServices() {
           try {
             const commandName = command.startsWith("/") ? command.slice(1) : command;
             if (commandName === "battlecard") {
-              console.log(import_chalk18.default.yellow("\u{1F512} /battlecard is not available on Free plan"));
-              console.log(import_chalk18.default.gray("  Join the waitlist for business features: https://maria-code.ai/waitlist"));
+              console.log(import_chalk19.default.yellow("\u{1F512} /battlecard is not available on Free plan"));
+              console.log(import_chalk19.default.gray("  Join the waitlist for business features: https://maria-code.ai/waitlist"));
               return {
                 success: false,
                 message: "Command not available on Free plan"
@@ -32079,7 +32991,7 @@ async function loadServices() {
       commandManager.setLegacyHandler(legacyHandlerAdapter);
     }
   } catch (e2) {
-    console.warn(import_chalk18.default.yellow("\u26A0 Some services unavailable, using fallbacks"));
+    console.warn(import_chalk19.default.yellow("\u26A0 Some services unavailable, using fallbacks"));
   }
 }
 async function init() {
@@ -32193,20 +33105,20 @@ async function enforceAuth(cmd) {
   try {
     const tokens = await authManager.getValidTokens();
     if (!tokens) {
-      console.log(import_chalk18.default.red("\u{1F510} Authentication required \xB7 Run: maria /login"));
+      console.log(import_chalk19.default.red("\u{1F510} Authentication required \xB7 Run: maria /login"));
       process.exit(2);
       return false;
     }
     return true;
   } catch (error2) {
     if (error2.code === "AUTH_REQUIRED") {
-      console.log(import_chalk18.default.red("\u{1F510} Authentication required \xB7 Run: maria /login"));
+      console.log(import_chalk19.default.red("\u{1F510} Authentication required \xB7 Run: maria /login"));
       process.exit(2);
     } else if (error2.code === "REAUTH_REQUIRED") {
-      console.log(import_chalk18.default.yellow("\u{1F504} Please re-authenticate \xB7 Run: maria /login"));
+      console.log(import_chalk19.default.yellow("\u{1F504} Please re-authenticate \xB7 Run: maria /login"));
       process.exit(2);
     } else {
-      console.log(import_chalk18.default.red("\u{1F310} Network error, check connection"));
+      console.log(import_chalk19.default.red("\u{1F310} Network error, check connection"));
       process.exit(1);
     }
     return false;
@@ -32246,7 +33158,7 @@ async function handleSlash(input3) {
             console.log(JSON.stringify(result.data, null, 2));
           }
         } else {
-          console.log(import_chalk18.default.red(`Help Error: ${result.message}`));
+          console.log(import_chalk19.default.red(`Help Error: ${result.message}`));
         }
         return true;
       }
@@ -32254,7 +33166,7 @@ async function handleSlash(input3) {
       if (process.env.MARIA_DEBUG === "1") {
         console.error("HelpCommand error:", helpError);
       }
-      console.log(import_chalk18.default.yellow("\u26A0 Dynamic help unavailable, using fallback"));
+      console.log(import_chalk19.default.yellow("\u26A0 Dynamic help unavailable, using fallback"));
     }
     const help = `
 \u{1F4D6} MARIA CLI Help
@@ -32279,7 +33191,7 @@ Chat:
     session.length = 0;
     if (ctx?.clearContext) ctx.clearContext();
     console.clear();
-    console.log(import_chalk18.default.cyan("\u2728 Session cleared"));
+    console.log(import_chalk19.default.cyan("\u2728 Session cleared"));
     return true;
   }
   if (cmd === "code") {
@@ -32287,7 +33199,7 @@ Chat:
     const prompt = args.join(" ").trim();
     if (!prompt) {
       console.log(
-        import_chalk18.default.red("Usage: /code <request>    e.g. /code build a REST API")
+        import_chalk19.default.red("Usage: /code <request>    e.g. /code build a REST API")
       );
       return true;
     }
@@ -32299,7 +33211,7 @@ Chat:
     const prompt = args.join(" ").trim();
     if (!prompt) {
       console.log(
-        import_chalk18.default.cyan("\u{1F3A8} **Image Generation**\n") + import_chalk18.default.white("Usage: /image <prompt>\n") + import_chalk18.default.gray("Example: /image \u5BCC\u58EB\u5C71\u306E\u65E5\u306E\u51FA")
+        import_chalk19.default.cyan("\u{1F3A8} **Image Generation**\n") + import_chalk19.default.white("Usage: /image <prompt>\n") + import_chalk19.default.gray("Example: /image \u5BCC\u58EB\u5C71\u306E\u65E5\u306E\u51FA")
       );
       return true;
     }
@@ -32311,14 +33223,14 @@ Chat:
           options: {},
           logger: {
             info: (msg) => console.log(msg),
-            error: (msg) => console.error(import_chalk18.default.red(msg)),
-            warn: (msg) => console.warn(import_chalk18.default.yellow(msg))
+            error: (msg) => console.error(import_chalk19.default.red(msg)),
+            warn: (msg) => console.warn(import_chalk19.default.yellow(msg))
           }
         };
         await imageCommand2.execute(context2);
       }
     } catch (error2) {
-      console.error(import_chalk18.default.red("Image generation failed:"), error2.message);
+      console.error(import_chalk19.default.red("Image generation failed:"), error2.message);
     }
     return true;
   }
@@ -32327,7 +33239,7 @@ Chat:
     const prompt = args.join(" ").trim();
     if (!prompt) {
       console.log(
-        import_chalk18.default.cyan("\u{1F3AC} **Video Generation**\n") + import_chalk18.default.white("Usage: /video <prompt>\n") + import_chalk18.default.gray("Example: /video \u6D77\u306E\u6CE2\u304C\u6253\u3061\u5BC4\u305B\u308B\u69D8\u5B50")
+        import_chalk19.default.cyan("\u{1F3AC} **Video Generation**\n") + import_chalk19.default.white("Usage: /video <prompt>\n") + import_chalk19.default.gray("Example: /video \u6D77\u306E\u6CE2\u304C\u6253\u3061\u5BC4\u305B\u308B\u69D8\u5B50")
       );
       return true;
     }
@@ -32339,14 +33251,14 @@ Chat:
           options: {},
           logger: {
             info: (msg) => console.log(msg),
-            error: (msg) => console.error(import_chalk18.default.red(msg)),
-            warn: (msg) => console.warn(import_chalk18.default.yellow(msg))
+            error: (msg) => console.error(import_chalk19.default.red(msg)),
+            warn: (msg) => console.warn(import_chalk19.default.yellow(msg))
           }
         };
         await videoCommand2.execute(context2);
       }
     } catch (error2) {
-      console.error(import_chalk18.default.red("Video generation failed:"), error2.message);
+      console.error(import_chalk19.default.red("Video generation failed:"), error2.message);
     }
     return true;
   }
@@ -32355,7 +33267,7 @@ Chat:
     const prompt = args.join(" ").trim();
     if (!prompt) {
       console.log(
-        import_chalk18.default.cyan("\u{1F399}\uFE0F **Voice Synthesis**\n") + import_chalk18.default.white("Usage: /voice <text>\n") + import_chalk18.default.gray("Example: /voice \u3053\u3093\u306B\u3061\u306F\u3001\u5143\u6C17\u3067\u3059\u304B\uFF1F")
+        import_chalk19.default.cyan("\u{1F399}\uFE0F **Voice Synthesis**\n") + import_chalk19.default.white("Usage: /voice <text>\n") + import_chalk19.default.gray("Example: /voice \u3053\u3093\u306B\u3061\u306F\u3001\u5143\u6C17\u3067\u3059\u304B\uFF1F")
       );
       return true;
     }
@@ -32367,14 +33279,14 @@ Chat:
           options: {},
           logger: {
             info: (msg) => console.log(msg),
-            error: (msg) => console.error(import_chalk18.default.red(msg)),
-            warn: (msg) => console.warn(import_chalk18.default.yellow(msg))
+            error: (msg) => console.error(import_chalk19.default.red(msg)),
+            warn: (msg) => console.warn(import_chalk19.default.yellow(msg))
           }
         };
         await voiceCommand2.execute(context2);
       }
     } catch (error2) {
-      console.error(import_chalk18.default.red("Voice synthesis failed:"), error2.message);
+      console.error(import_chalk19.default.red("Voice synthesis failed:"), error2.message);
     }
     return true;
   }
@@ -32393,36 +33305,36 @@ Chat:
         if (args.includes("status")) {
           if (await authManager.isAuthenticated()) {
             const user = await authManager.getCurrentUser();
-            console.log(import_chalk18.default.green("\u2705 Authenticated"));
-            console.log(import_chalk18.default.white(`\u{1F464} User: ${import_chalk18.default.cyan(user.email)}`));
-            console.log(import_chalk18.default.white(`\u{1F4CA} Plan: ${import_chalk18.default.cyan(user.plan)}`));
+            console.log(import_chalk19.default.green("\u2705 Authenticated"));
+            console.log(import_chalk19.default.white(`\u{1F464} User: ${import_chalk19.default.cyan(user.email)}`));
+            console.log(import_chalk19.default.white(`\u{1F4CA} Plan: ${import_chalk19.default.cyan(user.plan)}`));
           } else {
-            console.log(import_chalk18.default.yellow("\u26A0\uFE0F Not authenticated"));
-            console.log(import_chalk18.default.gray("Use /login to sign in"));
+            console.log(import_chalk19.default.yellow("\u26A0\uFE0F Not authenticated"));
+            console.log(import_chalk19.default.gray("Use /login to sign in"));
           }
         } else {
           const result = await authManager.login(options2);
           if (result.success && result.user) {
-            console.log(import_chalk18.default.green("\u2705 Successfully logged in!"));
-            console.log(import_chalk18.default.white(`\u{1F464} User: ${import_chalk18.default.cyan(result.user.email)}`));
-            console.log(import_chalk18.default.white(`\u{1F4CA} Plan: ${import_chalk18.default.cyan(result.user.plan)}`));
+            console.log(import_chalk19.default.green("\u2705 Successfully logged in!"));
+            console.log(import_chalk19.default.white(`\u{1F464} User: ${import_chalk19.default.cyan(result.user.email)}`));
+            console.log(import_chalk19.default.white(`\u{1F4CA} Plan: ${import_chalk19.default.cyan(result.user.plan)}`));
           } else {
-            console.log(import_chalk18.default.red("\u274C Login failed"));
-            if (result.error) console.log(import_chalk18.default.gray(result.error));
+            console.log(import_chalk19.default.red("\u274C Login failed"));
+            if (result.error) console.log(import_chalk19.default.gray(result.error));
           }
         }
       }
     } catch (error2) {
-      console.error(import_chalk18.default.red("Login error:"), error2.message);
+      console.error(import_chalk19.default.red("Login error:"), error2.message);
     }
     return true;
   }
   if (cmd === "logout" || cmd === "signout") {
     try {
       await authManager.logout();
-      console.log(import_chalk18.default.green("\u{1F44B} Signed out. Local credentials removed."));
+      console.log(import_chalk19.default.green("\u{1F44B} Signed out. Local credentials removed."));
     } catch (error2) {
-      console.error(import_chalk18.default.red("Logout error:"), error2.message);
+      console.error(import_chalk19.default.red("Logout error:"), error2.message);
     }
     return true;
   }
@@ -32523,11 +33435,11 @@ Chat:
     }
   }
   if (!["battlecard", "sales-dashboard", "tune", "pilot-setup"].includes(cmd)) {
-    console.log(import_chalk18.default.red(`\u274C Unknown command: /${cmd}`));
-    console.log(import_chalk18.default.yellow("\n\u{1F4A1} Suggestions:"));
-    console.log(import_chalk18.default.gray("  \u2022 Type /help to see available commands"));
-    console.log(import_chalk18.default.gray("  \u2022 Check if you need to /login first"));
-    console.log(import_chalk18.default.gray(`  \u2022 Try similar commands: /help --search ${cmd}`));
+    console.log(import_chalk19.default.red(`\u274C Unknown command: /${cmd}`));
+    console.log(import_chalk19.default.yellow("\n\u{1F4A1} Suggestions:"));
+    console.log(import_chalk19.default.gray("  \u2022 Type /help to see available commands"));
+    console.log(import_chalk19.default.gray("  \u2022 Check if you need to /login first"));
+    console.log(import_chalk19.default.gray(`  \u2022 Try similar commands: /help --search ${cmd}`));
   }
   return true;
 }
@@ -32795,11 +33707,11 @@ async function handleCodeCommand(prompt) {
       const filepath = path11.resolve(process.cwd(), filename);
       await fs11.writeFile(filepath, code, "utf-8");
       console.log(
-        import_chalk18.default.green("\n\u2705 **Code Saved**\n") + import_chalk18.default.white(`\u{1F4C1} **File (Click to open):**
-`) + import_chalk18.default.cyan(`\u2022 [${filename}](file://${filepath})
-`) + import_chalk18.default.gray(`  \u{1F4CD} Path: \`${filepath}\`
-`) + import_chalk18.default.white(`  \u{1F4DD} Language: ${language}
-`) + import_chalk18.default.dim(`
+        import_chalk19.default.green("\n\u2705 **Code Saved**\n") + import_chalk19.default.white(`\u{1F4C1} **File (Click to open):**
+`) + import_chalk19.default.cyan(`\u2022 [${filename}](file://${filepath})
+`) + import_chalk19.default.gray(`  \u{1F4CD} Path: \`${filepath}\`
+`) + import_chalk19.default.white(`  \u{1F4DD} Language: ${language}
+`) + import_chalk19.default.dim(`
 \u{1F4A1} Tip: Command+Click (Mac) or Ctrl+Click (Windows/Linux) to open file`)
       );
     } else {
@@ -32808,11 +33720,11 @@ async function handleCodeCommand(prompt) {
   } catch (e2) {
     spinner.stop();
     if (process.env.MARIA_DEBUG === "1") {
-      console.error(import_chalk18.default.red("Code generation error:"), e2.message || e2);
+      console.error(import_chalk19.default.red("Code generation error:"), e2.message || e2);
     }
     const fallbackCode = templateFallback(prompt);
     console.log(
-      import_chalk18.default.yellow("\u26A0 AI unavailable, using template fallback:\n")
+      import_chalk19.default.yellow("\u26A0 AI unavailable, using template fallback:\n")
     );
     console.log(fallbackCode);
     try {
@@ -32821,14 +33733,14 @@ async function handleCodeCommand(prompt) {
       const filepath = path11.resolve(process.cwd(), filename);
       await fs11.writeFile(filepath, code, "utf-8");
       console.log(
-        import_chalk18.default.green("\n\u2705 **Template Code Saved**\n") + import_chalk18.default.white(`\u{1F4C1} **File (Click to open):**
-`) + import_chalk18.default.cyan(`\u2022 [${filename}](file://${filepath})
-`) + import_chalk18.default.gray(`  \u{1F4CD} Path: \`${filepath}\`
-`) + import_chalk18.default.dim(`
+        import_chalk19.default.green("\n\u2705 **Template Code Saved**\n") + import_chalk19.default.white(`\u{1F4C1} **File (Click to open):**
+`) + import_chalk19.default.cyan(`\u2022 [${filename}](file://${filepath})
+`) + import_chalk19.default.gray(`  \u{1F4CD} Path: \`${filepath}\`
+`) + import_chalk19.default.dim(`
 \u{1F4A1} Tip: Command+Click (Mac) or Ctrl+Click (Windows/Linux) to open file`)
       );
     } catch (saveError) {
-      console.error(import_chalk18.default.red("Failed to save code:"), saveError);
+      console.error(import_chalk19.default.red("Failed to save code:"), saveError);
     }
   }
 }
@@ -32884,7 +33796,7 @@ ${userPrompt}`;
         (seq) => response2.includes(seq)
       );
       if (guidedFlowDetected) {
-        console.log(import_chalk18.default.yellow("\u26A0 Guided flow detected, switching to fallback"));
+        console.log(import_chalk19.default.yellow("\u26A0 Guided flow detected, switching to fallback"));
         return null;
       }
       const codeMatch = response2.match(/```[\s\S]*?```/);
@@ -33052,14 +33964,14 @@ async function streamAnswer(text) {
       if (store?.addMessage) await store.addMessage(msg);
     } else {
       animation.stop();
-      console.log(import_chalk18.default.yellow("AI service unavailable. Please check your configuration."));
+      console.log(import_chalk19.default.yellow("AI service unavailable. Please check your configuration."));
     }
   } catch (e2) {
     animation.stop();
     if (e2.message?.includes("timeout") || e2.message?.includes("\u23F1\uFE0F")) {
-      console.log(import_chalk18.default.yellow(e2.message));
+      console.log(import_chalk19.default.yellow(e2.message));
     } else {
-      console.log(import_chalk18.default.red("Error generating response:"), e2.message || e2);
+      console.log(import_chalk19.default.red("Error generating response:"), e2.message || e2);
     }
   }
 }
@@ -33074,9 +33986,9 @@ async function handleLine(line) {
   if (consumed) return;
   const isAuthenticated = await authManager.isAuthenticated();
   if (!isAuthenticated) {
-    console.log(import_chalk18.default.yellow("\n\u26A0\uFE0F  Authentication required for chat features"));
-    console.log(import_chalk18.default.cyan("Please run: /login"));
-    console.log(import_chalk18.default.gray("Or use slash commands like /help, /version"));
+    console.log(import_chalk19.default.yellow("\n\u26A0\uFE0F  Authentication required for chat features"));
+    console.log(import_chalk19.default.cyan("Please run: /login"));
+    console.log(import_chalk19.default.gray("Or use slash commands like /help, /version"));
     return;
   }
   const user = { role: "user", content: input3, timestamp: /* @__PURE__ */ new Date() };
@@ -33098,7 +34010,7 @@ async function startInteractiveSession() {
     }
   }
   const stop = async () => {
-    console.log(import_chalk18.default.cyan("\n\u{1F44B} Goodbye!"));
+    console.log(import_chalk19.default.cyan("\n\u{1F44B} Goodbye!"));
     if (store?.close) await store.close().catch(() => {
     });
     if (interactiveCLI?.cleanup) interactiveCLI.cleanup();
@@ -33108,7 +34020,7 @@ async function startInteractiveSession() {
   process.once("SIGINT", stop);
   process.once("SIGTERM", stop);
   if (!isTTY) {
-    console.log(import_chalk18.default.gray("[Pipe mode detected - streaming input/output]"));
+    console.log(import_chalk19.default.gray("[Pipe mode detected - streaming input/output]"));
     const rl = readline5.createInterface({
       input: import_node_process3.stdin,
       output: import_node_process3.stdout,
@@ -33123,7 +34035,7 @@ async function startInteractiveSession() {
   if (interactiveCLI) {
     while (true) {
       try {
-        const prompt = import_chalk18.default.gray("> ");
+        const prompt = import_chalk19.default.gray("> ");
         process.stdout.write(prompt);
         const line = await interactiveCLI.question("");
         console.log();
@@ -33138,14 +34050,14 @@ async function startInteractiveSession() {
           await stop();
           return;
         }
-        console.error(import_chalk18.default.red("Error:"), error2?.message || error2);
+        console.error(import_chalk19.default.red("Error:"), error2?.message || error2);
       }
     }
   } else {
     const rl = readline5.createInterface({ input: import_node_process3.stdin, output: import_node_process3.stdout });
     while (true) {
       try {
-        const prompt = import_chalk18.default.gray("> ");
+        const prompt = import_chalk19.default.gray("> ");
         const line = await rl.question(prompt);
         console.log();
         if (line.toLowerCase() === "exit" || line.toLowerCase() === "quit") {
@@ -33159,7 +34071,7 @@ async function startInteractiveSession() {
           await stop();
           return;
         }
-        console.error(import_chalk18.default.red("Error:"), error2?.message || error2);
+        console.error(import_chalk19.default.red("Error:"), error2?.message || error2);
       }
     }
   }
@@ -33169,7 +34081,7 @@ function createCLI() {
   program2.name("maria").description(`\u{1F680} MARIA v${getVersion()} - Intelligent AI Assistant`).version(getVersion()).option("--v3-session", "Use v3 session architecture").option("--no-interactive", "Disable interactive mode for CI/CD").option("--server", "Start HTTP server mode for Cloud Run").action(async (options) => {
     loadEnvironmentVariables();
     if (options.server) {
-      console.log(import_chalk18.default.green("\u{1F680} Starting MARIA server mode..."));
+      console.log(import_chalk19.default.green("\u{1F680} Starting MARIA server mode..."));
       try {
         const serverPath = path11.join(process.cwd(), "server.mjs");
         const { spawn } = await import("child_process");
@@ -33178,12 +34090,12 @@ function createCLI() {
           env: process.env
         });
         serverProcess.on("error", (error2) => {
-          console.error(import_chalk18.default.red("\u274C Server process error:"), error2);
+          console.error(import_chalk19.default.red("\u274C Server process error:"), error2);
           process.exit(1);
         });
         return;
       } catch (error2) {
-        console.error(import_chalk18.default.red("\u274C Failed to start server mode:"), error2);
+        console.error(import_chalk19.default.red("\u274C Failed to start server mode:"), error2);
         process.exit(1);
       }
     }
@@ -33193,7 +34105,7 @@ function createCLI() {
         displayStartupLogo2();
         startupDisplayed = true;
       } catch {
-        console.log(import_chalk18.default.cyan(`
+        console.log(import_chalk19.default.cyan(`
 \u{1F680} MARIA v${getVersion()}
 `));
         startupDisplayed = true;
@@ -33202,24 +34114,24 @@ function createCLI() {
     const useV3 = options.v3Session || process.env.MARIA_USE_V3_SESSION === "1";
     if (useV3) {
       try {
-        console.log(import_chalk18.default.cyan("\u{1F680} Starting MARIA v3 session..."));
+        console.log(import_chalk19.default.cyan("\u{1F680} Starting MARIA v3 session..."));
         const { MariaAI: MariaAI2 } = await Promise.resolve().then(() => (init_maria_ai(), maria_ai_exports));
         const maria = new MariaAI2();
         await maria.initialize();
         return;
       } catch (e2) {
-        console.warn(import_chalk18.default.yellow("\u26A0 V3 session unavailable, using standard mode"));
+        console.warn(import_chalk19.default.yellow("\u26A0 V3 session unavailable, using standard mode"));
       }
     }
     await startInteractiveSession();
   });
   return program2;
 }
-var import_commander, import_chalk18, readline5, import_node_process3, path11, fs11, AIResponseService2, ChatContextService2, ConversationPersistence2, InteractiveCLI2, ai, ctx, store, session, commandManager, startupDisplayed, program;
+var import_commander, import_chalk19, readline5, import_node_process3, path11, fs11, AIResponseService2, ChatContextService2, ConversationPersistence2, InteractiveCLI2, ai, ctx, store, session, commandManager, startupDisplayed, program;
 var init_cli = __esm({
   "src/cli.ts"() {
     import_commander = require("commander");
-    import_chalk18 = __toESM(require("chalk"), 1);
+    import_chalk19 = __toESM(require("chalk"), 1);
     readline5 = __toESM(require("readline/promises"), 1);
     import_node_process3 = require("process");
     path11 = __toESM(require("path"), 1);
@@ -33262,21 +34174,21 @@ function createCLI2() {
     }
   });
   program2.command("setup-ollama").description("Setup Ollama for local AI").action(async () => {
-    console.log(import_chalk19.default.cyan("Setting up Ollama..."));
+    console.log(import_chalk20.default.cyan("Setting up Ollama..."));
     console.log(
-      import_chalk19.default.yellow("Please run: brew install ollama && ollama serve")
+      import_chalk20.default.yellow("Please run: brew install ollama && ollama serve")
     );
   });
   program2.command("setup-vllm").description("Setup vLLM for local AI").action(async () => {
-    console.log(import_chalk19.default.cyan("Setting up vLLM..."));
-    console.log(import_chalk19.default.yellow("Please run: pip install vllm"));
+    console.log(import_chalk20.default.cyan("Setting up vLLM..."));
+    console.log(import_chalk20.default.yellow("Please run: pip install vllm"));
   });
   return program2;
 }
-var import_chalk19, import_commander2, MariaAI;
+var import_chalk20, import_commander2, MariaAI;
 var init_maria_ai = __esm({
   "src/maria-ai.ts"() {
-    import_chalk19 = __toESM(require("chalk"), 1);
+    import_chalk20 = __toESM(require("chalk"), 1);
     import_commander2 = require("commander");
     init_startup_display();
     init_provider_selector();
@@ -33299,13 +34211,13 @@ var init_maria_ai = __esm({
           await this.providerSelector.initialize();
           const { provider, model } = await this.providerSelector.selectProvider();
           console.log(
-            import_chalk19.default.green(`
+            import_chalk20.default.green(`
 \u2705 Selected: ${provider} with model ${model}`)
           );
           this.config.set("currentProvider", provider);
           this.config.set("currentModel", model);
           await this.config.save();
-          console.log(import_chalk19.default.cyan("\n\u{1F9E0} Initializing Intelligent Router..."));
+          console.log(import_chalk20.default.cyan("\n\u{1F9E0} Initializing Intelligent Router..."));
           this.router = new IntelligentRouterService({
             confidenceThreshold: 0.85,
             enableLearning: true,
@@ -33313,12 +34225,12 @@ var init_maria_ai = __esm({
           });
           await this.router.initialize();
           console.log(
-            import_chalk19.default.green("\u2705 Intelligent Router initialized successfully\n")
+            import_chalk20.default.green("\u2705 Intelligent Router initialized successfully\n")
           );
           this.session = createInteractiveSession(this);
           await this.session.start();
         } catch (error2) {
-          console.error(import_chalk19.default.red("\n\u274C Initialization failed:"), error2);
+          console.error(import_chalk20.default.red("\n\u274C Initialization failed:"), error2);
           process.exit(1);
         }
       }
@@ -33326,7 +34238,7 @@ var init_maria_ai = __esm({
         if (this.session) {
           await this.session.stop();
         }
-        console.log(import_chalk19.default.cyan("\n\u{1F44B} Goodbye!"));
+        console.log(import_chalk20.default.cyan("\n\u{1F44B} Goodbye!"));
       }
     };
   }
@@ -33336,7 +34248,7 @@ var init_maria_ai = __esm({
 init_maria_ai();
 
 // src/utils/version-check.ts
-var import_chalk20 = __toESM(require("chalk"), 1);
+var import_chalk21 = __toESM(require("chalk"), 1);
 var import_semver = __toESM(require("semver"), 1);
 var MINIMUM_NODE_VERSION = "18.0.0";
 var RECOMMENDED_NODE_VERSION = "20.0.0";
@@ -33344,25 +34256,25 @@ function checkNodeVersion() {
   const currentVersion = process.version;
   if (!import_semver.default.satisfies(currentVersion, `>=${MINIMUM_NODE_VERSION}`)) {
     console.error(
-      import_chalk20.default.red(`
+      import_chalk21.default.red(`
 \u274C Node.js version ${currentVersion} is not supported.`)
     );
     console.error(
-      import_chalk20.default.yellow(`Minimum required version: ${MINIMUM_NODE_VERSION}`)
+      import_chalk21.default.yellow(`Minimum required version: ${MINIMUM_NODE_VERSION}`)
     );
     console.error(
-      import_chalk20.default.yellow(
+      import_chalk21.default.yellow(
         `Recommended version: ${RECOMMENDED_NODE_VERSION} or higher`
       )
     );
-    console.error(import_chalk20.default.cyan("\nPlease upgrade Node.js:"));
-    console.error(import_chalk20.default.gray("  \u2022 Using nvm: nvm install 20 && nvm use 20"));
+    console.error(import_chalk21.default.cyan("\nPlease upgrade Node.js:"));
+    console.error(import_chalk21.default.gray("  \u2022 Using nvm: nvm install 20 && nvm use 20"));
     console.error(
-      import_chalk20.default.gray(
+      import_chalk21.default.gray(
         "  \u2022 Using nodenv: nodenv install 20.0.0 && nodenv global 20.0.0"
       )
     );
-    console.error(import_chalk20.default.gray("  \u2022 Download from: https://nodejs.org/"));
+    console.error(import_chalk21.default.gray("  \u2022 Download from: https://nodejs.org/"));
     process.exit(1);
   }
 }