@bonginkan/maria 4.4.2 → 4.4.3

package/dist/bin/maria.cjs

@@ -23,9 +23,9 @@ var crypto6 = require('crypto');
 var perf_hooks = require('perf_hooks');
 var dotenv = require('dotenv');
 var child_process = require('child_process');
+var promises = require('timers/promises');
 var string_decoder = require('string_decoder');
 var fs9 = require('fs-extra');
-var promises = require('timers/promises');
 var dns = require('dns/promises');
 var yaml = require('js-yaml');
 var neo4j = require('neo4j-driver');
@@ -526,22 +526,22 @@ function dataUriToBuffer(uri) {
   if (firstComma === -1 || firstComma <= 4) {
     throw new TypeError("malformed data: URI");
   }
-  const meta27 = uri.substring(5, firstComma).split(";");
+  const meta28 = uri.substring(5, firstComma).split(";");
   let charset = "";
   let base64 = false;
-  const type = meta27[0] || "text/plain";
+  const type = meta28[0] || "text/plain";
   let typeFull = type;
-  for (let i2 = 1; i2 < meta27.length; i2++) {
-    if (meta27[i2] === "base64") {
+  for (let i2 = 1; i2 < meta28.length; i2++) {
+    if (meta28[i2] === "base64") {
       base64 = true;
-    } else if (meta27[i2]) {
-      typeFull += `;${meta27[i2]}`;
-      if (meta27[i2].indexOf("charset=") === 0) {
-        charset = meta27[i2].substring(8);
+    } else if (meta28[i2]) {
+      typeFull += `;${meta28[i2]}`;
+      if (meta28[i2].indexOf("charset=") === 0) {
+        charset = meta28[i2].substring(8);
       }
     }
   }
-  if (!meta27[0] && !charset.length) {
+  if (!meta28[0] && !charset.length) {
     typeFull += ";charset=US-ASCII";
     charset = "US-ASCII";
   }
@@ -7110,8 +7110,8 @@ var init_base_provider = __esm({
               throw error2;
             }
             if (attempt < maxRetries - 1) {
-              const delay = Math.pow(2, attempt) * 1e3;
-              await new Promise((resolve19) => setTimeout(resolve19, delay));
+              const delay2 = Math.pow(2, attempt) * 1e3;
+              await new Promise((resolve19) => setTimeout(resolve19, delay2));
             }
           }
         }
@@ -7517,8 +7517,8 @@ var init_SecretManagerIntegration = __esm({
             return payload.toString();
           } catch (e2) {
             if (attempt === this.MAX_RETRIES - 1) break;
-            const delay = this.BASE_DELAY_MS * Math.pow(2, attempt);
-            await new Promise((r2) => setTimeout(r2, delay));
+            const delay2 = this.BASE_DELAY_MS * Math.pow(2, attempt);
+            await new Promise((r2) => setTimeout(r2, delay2));
           }
         }
         return void 0;
@@ -8794,10 +8794,10 @@ var init_llm_health_checker = __esm({
       }
       async startLMStudio() {
         try {
-          const { spawn: spawn4 } = await import('child_process');
+          const { spawn: spawn5 } = await import('child_process');
           const _lmsPath = "/Users/bongin_max/.lmstudio/bin/lms";
           return new Promise((resolve19) => {
-            const _child = spawn4(_lmsPath, ["server", "start"], {
+            const _child = spawn5(_lmsPath, ["server", "start"], {
               stdio: "ignore",
               detached: true
             });
@@ -26067,8 +26067,8 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@bonginkan/maria",
-      version: "4.4.2",
-      description: "\u{1F680} MARIA v4.4.2 - Enterprise AI Development Platform with identity system and character voice implementation. 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.",
+      version: "4.4.3",
+      description: "\u{1F680} MARIA v4.4.3 - Enterprise AI Development Platform with identity system and character voice implementation. 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",
@@ -27046,6 +27046,10 @@ ${authUrl}
 });
 
 // src/services/cli-auth/MariaAPIClient.ts
+var MariaAPIClient_exports = {};
+__export(MariaAPIClient_exports, {
+  MariaAPIClient: () => MariaAPIClient
+});
 var MariaAPIClient;
 var init_MariaAPIClient = __esm({
   "src/services/cli-auth/MariaAPIClient.ts"() {
@@ -27069,12 +27073,36 @@ var init_MariaAPIClient = __esm({
           "Content-Type": "application/json"
         };
         if (requiresAuth2) {
-          const token = await this.authClient.getAccessToken();
+          let token = await this.authClient.getAccessToken();
+          if (!token) {
+            try {
+              const stored = await this.authClient.loadStoredTokens();
+              if (stored?.refreshToken) {
+                await this.authClient.refreshAccessToken(stored.refreshToken);
+                token = await this.authClient.getAccessToken();
+              }
+            } catch (e2) {
+              if (process.env.MARIA_DEBUG === "1") {
+                console.error("[MARIA DEBUG] Token refresh preflight failed", String(e2?.message || e2));
+              }
+            }
+          }
           if (!token) {
             throw new Error('Authentication required. Please run "maria /login" first.');
           }
           headers["Authorization"] = `Bearer ${token}`;
         }
+        if (process.env.MARIA_DEBUG === "1") {
+          try {
+            console.error("[MARIA DEBUG] API request start", {
+              method,
+              url: url2,
+              requiresAuth: requiresAuth2,
+              hasAuthHeader: Boolean(headers["Authorization"])
+            });
+          } catch {
+          }
+        }
         let lastError = null;
         for (let attempt = 1; attempt <= (this.config.retryAttempts || 3); attempt++) {
           try {
@@ -27089,26 +27117,52 @@ var init_MariaAPIClient = __esm({
             clearTimeout(timeoutId);
             const responseData = await response.json();
             if (!response.ok) {
-              if (response.status === 401) {
+              if (response.status === 401 && requiresAuth2) {
                 const tokens2 = await this.authClient.loadStoredTokens();
                 if (tokens2?.refreshToken) {
                   try {
+                    if (process.env.MARIA_DEBUG === "1") {
+                      try {
+                        console.error("[MARIA DEBUG] 401 received, attempting token refresh");
+                      } catch {
+                      }
+                    }
                     await this.authClient.refreshAccessToken(tokens2.refreshToken);
+                    const refreshedToken = await this.authClient.getAccessToken();
+                    if (refreshedToken) {
+                      headers["Authorization"] = `Bearer ${refreshedToken}`;
+                    }
+                    if (process.env.MARIA_DEBUG === "1") {
+                      try {
+                        console.error("[MARIA DEBUG] Token refresh completed", { hasAuthHeader: Boolean(headers["Authorization"]) });
+                      } catch {
+                      }
+                    }
                     continue;
                   } catch {
-                    throw new Error("Session expired. Please login again.");
                   }
                 }
-                throw new Error(responseData.hint || "Authentication failed");
+                throw new Error(responseData?.hint || "Authentication failed");
               }
               if (response.status === 429) {
                 const retryAfter = response.headers.get("Retry-After");
-                const delay = retryAfter ? parseInt(retryAfter) * 1e3 : 5e3;
-                console.log(`\u23F3 Rate limited. Waiting ${delay}ms before retry...`);
-                await new Promise((resolve19) => setTimeout(resolve19, delay));
+                const delay2 = retryAfter ? parseInt(retryAfter) * 1e3 : 5e3;
+                console.log(`\u23F3 Rate limited. Waiting ${delay2}ms before retry...`);
+                await new Promise((resolve19) => setTimeout(resolve19, delay2));
                 continue;
               }
-              throw new Error(responseData.error || `Request failed: ${response.status}`);
+              const details = {
+                status: response.status,
+                endpoint: url2,
+                method,
+                attempt,
+                response: responseData
+              };
+              if (process.env.MARIA_DEBUG === "1") {
+                console.error("[MARIA DEBUG] API request failed", details);
+              }
+              const msg = responseData && (responseData.error || responseData.message) || `Request failed: ${response.status}`;
+              throw new Error(msg);
             }
             return responseData;
           } catch (error2) {
@@ -27117,11 +27171,17 @@ var init_MariaAPIClient = __esm({
               console.error(`Request timeout after ${this.config.timeout}ms`);
             }
             if (attempt < (this.config.retryAttempts || 3)) {
+              if (process.env.MARIA_DEBUG === "1") {
+                console.error("[MARIA DEBUG] API error on attempt", { method, endpoint: url2, attempt, error: String(error2?.message || error2) });
+              }
               console.log(`\u{1F504} Retrying request (attempt ${attempt + 1}/${this.config.retryAttempts})...`);
               await new Promise((resolve19) => setTimeout(resolve19, 1e3 * attempt));
             }
           }
         }
+        if (process.env.MARIA_DEBUG === "1") {
+          console.error("[MARIA DEBUG] API request exhausted retries", { method, endpoint: url2, error: String(lastError?.message || lastError) });
+        }
         throw lastError || new Error("Request failed after all retries");
       }
       /**
@@ -27166,6 +27226,33 @@ var init_MariaAPIClient = __esm({
       async getAPIInfo() {
         return this.request("GET", "/api/v1", null, false);
       }
+      /**
+       * Create Stripe checkout session for a target plan
+       */
+      async createCheckoutSession(planId, options) {
+        try {
+          return await this.request("POST", "/api/stripe/create-checkout-session", {
+            planId,
+            isAnnual: Boolean(options?.isAnnual)
+          });
+        } catch (e2) {
+          return await this.request("POST", "/api/create-checkout-session", {
+            planId,
+            isAnnual: Boolean(options?.isAnnual)
+          });
+        }
+      }
+      /**
+       * Create Stripe customer portal session
+       */
+      async createPortalSession(returnUrl) {
+        const body = { returnUrl: returnUrl || (process.env.MARIA_RETURN_URL || "https://maria-code.ai/manage") };
+        try {
+          return await this.request("POST", "/api/stripe/create-portal-session", body);
+        } catch (e2) {
+          return await this.request("POST", "/api/create-portal-session", body);
+        }
+      }
       /**
        * Health check
        */
@@ -27237,7 +27324,7 @@ var init_MariaAPIClient = __esm({
           });
           console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n");
         } catch (error2) {
-          console.error("Failed to fetch usage stats:", error2.message);
+          console.error("Failed to fetch usage stats:", error2?.message || String(error2));
         }
       }
       /**
@@ -27954,6 +28041,12 @@ var init_AuthSecretManager = __esm({
     new AuthSecretManager();
   }
 });
+
+// src/utils/open-url.ts
+var open_url_exports = {};
+__export(open_url_exports, {
+  openUrl: () => openUrl
+});
 async function openUrl(url2) {
   if (process.env.CI === "true" || process.env.SSH_CONNECTION || process.env.CONTAINER === "true") {
     throw new Error("Headless environment");
@@ -28131,7 +28224,7 @@ var init_AuthenticationManager = __esm({
           const response = await fetch(`${this.apiBase}/api/user/profile`, {
             headers: {
               "Authorization": `Bearer ${tokens2.accessToken}`,
-              "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.4.2"}`
+              "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.4.3"}`
             }
           });
           if (response.status === 401) {
@@ -28785,7 +28878,7 @@ async function callApi(path66, init3 = {}) {
     "Authorization": `Bearer ${token}`,
     "X-Device-Id": getDeviceId(),
     "X-Session-Id": getSessionId() || "",
-    "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.4.2"}`,
+    "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.4.3"}`,
     "Content-Type": init3.headers?.["Content-Type"] || "application/json"
   });
   const doFetch = async (token) => {
@@ -29050,6 +29143,273 @@ var init_choice_memory = __esm({
   }
 });
 
+// src/services/local-llm-manager.ts
+var local_llm_manager_exports = {};
+__export(local_llm_manager_exports, {
+  ensureLocalProviderUp: () => ensureLocalProviderUp,
+  generateViaCli: () => generateViaCli,
+  selectLocalProviderAndModel: () => selectLocalProviderAndModel
+});
+function debugLog(...args2) {
+  if (process.env.MARIA_DEBUG === "1") {
+    try {
+      console.log("[DEBUG/local-llm]", ...args2);
+    } catch {
+    }
+  }
+}
+async function isUp(provider) {
+  const res = await discoverLocalProvider(provider, { timeoutMs: 600, nearbyScan: true });
+  return res?.base || null;
+}
+async function tryStartLMStudio() {
+  child_process.spawn("lms", ["server", "start"], { stdio: "ignore", detached: true }).unref();
+}
+async function tryStartOllama() {
+  child_process.spawn("ollama", ["serve"], { stdio: "ignore", detached: true }).unref();
+}
+async function waitUntilUp(provider, timeoutMs = 15e3) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const base = await isUp(provider);
+    if (base) return base;
+    await promises.setTimeout(500);
+  }
+  return null;
+}
+async function ensureLocalProviderUp(preferredOrder = ["lmstudio", "ollama"]) {
+  for (const p of preferredOrder) {
+    const up = await isUp(p);
+    if (up) {
+      debugLog("provider up", p, up);
+      return { provider: p, baseUrl: up, started: false };
+    }
+    try {
+      debugLog("attempting autostart", p);
+      if (p === "lmstudio") await tryStartLMStudio();
+      else await tryStartOllama();
+      const providerTimeout = p === "lmstudio" ? parseInt(process.env.LMSTUDIO_STARTUP_TIMEOUT_MS || "") || 9e4 : parseInt(process.env.OLLAMA_STARTUP_TIMEOUT_MS || "") || 2e4;
+      const base = await waitUntilUp(p, providerTimeout);
+      if (base) {
+        debugLog("provider started", p, base);
+        return { provider: p, baseUrl: base, started: true };
+      }
+      debugLog("autostart failed or timed out", p);
+    } catch (e2) {
+      debugLog("autostart error", p, e2?.message || String(e2));
+    }
+  }
+  debugLog("no preferred providers available");
+  return null;
+}
+function parseModelId(id) {
+  const s2 = id.toLowerCase();
+  const afterSlash = s2.includes("/") ? s2.split("/").pop() || s2 : s2;
+  const m1 = afterSlash.match(/^(gpt-oss|gemma|llama|magistral)[-:]?(\d+(?:\.\d+)?)?([a-z]*)?[:\-]?(\d+)?([a-z]*)?$/);
+  if (m1) {
+    const fam = m1[1];
+    const verToken = m1[2] || null;
+    const lastNum = m1[4] || null;
+    const sizeToken = (m1[3] || m1[5] || "").toLowerCase();
+    const version = verToken ? Number(verToken) : null;
+    const size = lastNum ? Number(lastNum) : sizeToken.includes("b") ? Number(sizeToken.replace(/[^0-9]/g, "")) : null;
+    return { family: fam, version, size };
+  }
+  const m2 = afterSlash.match(/^(gpt-oss|gemma|llama|magistral)[^-:]*[:](\d+)([a-z])$/);
+  if (m2) {
+    return { family: m2[1], version: null, size: Number(m2[2]) };
+  }
+  return { family: s2.split(/[-:]/)[0], version: null, size: null };
+}
+function pickBestModel(models, prefs) {
+  if (!models.length) return null;
+  if (prefs.explicitModel) {
+    const exact = models.find((m2) => m2.toLowerCase() === prefs.explicitModel.toLowerCase());
+    if (exact) return exact;
+    const family = prefs.explicitModel.split(/[:\-]/)[0].toLowerCase();
+    const famMs = models.filter((m2) => m2.toLowerCase().startsWith(family));
+    if (famMs.length) models = famMs;
+  }
+  const familyRank = (id) => {
+    const fam = parseModelId(id).family;
+    const idx = FAMILY_ORDER.indexOf(fam);
+    return idx === -1 ? 999 : idx;
+  };
+  const score = (id) => {
+    const { version, size } = parseModelId(id);
+    return [-(version || 0), -(size || 0)];
+  };
+  const sorted = [...models].sort((a, b) => {
+    const fa = familyRank(a);
+    const fb = familyRank(b);
+    if (fa !== fb) return fa - fb;
+    const [va, sa] = score(a);
+    const [vb, sb] = score(b);
+    if (va !== vb) return va - vb;
+    return sa - sb;
+  });
+  return sorted[0] || null;
+}
+async function listModels(provider, baseUrl) {
+  const viaCli = await listModelsViaCli(provider).catch(() => []);
+  if (viaCli.length) return viaCli;
+  try {
+    const url2 = provider === "ollama" ? `${baseUrl}/api/tags` : `${baseUrl}/models`;
+    const res = await fetch(url2);
+    if (!res.ok) return [];
+    const body = await res.json().catch(() => ({}));
+    if (provider === "ollama") {
+      const arr2 = Array.isArray(body.models) ? body.models : body.data || [];
+      return arr2.map((m2) => m2?.name).filter(Boolean);
+    }
+    const arr = Array.isArray(body.data) ? body.data : Array.isArray(body._data) ? body._data : [];
+    return arr.map((m2) => m2?.id).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+async function ensureBaselineModel(provider) {
+  if (provider === "lmstudio") {
+    child_process.spawn("lms", ["model", "download", "openai/gpt-oss-20b"], { stdio: "ignore", detached: true }).unref();
+    return;
+  }
+  child_process.spawn("ollama", ["pull", "gpt-oss:latest"], { stdio: "ignore", detached: true }).unref();
+}
+async function selectLocalProviderAndModel(prefs = {}) {
+  const order = prefs.explicitProvider ? [
+    prefs.explicitProvider,
+    ...prefs.explicitProvider === "lmstudio" ? ["ollama"] : ["lmstudio"]
+  ] : ["lmstudio", "ollama"];
+  const up = await ensureLocalProviderUp(order);
+  if (!up) return null;
+  let models = await listModels(up.provider, up.baseUrl);
+  if (process.env.MARIA_DEBUG === "1") {
+    try {
+      console.log("[DEBUG/local-llm] models.list", up.provider, models.slice(0, 20));
+    } catch {
+    }
+  }
+  if (!models.length) {
+    await ensureBaselineModel(up.provider);
+    await promises.setTimeout(2e3);
+    models = await listModels(up.provider, up.baseUrl);
+  }
+  if (up.provider === "lmstudio") {
+    const hasPreferred = models.some((m2) => parseModelId(m2).family === "gpt-oss");
+    if (!hasPreferred) {
+      await ensureBaselineModel("lmstudio");
+      await promises.setTimeout(3e3);
+      models = await listModels(up.provider, up.baseUrl);
+      if (process.env.MARIA_DEBUG === "1") {
+        try {
+          console.log("[DEBUG/local-llm] models.relist.after-download", models.slice(0, 20));
+        } catch {
+        }
+      }
+    }
+  }
+  const chosen = pickBestModel(models, prefs) || (up.provider === "lmstudio" ? "openai/gpt-oss-20b" : "gpt-oss:latest");
+  debugLog("selected provider/model", up.provider, chosen);
+  return { provider: up.provider, baseUrl: up.baseUrl, model: chosen };
+}
+function runCommand(cmd, args2, input3, timeoutMs = 3e5) {
+  return new Promise((resolve19) => {
+    const child = child_process.spawn(cmd, args2, { stdio: ["pipe", "pipe", "pipe"] });
+    let stdout2 = "";
+    let stderr = "";
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    }, timeoutMs);
+    child.stdout?.on("data", (d) => {
+      stdout2 += d.toString();
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      resolve19({ code, stdout: stdout2, stderr });
+    });
+    if (input3 && child.stdin) {
+      child.stdin.write(input3);
+      child.stdin.end();
+    }
+  });
+}
+async function listModelsViaCli(provider) {
+  try {
+    if (provider === "lmstudio") {
+      const res2 = await runCommand("lms", ["ls", "--json"]);
+      if (res2.code === 0) {
+        try {
+          const j = JSON.parse(res2.stdout);
+          const arr = Array.isArray(j?.models) ? j.models : Array.isArray(j?.data) ? j.data : [];
+          return arr.map((m2) => m2?.id || m2?.name).filter(Boolean);
+        } catch {
+        }
+      }
+      const res22 = await runCommand("lms", ["ls"]);
+      if (res22.code === 0) {
+        return res22.stdout.split(/\r?\n/).map((s2) => s2.trim()).filter(Boolean);
+      }
+      return [];
+    }
+    const res = await runCommand("ollama", ["list"]);
+    if (res.code === 0) {
+      const lines = res.stdout.split(/\r?\n/).slice(1).filter(Boolean);
+      const names = lines.map((l) => l.split(/\s+/)[0]).filter(Boolean);
+      return names;
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}
+async function generateViaCli(provider, model, prompt) {
+  try {
+    if (provider === "lmstudio") {
+      const args2 = ["chat", model, "-p", prompt, "--yes", "--offline", "--ttl", "2"];
+      if (process.env.MARIA_DEBUG === "1") {
+        try {
+          console.log("[DEBUG/local][lmstudio-cli] args", args2);
+        } catch {
+        }
+      }
+      const exec2 = await runCommand("lms", args2);
+      if (process.env.MARIA_DEBUG === "1") {
+        try {
+          console.log("[DEBUG/local][lmstudio-cli] exit", exec2.code, "stdout.len:", exec2.stdout.length, "stderr.len:", exec2.stderr.length);
+        } catch {
+        }
+      }
+      if (exec2.code === 0) {
+        const out = exec2.stdout.trim();
+        if (out) return out;
+        const err = exec2.stderr.trim();
+        if (err) return err;
+      }
+      return null;
+    }
+    const res = await runCommand("ollama", ["run", model], prompt);
+    if (res.code === 0) return res.stdout.trim();
+    const res2 = await runCommand("ollama", ["run", model, prompt]);
+    if (res2.code === 0) return res2.stdout.trim();
+    return null;
+  } catch {
+    return null;
+  }
+}
+var FAMILY_ORDER;
+var init_local_llm_manager = __esm({
+  "src/services/local-llm-manager.ts"() {
+    init_llm_endpoint_discovery();
+    FAMILY_ORDER = ["gpt-oss", "gemma", "llama", "magistral"];
+  }
+});
+
 // src/services/cli-auth/api-caller.ts
 var api_caller_exports = {};
 __export(api_caller_exports, {
@@ -29059,6 +29419,44 @@ __export(api_caller_exports, {
   executeChat: () => executeChat,
   executeCode: () => executeCode
 });
+function sanitizeLocalOutputText(raw) {
+  let t2 = (raw || "").toString();
+  const marker = "<|channel|>final<|message|>";
+  const idx = t2.lastIndexOf(marker);
+  if (idx >= 0) {
+    let body = t2.substring(idx + marker.length);
+    const endIdx = body.indexOf("<|end|>");
+    if (endIdx >= 0) body = body.substring(0, endIdx);
+    return body.trim();
+  }
+  return t2.replace(/<\|[^>]+?\|>/g, "").trim();
+}
+async function getEnterpriseFlag() {
+  if (cachedEnterprise !== null) return cachedEnterprise;
+  try {
+    const tokens2 = await authManager2.getValidTokens();
+    if (!tokens2) return false;
+    const apiBase = process.env.MARIA_API_BASE || "https://api.maria-code.ai";
+    const ctl = new AbortController();
+    const to = setTimeout(() => ctl.abort(), 3e3);
+    const r2 = await fetch(`${apiBase}/api/user/profile`, {
+      method: "GET",
+      headers: { "Authorization": `Bearer ${tokens2.accessToken}` }
+    });
+    clearTimeout(to);
+    if (!r2.ok) {
+      cachedEnterprise = false;
+      return false;
+    }
+    const prof = await r2.json().catch(() => ({}));
+    const plan = String((prof?.plan || "").toString()).toLowerCase();
+    cachedEnterprise = plan === "enterprise";
+    return cachedEnterprise;
+  } catch {
+    cachedEnterprise = false;
+    return false;
+  }
+}
 async function callAPI(endpoint, options = {}) {
   const tokens2 = await authManager2.getValidTokens();
   if (!tokens2) {
@@ -29066,6 +29464,93 @@ async function callAPI(endpoint, options = {}) {
   }
   const apiBase = process.env.MARIA_API_BASE || "https://api.maria-code.ai";
   const url2 = `${apiBase}${endpoint}`;
+  try {
+    const isLocalMode = process.env.LOCAL_MODE === "1";
+    const isAiProxy = endpoint === "/v1/ai-proxy" && (options.method || "GET") === "POST";
+    if (isAiProxy && (isLocalMode || true)) {
+      const isEnterprisePlan = await getEnterpriseFlag().catch(() => false) || String(process.env.PLAN || "").toLowerCase() === "enterprise";
+      if (!isLocalMode && !isEnterprisePlan) {
+      } else {
+        const payload = options.body || {};
+        const reqProvider = String(payload?.provider || "").toLowerCase();
+        if (isEnterprisePlan && reqProvider && !["lmstudio", "ollama"].includes(reqProvider)) {
+          throw new Error("Enterprise policy requires local LLM only");
+        }
+        const explicitModel = typeof payload?.model === "string" ? payload.model : void 0;
+        let effectivePrompt = void 0;
+        if (typeof payload?.prompt === "string" && payload.prompt.trim()) {
+          effectivePrompt = String(payload.prompt).trim();
+        } else if (Array.isArray(payload?.messages)) {
+          try {
+            const lastUser = [...payload.messages].reverse().find((m2) => (m2?.role || "").toLowerCase() === "user");
+            effectivePrompt = lastUser?.content && String(lastUser.content) || payload.messages.map((m2) => String(m2?.content || "")).filter(Boolean).join("\n");
+          } catch {
+          }
+        }
+        if (effectivePrompt && (!reqProvider || ["lmstudio", "ollama"].includes(reqProvider))) {
+          try {
+            let inlineProvider;
+            let inlineModel;
+            {
+              const provMatch = /\s--provider=([a-zA-Z0-9_-]+)/i.exec(effectivePrompt);
+              if (provMatch) inlineProvider = provMatch[1].toLowerCase();
+              const modelMatch = /\s--model=([^\s]+)/i.exec(effectivePrompt);
+              if (modelMatch) inlineModel = modelMatch[1];
+              if (inlineProvider || inlineModel) {
+                effectivePrompt = effectivePrompt.replace(/\s--provider=[^\s]+/ig, "").replace(/\s--model=[^\s]+/ig, "").trim();
+              }
+            }
+            const { selectLocalProviderAndModel: selectLocalProviderAndModel2, generateViaCli: generateViaCli2 } = await Promise.resolve().then(() => (init_local_llm_manager(), local_llm_manager_exports));
+            const sel = await selectLocalProviderAndModel2({ explicitModel: inlineModel || explicitModel, explicitProvider: inlineProvider });
+            if (process.env.MARIA_DEBUG === "1" && sel) {
+              try {
+                console.log("[DEBUG/local] provider:", sel.provider, "model:", sel.model);
+              } catch {
+              }
+            }
+            if (sel) {
+              const out = await generateViaCli2(sel.provider, sel.model, effectivePrompt);
+              if (typeof out === "string" && out.length > 0) {
+                const finalText = sanitizeLocalOutputText(out);
+                if (process.env.MARIA_DEBUG === "1") {
+                  try {
+                    console.log("[DEBUG/local] sanitize", { inLen: out.length, outLen: finalText.length, changed: finalText.length !== out.length });
+                  } catch {
+                  }
+                }
+                try {
+                  const ctl = new AbortController();
+                  const to = setTimeout(() => ctl.abort(), 1500);
+                  await fetch(`${apiBase}/api/v1/usage`, {
+                    method: "POST",
+                    headers: {
+                      "Authorization": `Bearer ${tokens2.accessToken}`,
+                      "Content-Type": "application/json",
+                      "Idempotency-Key": `cli_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`
+                    },
+                    body: JSON.stringify({ consumption: { requests: 1 } }),
+                    signal: ctl.signal
+                  }).catch(() => null);
+                  clearTimeout(to);
+                } catch {
+                }
+                return { data: { content: finalText, routedModel: { vendor: "local", family: sel.provider, name: sel.model, reason: isEnterprisePlan ? "enterprise" : "local_mode" } } };
+              }
+            }
+            if (isEnterprisePlan) {
+              throw new Error("Enterprise policy requires local LLM. Local execution failed or unavailable.");
+            }
+          } catch (e2) {
+            if (isEnterprisePlan) throw e2;
+          }
+        } else if (isEnterprisePlan) {
+          throw new Error("Enterprise policy requires local LLM only");
+        }
+      }
+    }
+  } catch (e2) {
+    if (String(process.env.PLAN || "").toLowerCase() === "enterprise") throw e2;
+  }
   const controller = new AbortController();
   const defaultMs = 6e5;
   const envMs = Number(process.env.MARIA_API_TIMEOUT_MS || process.env.MARIA_CODE_TIMEOUT_MS || defaultMs);
@@ -29225,12 +29710,13 @@ async function executeAIProxy(provider, model, messages, options) {
     body: { provider, model, messages, options }
   });
 }
-var authManager2, RateLimitError;
+var authManager2, cachedEnterprise, RateLimitError;
 var init_api_caller = __esm({
   "src/services/cli-auth/api-caller.ts"() {
     init_AuthenticationManager();
     new https__default.default.Agent({ keepAlive: true });
     authManager2 = new AuthenticationManager();
+    cachedEnterprise = null;
     RateLimitError = class extends Error {
       constructor(message, retryAfter) {
         super(message);
@@ -38009,7 +38495,23 @@ var init_telemetry_helper = __esm({
 
 // src/services/subscription/subscription-manager.ts
 async function getUserPlan() {
-  return "free";
+  try {
+    const { cliAuth: cliAuth2 } = await Promise.resolve().then(() => (init_CLIAuthService(), CLIAuthService_exports));
+    const api = cliAuth2.getAPIClient();
+    const usage = await api.getUsage();
+    const raw = String(usage?.planCode || usage?.planName || "").toUpperCase();
+    const normalized = raw.replace(/[-_](ANNUAL|MONTHLY|YEARLY)$/i, "").toUpperCase();
+    try {
+      process.env.MARIA_PLAN = raw;
+    } catch {
+    }
+    if (normalized === "ENTERPRISE" || normalized === "ULTRA") return "ultra";
+    if (normalized === "PRO") return "pro";
+    if (normalized === "STARTER") return "starter";
+    return "free";
+  } catch {
+    return "free";
+  }
 }
 var init_subscription_manager = __esm({
   "src/services/subscription/subscription-manager.ts"() {
@@ -40640,18 +41142,18 @@ var init_StatusCommand = __esm({
         );
         if (process.env.NODE_ENV === "test") {
           if (timeoutMs < 200 || options.signal) {
-            const delay = Math.max(75, timeoutMs + 50);
+            const delay2 = Math.max(75, timeoutMs + 50);
             systemHealthPromise = Promise.all([
               systemHealthPromise,
-              this.createCancellableDelay(delay, options.signal)
+              this.createCancellableDelay(delay2, options.signal)
             ]).then(([health]) => health);
           } else {
             systemHealthPromise = systemHealthPromise.then((health) => {
               return new Promise((resolve19) => {
                 if (!globalThis._statusCommandTestCounter)
                   globalThis._statusCommandTestCounter = 0;
-                const delay = ++globalThis._statusCommandTestCounter % 2 === 1 ? 3 : 1;
-                setTimeout(() => resolve19(health), delay);
+                const delay2 = ++globalThis._statusCommandTestCounter % 2 === 1 ? 3 : 1;
+                setTimeout(() => resolve19(health), delay2);
               });
             });
           }
@@ -48613,13 +49115,13 @@ async function withRetry429(fn, opts) {
       const kind = classify(e2);
       if (!kind) throw e2;
       if (i2 === opts.retries) break;
-      const delay = backoffDelay(i2, opts);
+      const delay2 = backoffDelay(i2, opts);
       try {
-        process.stderr.write(`WARN: ${kind} retry in ${delay}ms (attempt ${i2 + 1}/${opts.retries})
+        process.stderr.write(`WARN: ${kind} retry in ${delay2}ms (attempt ${i2 + 1}/${opts.retries})
 `);
       } catch {
       }
-      await sleep2(delay);
+      await sleep2(delay2);
     }
   }
   throw lastErr;
@@ -51505,7 +52007,7 @@ var init_about_command = __esm({
       async execute(args2, context2) {
         const output3 = [];
         output3.push("");
-        output3.push(chalk14__default.default.cyan.bold("About MARIA v4.4.2"));
+        output3.push(chalk14__default.default.cyan.bold("About MARIA v4.4.3"));
         output3.push(chalk14__default.default.gray("\u2550".repeat(40)));
         output3.push("");
         output3.push(chalk14__default.default.white.bold("MARIA - Minimal API, Maximum Power"));
@@ -55917,16 +56419,16 @@ function countRemainingLines(hunks, startHunkIdx, currentPart, currentLine) {
 }
 function colorGreen(s2) {
   try {
-    const chalk44 = __require("chalk");
-    return chalk44.green(s2);
+    const chalk46 = __require("chalk");
+    return chalk46.green(s2);
   } catch {
     return s2;
   }
 }
 function colorRed(s2) {
   try {
-    const chalk44 = __require("chalk");
-    return chalk44.red(s2);
+    const chalk46 = __require("chalk");
+    return chalk46.red(s2);
   } catch {
     return s2;
   }
@@ -57415,9 +57917,9 @@ function emitTelemetry(ev) {
 }
 async function assertCleanWorkingTree() {
   try {
-    const { spawn: spawn4 } = await import('child_process');
+    const { spawn: spawn5 } = await import('child_process');
     const run = (cmd, args2) => new Promise((resolve19) => {
-      const p = spawn4(cmd, args2, { stdio: "ignore" });
+      const p = spawn5(cmd, args2, { stdio: "ignore" });
       p.on("close", (code) => resolve19(code ?? 0));
       p.on("error", () => resolve19(1));
     });
@@ -57432,15 +57934,15 @@ async function assertCleanWorkingTree() {
 }
 async function gitSingleCommit(appliedCount, opts) {
   try {
-    const { spawn: spawn4 } = await import('child_process');
+    const { spawn: spawn5 } = await import('child_process');
     const run = (cmd, args2) => new Promise((resolve19) => {
-      const p = spawn4(cmd, args2, { stdio: "ignore" });
+      const p = spawn5(cmd, args2, { stdio: "ignore" });
       p.on("close", (code2) => resolve19(code2 ?? 0));
       p.on("error", () => resolve19(1));
     });
     const runOut = (cmd, args2) => new Promise((resolve19) => {
       const chunks = [];
-      const p = spawn4(cmd, args2, { stdio: ["ignore", "pipe", "ignore"] });
+      const p = spawn5(cmd, args2, { stdio: ["ignore", "pipe", "ignore"] });
       p.stdout.on("data", (c) => chunks.push(c));
       p.on("close", () => resolve19(Buffer.concat(chunks).toString().trim()));
       p.on("error", () => resolve19(""));
@@ -57478,10 +57980,10 @@ async function gitSingleCommit(appliedCount, opts) {
 }
 async function buildAutoTag(prefix) {
   try {
-    const { spawn: spawn4 } = await import('child_process');
+    const { spawn: spawn5 } = await import('child_process');
     const runOut = (cmd, args2) => new Promise((resolve19) => {
       const chunks = [];
-      const p = spawn4(cmd, args2, { stdio: ["ignore", "pipe", "ignore"] });
+      const p = spawn5(cmd, args2, { stdio: ["ignore", "pipe", "ignore"] });
       p.stdout.on("data", (c) => chunks.push(c));
       p.on("close", () => resolve19(Buffer.concat(chunks).toString().trim()));
       p.on("error", () => resolve19(""));
@@ -59589,12 +60091,12 @@ async function scanRoot(opts) {
       const filepath = path12__namespace.join(cwd2, name2);
       const result = await safeRead(filepath, 512 * 1024, maxLines, signal);
       if (result.head || result.meta) {
-        let meta27 = result.meta || object;
+        let meta28 = result.meta || object;
         if (name2 === "package.json" && result.head) {
           try {
             const pkg = JSON.parse(result.head);
-            meta27 = {
-              ...meta27,
+            meta28 = {
+              ...meta28,
               name: pkg.name,
               version: pkg.version,
               type: pkg.type,
@@ -59607,14 +60109,14 @@ async function scanRoot(opts) {
               workspaces: pkg.workspaces
             };
           } catch (e2) {
-            meta27.parseError = true;
+            meta28.parseError = true;
           }
         }
         findings.push({
           file: name2,
           kind: "read",
           head: result.head,
-          meta: meta27,
+          meta: meta28,
           truncated: result.truncated
         });
       }
@@ -59952,19 +60454,19 @@ function extractPackageInfo(findings) {
       hasPostinstall: false
     };
   }
-  const meta27 = pkgFinding.meta;
+  const meta28 = pkgFinding.meta;
   return {
-    name: meta27.name,
-    version: meta27.version,
-    type: meta27.type,
-    scripts: meta27.scripts ? Object.keys(meta27.scripts) : [],
-    hasPostinstall: !!meta27.scripts?.postinstall,
-    bin: meta27.bin,
-    main: meta27.main,
-    exports: meta27.exports,
-    dependencies: meta27.dependencies || [],
-    devDependencies: meta27.devDependencies || [],
-    workspaces: meta27.workspaces
+    name: meta28.name,
+    version: meta28.version,
+    type: meta28.type,
+    scripts: meta28.scripts ? Object.keys(meta28.scripts) : [],
+    hasPostinstall: !!meta28.scripts?.postinstall,
+    bin: meta28.bin,
+    main: meta28.main,
+    exports: meta28.exports,
+    dependencies: meta28.dependencies || [],
+    devDependencies: meta28.devDependencies || [],
+    workspaces: meta28.workspaces
   };
 }
 function collectWarnings(pkg, findings, cwd2) {
@@ -60115,9 +60617,9 @@ function calculateMetrics(findings, startTime) {
 }
 function renderFinding(f3) {
   const title = `### ${f3.kind.toUpperCase()} \u2014 ${f3.file}`;
-  let meta27 = "";
+  let meta28 = "";
   if (f3.meta && Object.keys(f3.meta).length > 0) {
-    meta27 = `
+    meta28 = `
 <details><summary>meta</summary>
 
 \`\`\`json
@@ -60138,7 +60640,7 @@ ${f3.head.trim()}
   }
   const truncInfo = f3.truncated ? `
 > _truncated preview_` : "";
-  return [title, meta27, content, truncInfo, ""].join("\n");
+  return [title, meta28, content, truncInfo, ""].join("\n");
 }
 function safeJsonStringify(obj) {
   try {
@@ -70853,11 +71355,11 @@ var init_search_command = __esm({
        * Calculate processing delay for simulation
        */
       calculateProcessingDelay(options) {
-        let delay = 100;
-        if (options.kgBoost) delay += 50;
-        if (options.rerank) delay += 100;
-        if (options.explain) delay += 30;
-        return delay + Math.random() * 50;
+        let delay2 = 100;
+        if (options.kgBoost) delay2 += 50;
+        if (options.rerank) delay2 += 100;
+        if (options.explain) delay2 += 30;
+        return delay2 + Math.random() * 50;
       }
       /**
        * Generate mock search results
@@ -72935,6 +73437,592 @@ var init_gpu_command = __esm({
     gpu_command_default = GPUCommand;
   }
 });
+function renderFeatureComparison() {
+  const lines = [];
+  const COLS = {
+    feature: 28,
+    free: 9,
+    starter: 15,
+    pro: 20,
+    ultra: 20
+  };
+  const stripAnsi2 = (s2) => s2.replace(/\x1B\[[0-9;]*m/g, "");
+  const padAnsi = (s2, width) => {
+    const len = stripAnsi2(s2).length;
+    return s2 + " ".repeat(Math.max(0, width - len));
+  };
+  lines.push("");
+  lines.push(chalk14__default.default.bold.white("\u{1F4CA} Plan Comparison"));
+  lines.push("");
+  lines.push(chalk14__default.default.gray("\u2500".repeat(60)));
+  lines.push("");
+  lines.push(
+    "  " + padAnsi(chalk14__default.default.gray.bold("Feature"), COLS.feature) + padAnsi(chalk14__default.default.bold("FREE"), COLS.free) + " " + padAnsi(chalk14__default.default.blue.bold("STARTER"), COLS.starter) + " " + padAnsi(chalk14__default.default.yellow.bold("PRO"), COLS.pro) + " " + padAnsi(chalk14__default.default.magenta.bold("ULTRA"), COLS.ultra)
+  );
+  lines.push("");
+  const features = [
+    // LP-aligned buckets
+    ["Code Generation/month", "40", "300", "1,200", "5,000"],
+    ["File Analysis/month", "5", "50", "200", "500"],
+    ["AI Models", "3 models", "4 models", "6 models", "12 models"],
+    ["Support", "Community", "Community", "Community", "Priority"]
+  ];
+  for (const [feature, free, starter, pro, ultra] of features) {
+    const line = "  " + padAnsi(feature, COLS.feature) + padAnsi(formatValue(free), COLS.free) + " " + padAnsi(formatValue(starter, "blue"), COLS.starter) + " " + padAnsi(formatValue(pro, "yellow"), COLS.pro) + " " + padAnsi(formatValue(ultra, "magenta"), COLS.ultra);
+    lines.push(line);
+  }
+  lines.push("");
+  lines.push(chalk14__default.default.gray("\u2500".repeat(60)));
+  lines.push("");
+  lines.push(chalk14__default.default.cyan("  \u{1F48E} Upgrade: /upgrade"));
+  lines.push("");
+  return lines.join("\n");
+}
+function formatValue(value, color) {
+  if (value === "\u274C") return chalk14__default.default.red(value);
+  if (value === "\u2705") return chalk14__default.default.green(value);
+  if (value === "Unlimited") {
+    return color === "magenta" ? chalk14__default.default.magenta.bold(value) : chalk14__default.default.bold(value);
+  }
+  switch (color) {
+    case "blue":
+      return chalk14__default.default.blue(value);
+    case "yellow":
+      return chalk14__default.default.yellow(value);
+    case "magenta":
+      return chalk14__default.default.magenta(value);
+    default:
+      return chalk14__default.default.white(value);
+  }
+}
+var init_plan_aware_ui = __esm({
+  "src/ui/components/plan-aware-ui.ts"() {
+  }
+});
+
+// src/slash-commands/categories/system/upgrade.command.ts
+var upgrade_command_exports = {};
+__export(upgrade_command_exports, {
+  UpgradeCommand: () => UpgradeCommand,
+  meta: () => meta26
+});
+var UpgradeCommand, meta26;
+var init_upgrade_command = __esm({
+  "src/slash-commands/categories/system/upgrade.command.ts"() {
+    init_base_command();
+    init_plan_aware_ui();
+    init_subscription_manager();
+    UpgradeCommand = class extends BaseCommand {
+      name = "upgrade";
+      description = "Upgrade your subscription plan";
+      category = "system";
+      aliases = ["pro", "ultra", "premium", "subscribe"];
+      async execute(args2, context2) {
+        Array.isArray(args2?.raw) ? args2.raw : [];
+        const positional = args2?.parsed?.positional;
+        const firstPositional = Array.isArray(positional) && positional.length > 0 ? positional[0] : void 0;
+        const planOpt = args2?.options?.plan;
+        const compareFlag = Boolean(args2?.flags?.compare);
+        const plan = (planOpt || firstPositional)?.trim();
+        const contextPlan = String(context2?.user?.plan || "").toUpperCase();
+        const mappedFromContext = this.mapContextPlanToInternal(contextPlan);
+        let currentPlan = mappedFromContext || await getUserPlan();
+        if (compareFlag) {
+          return {
+            success: true,
+            message: renderFeatureComparison(),
+            requiresInput: false,
+            autoRetry: false
+          };
+        }
+        if (!plan) {
+          return this.showInteractiveUpgrade(currentPlan, contextPlan);
+        }
+        let isAuthenticated = Boolean(context2?.user);
+        try {
+          if (!isAuthenticated) {
+            const { cliAuth: cliAuth2 } = await Promise.resolve().then(() => (init_CLIAuthService(), CLIAuthService_exports));
+            isAuthenticated = await cliAuth2.getAuthClient().isAuthenticated();
+          }
+        } catch {
+        }
+        if (!isAuthenticated) {
+          return {
+            success: false,
+            message: "\u{1F510} Authentication required \xB7 Run: /login",
+            requiresInput: false,
+            autoRetry: false
+          };
+        }
+        const normalizedPlan = plan.trim().toLowerCase();
+        if (!["starter", "pro", "ultra"].includes(normalizedPlan)) {
+          return {
+            success: false,
+            message: `Invalid plan: ${plan}. Choose 'starter', 'pro' or 'ultra'.`,
+            requiresInput: false,
+            autoRetry: false
+          };
+        }
+        return this.processUpgrade(currentPlan, normalizedPlan, contextPlan, isAuthenticated, context2);
+      }
+      mapContextPlanToInternal(contextPlanUpper) {
+        const code = contextPlanUpper.replace(/[-_](ANNUAL|MONTHLY|YEARLY)$/i, "").toUpperCase();
+        if (code.includes("ENTERPRISE")) return "ultra";
+        if (code.includes("ULTRA")) return "ultra";
+        if (code.includes("PRO")) return "pro";
+        if (code.includes("STARTER")) return "starter";
+        if (code.includes("FREE")) return "free";
+        return void 0;
+      }
+      async showInteractiveUpgrade(currentPlan, contextPlanUpper) {
+        const output3 = [];
+        output3.push("");
+        output3.push(chalk14__default.default.bold.cyan("\u{1F48E} Upgrade Your Plan"));
+        output3.push("");
+        output3.push(chalk14__default.default.gray("Current Plan: ") + this.getCurrentPlanLabel(currentPlan, contextPlanUpper));
+        output3.push("");
+        output3.push(chalk14__default.default.gray("\u2500".repeat(60)));
+        output3.push("");
+        if (currentPlan === "free") {
+          output3.push(chalk14__default.default.bold.white("\u{1F539} STARTER - $20/month"));
+          output3.push(chalk14__default.default.gray("For individual developers"));
+          output3.push("");
+          output3.push("  \u2705 Advanced AI Chat");
+          output3.push("  \u2705 Code Generation (300/month)");
+          output3.push("  \u2705 50 file analysis/month");
+          output3.push("  \u2705 4 AI models");
+          output3.push("  \u2705 Community support");
+          output3.push("");
+          output3.push(chalk14__default.default.cyan("  Upgrade: /upgrade starter"));
+          output3.push("");
+          output3.push(chalk14__default.default.gray("\u2500".repeat(60)));
+          output3.push("");
+          output3.push(chalk14__default.default.bold.yellow("\u{1F31F} PRO - $39/month"));
+          output3.push(chalk14__default.default.gray("For serious developers"));
+          output3.push("");
+          output3.push("  \u2705 Pro AI Chat");
+          output3.push("  \u2705 Advanced Code Generation (1,200/month)");
+          output3.push("  \u2705 200 file analysis/month");
+          output3.push("  \u2705 6 AI models");
+          output3.push("  \u2705 Community support");
+          output3.push("  \u2705 API Access");
+          output3.push("");
+          output3.push(chalk14__default.default.cyan("  Upgrade: /upgrade pro"));
+          output3.push("");
+          output3.push(chalk14__default.default.gray("\u2500".repeat(60)));
+          output3.push("");
+          output3.push(chalk14__default.default.bold.magenta("\u{1F680} ULTRA - $99/month"));
+          output3.push(chalk14__default.default.gray("For power users and teams"));
+          output3.push("");
+          output3.push("  \u2705 Executive AI Chat");
+          output3.push("  \u2705 Professional Code Generation (5,000/month)");
+          output3.push("  \u2705 500 file analysis/month");
+          output3.push("  \u2705 12 AI models");
+          output3.push("  \u2705 Priority support");
+          output3.push("  \u2705 API Access");
+          output3.push("");
+          output3.push(chalk14__default.default.cyan("  Upgrade: /upgrade ultra"));
+        } else if (currentPlan === "starter") {
+          output3.push(chalk14__default.default.bold.yellow("\u{1F31F} Upgrade to PRO - $39/month"));
+          output3.push("");
+          output3.push("  \u2705 Pro AI Chat");
+          output3.push("  \u2705 Advanced Code Generation (1,200/month)");
+          output3.push("  \u2705 200 file analysis/month");
+          output3.push("  \u2705 6 AI models");
+          output3.push("  \u2705 Community support");
+          output3.push("  \u2705 API Access");
+          output3.push("");
+          output3.push(chalk14__default.default.cyan("  Upgrade: /upgrade pro"));
+          output3.push("");
+          output3.push(chalk14__default.default.gray("\u2500".repeat(60)));
+          output3.push("");
+          output3.push(chalk14__default.default.bold.magenta("\u{1F680} Upgrade to ULTRA - $99/month"));
+          output3.push("");
+          output3.push("  \u2705 Executive AI Chat");
+          output3.push("  \u2705 Professional Code Generation (5,000/month)");
+          output3.push("  \u2705 500 file analysis/month");
+          output3.push("  \u2705 12 AI models");
+          output3.push("  \u2705 Priority support");
+          output3.push("  \u2705 API Access");
+          output3.push("");
+          output3.push(chalk14__default.default.cyan("  Upgrade: /upgrade ultra"));
+        } else if (currentPlan === "pro") {
+          output3.push(chalk14__default.default.bold.magenta("\u{1F680} Upgrade to ULTRA - $99/month"));
+          output3.push("");
+          output3.push("  \u2705 Executive AI Chat");
+          output3.push("  \u2705 Professional Code Generation (5,000/month)");
+          output3.push("  \u2705 500 file analysis/month");
+          output3.push("  \u2705 12 AI models + Local LLM");
+          output3.push("  \u2705 Priority support");
+          output3.push("");
+          output3.push(chalk14__default.default.cyan("  Upgrade: /upgrade ultra"));
+        } else {
+          output3.push(chalk14__default.default.green(`\u2728 You have the ${this.getTopTierLabel(contextPlanUpper)} plan!`));
+          output3.push("");
+          output3.push("You already have access to all features:");
+          output3.push("  \u2022 Maximum rate limits");
+          output3.push("  \u2022 All premium features");
+          output3.push("  \u2022 Priority support");
+        }
+        output3.push("");
+        output3.push(chalk14__default.default.gray("\u2500".repeat(60)));
+        output3.push("");
+        output3.push(chalk14__default.default.gray("Compare all plans: /upgrade --compare"));
+        output3.push("");
+        return {
+          success: true,
+          message: output3.join("\n"),
+          requiresInput: false,
+          autoRetry: false
+        };
+      }
+      async processUpgrade(currentPlan, targetPlan, contextPlanUpper, isAuthenticated, context2) {
+        const output3 = [];
+        const planHierarchy = {
+          free: 0,
+          starter: 1,
+          pro: 2,
+          ultra: 3
+        };
+        if (planHierarchy[targetPlan] <= planHierarchy[currentPlan]) {
+          output3.push("");
+          output3.push(chalk14__default.default.yellow("\u26A0\uFE0F  Invalid Upgrade"));
+          output3.push("");
+          output3.push(`You already have the ${this.getCurrentPlanLabel(currentPlan, contextPlanUpper)} plan.`);
+          if (currentPlan === "ultra" || String(contextPlanUpper || "").toUpperCase() === "ENTERPRISE") {
+            output3.push("You have access to all features!");
+          } else {
+            output3.push(`Consider upgrading to ${targetPlan === "pro" ? "ULTRA" : "a higher plan"} for more features.`);
+          }
+          output3.push("");
+          return {
+            success: true,
+            message: output3.join("\n"),
+            requiresInput: false,
+            autoRetry: false
+          };
+        }
+        output3.push("");
+        output3.push(chalk14__default.default.cyan("\u{1F504} Processing upgrade..."));
+        output3.push("");
+        output3.push(`From: ${this.getPlanBadge(currentPlan)}`);
+        output3.push(`To: ${this.getPlanBadge(targetPlan)}`);
+        output3.push("");
+        output3.push(chalk14__default.default.gray("Opening browser for billing..."));
+        output3.push("");
+        let upgraded = false;
+        let changedTo = null;
+        try {
+          const base = process.env.MARIA_API_URL || "https://maria-code.ai";
+          const startCliReturnServer = async () => {
+            const callbackPort = 65434;
+            const callbackPath = "/cli-return";
+            const http4 = await import('http');
+            return new Promise((resolve19) => {
+              let finished = false;
+              const server = http4.createServer(async (req, res) => {
+                try {
+                  const method = (req.method || "GET").toUpperCase();
+                  let status;
+                  let plan;
+                  const urlStr = `http://localhost${req.url || ""}`;
+                  const u = new URL(urlStr);
+                  if (u.pathname === callbackPath) {
+                    status = u.searchParams.get("status") || void 0;
+                    plan = u.searchParams.get("plan") || void 0;
+                    if (method === "POST") {
+                      const chunks = [];
+                      await new Promise((r2) => {
+                        req.on("data", (c) => {
+                          if (chunks.join("").length < 8192) chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(String(c)));
+                        });
+                        req.on("end", () => r2());
+                      });
+                      const body = Buffer.concat(chunks).toString("utf8");
+                      try {
+                        const params2 = new URLSearchParams(body);
+                        status = params2.get("status") || status;
+                        plan = params2.get("plan") || plan;
+                      } catch {
+                      }
+                    }
+                    if (process.env.MARIA_DEBUG === "1") {
+                      try {
+                        console.error("[MARIA DEBUG] CLI return inbound", { method, status, plan });
+                      } catch {
+                      }
+                    }
+                    res.writeHead(200, { "Content-Type": "text/html" });
+                    res.end('<html><body style="font-family:system-ui;padding:24px;text-align:center">OK. You can close this window.</body></html>');
+                    if (!finished && status === "success") {
+                      finished = true;
+                      setTimeout(() => {
+                        try {
+                          server.close();
+                        } catch {
+                        }
+                        resolve19({ status, plan });
+                      }, 10);
+                    }
+                    return;
+                  }
+                } catch {
+                }
+                res.statusCode = 404;
+                res.end("");
+              });
+              const timer = setTimeout(() => {
+                if (!finished) {
+                  finished = true;
+                  try {
+                    server.close();
+                  } catch {
+                  }
+                  resolve19(null);
+                }
+              }, 18e4);
+              server.listen(callbackPort, "127.0.0.1", () => {
+                if (process.env.MARIA_DEBUG === "1") {
+                  try {
+                    console.error("[MARIA DEBUG] CLI return server listening", { port: callbackPort, path: callbackPath });
+                  } catch {
+                  }
+                }
+              });
+              server.on("close", () => {
+                clearTimeout(timer);
+              });
+            });
+          };
+          const cliReturnUrl = `http://localhost:65434/cli-return`;
+          const targetUrl = `${base}/manage?upgrade=${encodeURIComponent(targetPlan)}&auto=1&cliReturn=${encodeURIComponent(cliReturnUrl)}`;
+          const { openUrl: openUrl2 } = await Promise.resolve().then(() => (init_open_url(), open_url_exports));
+          if (process.env.MARIA_DEBUG === "1") {
+            console.error("[MARIA DEBUG] Open manage URL", { url: targetUrl });
+          }
+          const cliReturnPromise = startCliReturnServer();
+          await openUrl2(targetUrl);
+          try {
+            const cb = await cliReturnPromise;
+            if (cb && (cb.status === "success" || cb.status === "scheduled")) {
+              const p = String(cb.plan || "").toLowerCase();
+              if (p === "starter" || p === "pro" || p === "ultra") {
+                if (cb.status === "success") {
+                  changedTo = p;
+                  upgraded = true;
+                } else {
+                  changedTo = p;
+                }
+                if (process.env.MARIA_DEBUG === "1") {
+                  try {
+                    console.error("[MARIA DEBUG] LP callback received", { plan: p, status: cb.status });
+                  } catch {
+                  }
+                }
+              }
+            }
+          } catch {
+          }
+          try {
+            const { cliAuth: cliAuth2 } = await Promise.resolve().then(() => (init_CLIAuthService(), CLIAuthService_exports));
+            const { MariaAPIClient: MariaAPIClient2 } = await Promise.resolve().then(() => (init_MariaAPIClient(), MariaAPIClient_exports));
+            const api = new MariaAPIClient2({
+              baseUrl: "https://api.maria-code.ai",
+              timeout: 3e4,
+              retryAttempts: 3
+            }, cliAuth2.getAuthClient());
+            if (!isAuthenticated || upgraded) {
+              if (process.env.MARIA_DEBUG === "1") {
+                console.error("[MARIA DEBUG] Skip plan polling (no context.user)");
+              }
+              throw new Error("SKIP_POLLING_UNAUTHENTICATED");
+            }
+            const normalize3 = (v) => String(v).toLowerCase().replace(/-annual|-monthly|-yearly$/i, "");
+            const targetNorm = normalize3(targetPlan);
+            const initialNorm = normalize3(currentPlan);
+            const start = Date.now();
+            const timeoutMs = 6e5;
+            const intervalMs = 3e3;
+            while (Date.now() - start < timeoutMs) {
+              await new Promise((r2) => setTimeout(r2, intervalMs));
+              try {
+                const usage = await api.getUsage();
+                const code = String(usage?.planCode || usage?.planName || "").toLowerCase();
+                const norm = normalize3(code);
+                if (process.env.MARIA_DEBUG === "1") {
+                  try {
+                    console.error("[MARIA DEBUG] Poll tick", { endpoint: "GET /api/v1/usage", planCode: usage?.planCode, planName: usage?.planName, norm, initialNorm, targetNorm });
+                  } catch {
+                  }
+                }
+                if (norm !== initialNorm) {
+                  if (norm === "starter" || norm === "pro" || norm === "ultra") {
+                    changedTo = norm;
+                  } else {
+                    if (norm.includes("enterprise")) changedTo = "ultra";
+                  }
+                  if (changedTo) {
+                    upgraded = true;
+                    if (process.env.MARIA_DEBUG === "1") {
+                      try {
+                        console.error("[MARIA DEBUG] Plan change detected", { changedTo });
+                      } catch {
+                      }
+                    }
+                    break;
+                  }
+                }
+              } catch (pollErr) {
+                if (process.env.MARIA_DEBUG === "1") {
+                  const e2 = pollErr;
+                  try {
+                    console.error("[MARIA DEBUG] Plan poll failed", { error: String(e2?.message || e2), stack: e2?.stack, name: e2?.name });
+                  } catch {
+                  }
+                }
+                const msg = String(pollErr?.message || pollErr);
+                if (msg.includes("Authentication required")) {
+                  if (process.env.MARIA_DEBUG === "1") {
+                    try {
+                      console.error("[MARIA DEBUG] Stop polling due to auth error");
+                    } catch {
+                    }
+                  }
+                  break;
+                }
+              }
+            }
+          } catch (pollSetupErr) {
+            const msg = String(pollSetupErr?.message || pollSetupErr);
+            if (process.env.MARIA_DEBUG === "1" && msg !== "SKIP_POLLING_UNAUTHENTICATED") {
+              console.error("[MARIA DEBUG] Plan polling setup failed", { error: msg });
+            }
+          }
+        } catch (e2) {
+          if (process.env.MARIA_DEBUG === "1") {
+            console.error("[MARIA DEBUG] Failed to open manage URL", { error: String(e2?.message || e2) });
+          }
+          upgraded = false;
+        }
+        if (upgraded && changedTo) {
+          output3.push(chalk14__default.default.green("\u2705 Upgrade Successful!"));
+          output3.push("");
+          output3.push(`Welcome to ${this.getPlanBadge(changedTo)}!`);
+          output3.push("");
+          const planToDescribe = changedTo;
+          if (planToDescribe === "starter") {
+            output3.push("You now have access to:");
+            output3.push("  \u2022 Advanced AI Chat");
+            output3.push("  \u2022 Code Generation (300/month)");
+            output3.push("  \u2022 50 file analysis/month");
+            output3.push("  \u2022 4 AI models");
+            output3.push("  \u2022 Community support");
+          } else if (planToDescribe === "pro") {
+            output3.push("You now have access to:");
+            output3.push("  \u2022 Pro AI Chat");
+            output3.push("  \u2022 Advanced Code Generation (1,200/month)");
+            output3.push("  \u2022 200 file analysis/month");
+            output3.push("  \u2022 6 AI models");
+            output3.push("  \u2022 Community support");
+            output3.push("  \u2022 API Access");
+          } else if (planToDescribe === "ultra") {
+            output3.push("You now have access to:");
+            output3.push("  \u2022 Executive AI Chat");
+            output3.push("  \u2022 Professional Code Generation (5,000/month)");
+            output3.push("  \u2022 500 file analysis/month");
+            output3.push("  \u2022 12 AI models");
+            output3.push("  \u2022 Priority support");
+            output3.push("  \u2022 API Access");
+          }
+          output3.push("");
+          output3.push(chalk14__default.default.cyan("Try your new features (after billing completes):"));
+          output3.push('  /code "Refactor module"');
+          output3.push('  /image "logo in matrix style"');
+          output3.push('  /video "product teaser"');
+          output3.push("");
+        } else {
+          output3.push(chalk14__default.default.yellow("\u23F3 Billing in progress"));
+          output3.push("");
+          output3.push("The billing portal or checkout was opened in your browser.");
+          output3.push("We did not detect a plan change yet. Complete the process and run /whoami to verify.");
+        }
+        try {
+          const { WhoAmICommand: WhoAmICommand2 } = await Promise.resolve().then(() => (init_WhoAmICommand(), WhoAmICommand_exports));
+          const whoami = new WhoAmICommand2();
+          const who = await whoami.execute({}, context2);
+          if (who?.message) {
+            output3.push("");
+            output3.push(chalk14__default.default.gray("\u2500".repeat(60)));
+            output3.push("");
+            output3.push(chalk14__default.default.cyan("Current account status"));
+            output3.push(who.message);
+          }
+        } catch {
+        }
+        return {
+          success: upgraded,
+          message: output3.join("\n"),
+          requiresInput: false,
+          autoRetry: false
+        };
+      }
+      getPlanBadge(plan) {
+        const badges = {
+          free: chalk14__default.default.gray("[FREE]"),
+          starter: chalk14__default.default.bgBlue.black(" STARTER "),
+          pro: chalk14__default.default.bgYellow.black(" PRO "),
+          ultra: chalk14__default.default.bgMagenta.white(" ULTRA ")
+        };
+        return badges[plan];
+      }
+      getCurrentPlanLabel(plan, contextPlanUpper) {
+        try {
+          if (String(contextPlanUpper || "").toUpperCase() === "ENTERPRISE") {
+            return chalk14__default.default.bgMagenta.white(" ENTERPRISE ");
+          }
+          const envPlan = String(process.env.MARIA_PLAN || "").toUpperCase();
+          if (envPlan === "ENTERPRISE") return chalk14__default.default.bgMagenta.white(" ENTERPRISE ");
+        } catch {
+        }
+        return this.getPlanBadge(plan);
+      }
+      getTopTierLabel(contextPlanUpper) {
+        try {
+          if (String(contextPlanUpper || "").toUpperCase() === "ENTERPRISE") {
+            return "ENTERPRISE";
+          }
+          const envPlan = String(process.env.MARIA_PLAN || "").toUpperCase();
+          if (envPlan === "ENTERPRISE") return "ENTERPRISE";
+        } catch {
+        }
+        return "ULTRA";
+      }
+      async handleError(error2) {
+        return {
+          success: false,
+          message: `Failed to process upgrade: ${error2.message}`,
+          requiresInput: false,
+          autoRetry: false
+        };
+      }
+    };
+    meta26 = {
+      name: "upgrade",
+      category: "system",
+      description: "Upgrade your subscription plan",
+      aliases: ["pro", "ultra", "premium", "subscribe"],
+      usage: "/upgrade [starter|pro|ultra] [--compare]",
+      examples: [
+        "/upgrade",
+        "/upgrade starter",
+        "/upgrade pro",
+        "/upgrade ultra",
+        "/upgrade --compare"
+      ],
+      deps: []
+    };
+  }
+});
 var CriteriaManager;
 var init_CriteriaManager = __esm({
   "src/services/evaluation/CriteriaManager.ts"() {
@@ -73446,9 +74534,9 @@ var evaluate_command_exports = {};
 __export(evaluate_command_exports, {
   EvaluateCommand: () => EvaluateCommand,
   default: () => evaluate_command_default,
-  meta: () => meta26
+  meta: () => meta27
 });
-var EvaluateCommand, meta26, evaluate_command_default;
+var EvaluateCommand, meta27, evaluate_command_default;
 var init_evaluate_command = __esm({
   "src/slash-commands/categories/evaluation/evaluate.command.ts"() {
     init_base_command();
@@ -74174,7 +75262,7 @@ ${content}` : content;
         return { success: true };
       }
     };
-    meta26 = {
+    meta27 = {
       name: "evaluate",
       category: "evaluation",
       description: "A/B testing and quality evaluation framework",
@@ -74625,15 +75713,22 @@ async function registerBuiltInCommands() {
         initialize: async () => {
         }
       });
-      commandRegistry.register({
-        name: "upgrade",
-        category: "system",
-        description: "Upgrade MARIA",
-        aliases: [],
-        execute: async () => shield2({ message: "\u{1F512} Coming soon", showWaitlist: true }),
-        initialize: async () => {
-        }
-      });
+      try {
+        const { UpgradeCommand: UpgradeCommand2 } = await Promise.resolve().then(() => (init_upgrade_command(), upgrade_command_exports));
+        const upgrade = new UpgradeCommand2();
+        if (upgrade.initialize) await upgrade.initialize();
+        commandRegistry.register(upgrade);
+      } catch {
+        commandRegistry.register({
+          name: "upgrade",
+          category: "system",
+          description: "Upgrade your subscription plan",
+          aliases: ["pro", "ultra", "premium", "subscribe"],
+          execute: async () => shield2({ message: "\u{1F512} Coming soon", showWaitlist: true }),
+          initialize: async () => {
+          }
+        });
+      }
     } catch (error2) {
       console.error("Failed to register system _commands:", error2);
     }
@@ -77325,13 +78420,13 @@ ${options.map((opt, i2) => `${i2 + 1}) ${opt}`).join("\n")}`;
         const lines = response.split("\n");
         for (let i2 = 0; i2 < lines.length; i2++) {
           callback(lines[i2]);
-          let delay = 40;
+          let delay2 = 40;
           const line = lines[i2];
-          if (line.trim().length === 0) delay = 20;
-          else if (line.includes("```")) delay = 60;
-          else if (/[.!?]$/.test(line)) delay = 80;
+          if (line.trim().length === 0) delay2 = 20;
+          else if (line.includes("```")) delay2 = 60;
+          else if (/[.!?]$/.test(line)) delay2 = 80;
           if (i2 < lines.length - 1)
-            await new Promise((r2) => setTimeout(r2, delay));
+            await new Promise((r2) => setTimeout(r2, delay2));
         }
       }
     };
@@ -78130,8 +79225,8 @@ async function runServerMode() {
       console.error(chalk14__default.default.white("Searched dirs: " + candidateDirs.join(" | ")));
       process.exit(1);
     }
-    const { spawn: spawn4 } = await import('child_process');
-    const serverProcess = spawn4("node", [serverPath], {
+    const { spawn: spawn5 } = await import('child_process');
+    const serverProcess = spawn5("node", [serverPath], {
       stdio: "inherit",
       env: process.env,
       cwd: path12__namespace.dirname(serverPath)