@bonginkan/maria 4.3.9 → 4.3.10

package/dist/bin/maria.cjs

@@ -2,7 +2,7 @@
 'use strict';
 
 var fs22 = require('fs');
-var path54 = require('path');
+var path55 = require('path');
 var chalk36 = require('chalk');
 var os16 = require('os');
 var Stream = require('stream');
@@ -55,7 +55,7 @@ function _interopNamespace(e) {
 }
 
 var fs22__namespace = /*#__PURE__*/_interopNamespace(fs22);
-var path54__namespace = /*#__PURE__*/_interopNamespace(path54);
+var path55__namespace = /*#__PURE__*/_interopNamespace(path55);
 var chalk36__default = /*#__PURE__*/_interopDefault(chalk36);
 var os16__namespace = /*#__PURE__*/_interopNamespace(os16);
 var Stream__default = /*#__PURE__*/_interopDefault(Stream);
@@ -207,25 +207,25 @@ function getPackageJson() {
   try {
     const possiblePaths = [
       // When running from built dist/
-      path54.join(__dirname, "../../package.json"),
+      path55.join(__dirname, "../../package.json"),
       // When running from source
-      path54.join(__dirname, "../../../package.json"),
+      path55.join(__dirname, "../../../package.json"),
       // Current working directory
-      path54.join(process.cwd(), "package.json"),
+      path55.join(process.cwd(), "package.json"),
       // One level up from current working directory
-      path54.join(process.cwd(), "../package.json"),
+      path55.join(process.cwd(), "../package.json"),
       // For globally installed packages
-      path54.join(__dirname, "../../../../package.json"),
-      path54.join(__dirname, "../../../../../package.json"),
+      path55.join(__dirname, "../../../../package.json"),
+      path55.join(__dirname, "../../../../../package.json"),
       // npm global install locations
       "/usr/local/lib/node_modules/@bonginkan/maria/package.json",
       "/usr/lib/node_modules/@bonginkan/maria/package.json",
       // User home npm global
-      path54.join(
+      path55.join(
         process.env.HOME || "",
         ".npm-global/lib/node_modules/@bonginkan/maria/package.json"
       ),
-      path54.join(
+      path55.join(
         process.env.HOME || "",
         ".nvm/versions/node",
         process.version,
@@ -233,13 +233,13 @@ function getPackageJson() {
       )
     ];
     let packageJsonPath = null;
-    for (const path55 of possiblePaths) {
-      if (fs22.existsSync(path55)) {
+    for (const path56 of possiblePaths) {
+      if (fs22.existsSync(path56)) {
         try {
-          const content = fs22.readFileSync(path55, "utf-8");
+          const content = fs22.readFileSync(path56, "utf-8");
           const parsed = JSON.parse(content);
           if (parsed.name === "@bonginkan/maria") {
-            packageJsonPath = path55;
+            packageJsonPath = path56;
             break;
           }
         } catch {
@@ -508,8 +508,8 @@ var USE_LEGACY_PROVIDERS2, DEFAULT_PROVIDER2, DEFAULT_MODEL2;
 var init_config = __esm({
   "src/providers/config.ts"() {
     USE_LEGACY_PROVIDERS2 = false;
-    DEFAULT_PROVIDER2 = process.env.DEFAULT_PROVIDER || "openai";
-    DEFAULT_MODEL2 = process.env.OPENAI_MODEL || process.env.MARIA_DEFAULT_MODEL || "gpt-5-mini";
+    DEFAULT_PROVIDER2 = process.env.DEFAULT_PROVIDER || "google";
+    DEFAULT_MODEL2 = process.env.MARIA_DEFAULT_MODEL || process.env.OPENAI_MODEL || "gemini-2.5-flash";
   }
 });
 
@@ -5312,22 +5312,22 @@ var init_from = __esm({
     init_file();
     init_fetch_blob();
     ({ stat } = fs22.promises);
-    blobFromSync = (path55, type) => fromBlob(fs22.statSync(path55), path55, type);
-    blobFrom = (path55, type) => stat(path55).then((stat13) => fromBlob(stat13, path55, type));
-    fileFrom = (path55, type) => stat(path55).then((stat13) => fromFile(stat13, path55, type));
-    fileFromSync = (path55, type) => fromFile(fs22.statSync(path55), path55, type);
-    fromBlob = (stat13, path55, type = "") => new fetch_blob_default([new BlobDataItem({
-      path: path55,
+    blobFromSync = (path56, type) => fromBlob(fs22.statSync(path56), path56, type);
+    blobFrom = (path56, type) => stat(path56).then((stat13) => fromBlob(stat13, path56, type));
+    fileFrom = (path56, type) => stat(path56).then((stat13) => fromFile(stat13, path56, type));
+    fileFromSync = (path56, type) => fromFile(fs22.statSync(path56), path56, type);
+    fromBlob = (stat13, path56, type = "") => new fetch_blob_default([new BlobDataItem({
+      path: path56,
       size: stat13.size,
       lastModified: stat13.mtimeMs,
       start: 0
     })], { type });
-    fromFile = (stat13, path55, type = "") => new file_default([new BlobDataItem({
-      path: path55,
+    fromFile = (stat13, path56, type = "") => new file_default([new BlobDataItem({
+      path: path56,
       size: stat13.size,
       lastModified: stat13.mtimeMs,
       start: 0
-    })], path54.basename(path55), { type, lastModified: stat13.mtimeMs });
+    })], path55.basename(path56), { type, lastModified: stat13.mtimeMs });
     BlobDataItem = class _BlobDataItem {
       #path;
       #start;
@@ -9565,12 +9565,12 @@ ${this.toYamlLike(value, indent + 1)}`;
       }
       static async loadFromFile(configPath) {
         const { importNodeBuiltin: importNodeBuiltin2 } = await Promise.resolve().then(() => (init_import_helper(), import_helper_exports));
-        const fs45 = await importNodeBuiltin2("fs");
+        const fs46 = await importNodeBuiltin2("fs");
         const _path = await importNodeBuiltin2("_path");
         const os24 = await importNodeBuiltin2("os");
         const targetPath = configPath || _path.join(os24.homedir(), ".maria", "config.json");
         try {
-          const data = await fs45.promises.readFile(targetPath, "utf-8");
+          const data = await fs46.promises.readFile(targetPath, "utf-8");
           return JSON.parse(data);
         } catch (innerError) {
           if (innerError?.code === "ENOENT") {
@@ -9584,25 +9584,25 @@ ${this.toYamlLike(value, indent + 1)}`;
       }
       async save(configPath, options) {
         const { importNodeBuiltin: importNodeBuiltin2 } = await Promise.resolve().then(() => (init_import_helper(), import_helper_exports));
-        const fs45 = await importNodeBuiltin2("fs");
+        const fs46 = await importNodeBuiltin2("fs");
         const _path = await importNodeBuiltin2("_path");
         const os24 = await importNodeBuiltin2("os");
         const targetPath = configPath || _path.join(os24.homedir(), ".maria", "config.json");
         try {
           if (options?.backup) {
             try {
-              await fs45.promises.access(targetPath);
+              await fs46.promises.access(targetPath);
               const backupPath = `${targetPath}.backup.${Date.now()}`;
-              await fs45.promises.copyFile(targetPath, backupPath);
+              await fs46.promises.copyFile(targetPath, backupPath);
             } catch {
             }
           }
-          await fs45.promises.mkdir(_path.dirname(targetPath), { recursive: true });
+          await fs46.promises.mkdir(_path.dirname(targetPath), { recursive: true });
           const dataToSave = this.getAll({
             maskSensitive: options?.maskSensitive ?? true,
             includeSourceMap: options?.includeSourceMap ?? false
           });
-          await fs45.promises.writeFile(
+          await fs46.promises.writeFile(
             targetPath,
             JSON.stringify(dataToSave, null, 2),
             { mode: 384 }
@@ -9646,12 +9646,12 @@ ${this.toYamlLike(value, indent + 1)}`;
         }
         if (outputPath) {
           const { importNodeBuiltin: importNodeBuiltin2 } = await Promise.resolve().then(() => (init_import_helper(), import_helper_exports));
-          const fs45 = await importNodeBuiltin2("fs");
+          const fs46 = await importNodeBuiltin2("fs");
           const _path = await importNodeBuiltin2(
             "_path"
           );
-          await fs45.promises.mkdir(_path.dirname(outputPath), { recursive: true });
-          await fs45.promises.writeFile(outputPath, content, "utf-8");
+          await fs46.promises.mkdir(_path.dirname(outputPath), { recursive: true });
+          await fs46.promises.writeFile(outputPath, content, "utf-8");
           console.log(`\u2705 Configuration exported to ${outputPath}`);
         }
         return content;
@@ -9960,13 +9960,13 @@ async function loadEnvironmentConfig() {
   }
   try {
     const { importNodeBuiltin: importNodeBuiltin2, safeDynamicImport: safeDynamicImport2 } = await Promise.resolve().then(() => (init_import_helper(), import_helper_exports));
-    const fs45 = await safeDynamicImport2("fs-extra").catch(
+    const fs46 = await safeDynamicImport2("fs-extra").catch(
       () => importNodeBuiltin2("fs")
     );
     const _path = await importNodeBuiltin2("_path");
     const _envPath = _path.join(process.cwd(), ".env.local");
-    if (await fs45.pathExists(_envPath)) {
-      const _envContent = await fs45.readFile(_envPath, "utf-8");
+    if (await fs46.pathExists(_envPath)) {
+      const _envContent = await fs46.readFile(_envPath, "utf-8");
       console.log("Loading environment from:", _envPath);
       environmentLoaded = true;
       const _lines = _envContent.split("\n");
@@ -10032,14 +10032,14 @@ var init_NaturalLanguageProcessor = __esm({
       }
       async process(input3, language = "en") {
         const normalized = this.normalize(input3, language);
-        const tokens = this.tokenize(normalized, language);
-        const stems = this.stem(tokens, language);
+        const tokens2 = this.tokenize(normalized, language);
+        const stems = this.stem(tokens2, language);
         const entities = this.extractEntities(input3);
-        const _keywords = this.extractKeywords(tokens, language);
+        const _keywords = this.extractKeywords(tokens2, language);
         return {
           original: input3,
           normalized,
-          tokens,
+          tokens: tokens2,
           stems,
           entities,
           language,
@@ -10089,7 +10089,7 @@ var init_NaturalLanguageProcessor = __esm({
         return text.split(/\s+/).filter((token) => token.length > 0);
       }
       tokenizeJapanese(text) {
-        const tokens = [];
+        const tokens2 = [];
         const _patterns = [
           /[\u4e00-\u9faf]+/g,
           // Kanji
@@ -10105,24 +10105,24 @@ var init_NaturalLanguageProcessor = __esm({
         _patterns.forEach((pattern) => {
           const _matches = text.match(pattern);
           if (_matches) {
-            tokens.push(..._matches);
+            tokens2.push(..._matches);
           }
         });
-        return tokens;
+        return tokens2;
       }
       tokenizeChinese(text) {
-        const tokens = [];
+        const tokens2 = [];
         for (const char of text) {
           if (/[\u4e00-\u9faf]/.test(char)) {
-            tokens.push(char);
+            tokens2.push(char);
           } else if (/[a-zA-Z0-9]+/.test(char)) {
-            tokens.push(char);
+            tokens2.push(char);
           }
         }
-        return tokens;
+        return tokens2;
       }
       tokenizeKorean(text) {
-        const tokens = [];
+        const tokens2 = [];
         const _patterns = [
           /[\uac00-\ud7af]+/g,
           // Hangul
@@ -10134,16 +10134,16 @@ var init_NaturalLanguageProcessor = __esm({
         _patterns.forEach((pattern) => {
           const _matches = text.match(pattern);
           if (_matches) {
-            tokens.push(..._matches);
+            tokens2.push(..._matches);
           }
         });
-        return tokens;
+        return tokens2;
       }
-      stem(tokens, language) {
+      stem(tokens2, language) {
         if (language !== "en") {
-          return tokens;
+          return tokens2;
         }
-        return tokens.map((token) => {
+        return tokens2.map((token) => {
           let stem = token;
           if (stem.endsWith("ing")) {
             stem = stem.slice(0, -3);
@@ -10239,9 +10239,9 @@ var init_NaturalLanguageProcessor = __esm({
         });
         return entities;
       }
-      extractKeywords(tokens, language) {
+      extractKeywords(tokens2, language) {
         const stopWords = this.stopWords.get(language) ?? /* @__PURE__ */ new Set();
-        const _keywords = tokens.filter((token) => {
+        const _keywords = tokens2.filter((token) => {
           return token.length > 2 && !stopWords.has(token.toLowerCase());
         });
         const frequency = /* @__PURE__ */ new Map();
@@ -19136,11 +19136,11 @@ var init_ConfigService = __esm({
       _saveDebounceTimer = null;
       _isDirty = false;
       constructor(configDir = process.env.MARIA_CONFIG_DIR || "~/.maria") {
-        this._configPath = path54__namespace.join(
+        this._configPath = path55__namespace.join(
           this.expandHome(configDir),
           "session.config.json"
         );
-        this._userConfigPath = path54__namespace.join(
+        this._userConfigPath = path55__namespace.join(
           this.expandHome(configDir),
           "user.config.json"
         );
@@ -19215,8 +19215,8 @@ var init_ConfigService = __esm({
       /**
        * ネストされた設定値の取得
        */
-      getNestedValue(path55) {
-        const keys = path55.split(".");
+      getNestedValue(path56) {
+        const keys = path56.split(".");
         let value = this._config;
         for (const key of keys) {
           if (value && typeof value === "object" && key in value) {
@@ -19246,8 +19246,8 @@ var init_ConfigService = __esm({
       /**
        * ネストされた設定値の更新
        */
-      async setNestedValue(path55, value) {
-        const keys = path55.split(".");
+      async setNestedValue(path56, value) {
+        const keys = path56.split(".");
         const lastKey = keys.pop();
         let target = this._config;
         for (const key of keys) {
@@ -19260,7 +19260,7 @@ var init_ConfigService = __esm({
         target[lastKey] = value;
         this.validateConfig();
         this.emitChange({
-          path: path55,
+          path: path56,
           oldValue,
           newValue: value,
           timestamp: /* @__PURE__ */ new Date()
@@ -19274,7 +19274,7 @@ var init_ConfigService = __esm({
       async save() {
         if (!this._isDirty) return;
         try {
-          const configDir = path54__namespace.dirname(this._userConfigPath);
+          const configDir = path55__namespace.dirname(this._userConfigPath);
           await fsp__namespace.mkdir(configDir, { recursive: true });
           await fsp__namespace.writeFile(
             this._userConfigPath,
@@ -19305,8 +19305,8 @@ var init_ConfigService = __esm({
       setupAutoSave() {
         process.on("exit", () => {
           if (this._isDirty) {
-            const fs45 = __require("fs");
-            fs45.writeFileSync(
+            const fs46 = __require("fs");
+            fs46.writeFileSync(
               this._userConfigPath,
               JSON.stringify(this._config, null, 2),
               "utf-8"
@@ -19317,13 +19317,13 @@ var init_ConfigService = __esm({
       /**
        * 変更リスナーの登録
        */
-      onChange(path55, listener) {
-        if (!this._listeners.has(path55)) {
-          this._listeners.set(path55, []);
+      onChange(path56, listener) {
+        if (!this._listeners.has(path56)) {
+          this._listeners.set(path56, []);
         }
-        this._listeners.get(path55).push(listener);
+        this._listeners.get(path56).push(listener);
         return () => {
-          const listeners = this._listeners.get(path55);
+          const listeners = this._listeners.get(path56);
           if (listeners) {
             const index = listeners.indexOf(listener);
             if (index !== -1) {
@@ -19374,7 +19374,7 @@ var init_ConfigService = __esm({
        */
       expandHome(filePath) {
         if (filePath.startsWith("~/")) {
-          return path54__namespace.join(process.env.HOME || "", filePath.slice(2));
+          return path55__namespace.join(process.env.HOME || "", filePath.slice(2));
         }
         return filePath;
       }
@@ -19812,7 +19812,7 @@ var init_ValidationService = __esm({
         );
         this._schemas.set(
           "filePath",
-          zod.z.string().min(1).max(this._config.maxFilePathLength).refine((path55) => !this.containsPathTraversal(path55), {
+          zod.z.string().min(1).max(this._config.maxFilePathLength).refine((path56) => !this.containsPathTraversal(path56), {
             message: "Path traversal detected"
           })
         );
@@ -19951,11 +19951,11 @@ var init_ValidationService = __esm({
       /**
        * ファイルパス検証
        */
-      validateFilePath(path55) {
+      validateFilePath(path56) {
         try {
           const schema = this._schemas.get("filePath");
-          const result = schema.parse(path55);
-          if (this.isSystemPath(path55)) {
+          const result = schema.parse(path56);
+          if (this.isSystemPath(path56)) {
             return {
               valid: false,
               errors: [
@@ -20101,8 +20101,8 @@ var init_ValidationService = __esm({
       /**
        * パストラバーサルの検出
        */
-      containsPathTraversal(path55) {
-        return /\.\.[/\\]/.test(path55) || path55.includes("..\\") || path55.includes("../");
+      containsPathTraversal(path56) {
+        return /\.\.[/\\]/.test(path56) || path56.includes("..\\") || path56.includes("../");
       }
       /**
        * 危険なコマンドの判定
@@ -20129,7 +20129,7 @@ var init_ValidationService = __esm({
       /**
        * システムパスの判定
        */
-      isSystemPath(path55) {
+      isSystemPath(path56) {
         const systemPaths = [
           "/etc",
           "/sys",
@@ -20143,7 +20143,7 @@ var init_ValidationService = __esm({
           "/sbin"
         ];
         return systemPaths.some(
-          (sysPath) => path55.toLowerCase().startsWith(sysPath.toLowerCase())
+          (sysPath) => path56.toLowerCase().startsWith(sysPath.toLowerCase())
         );
       }
       /**
@@ -25085,10 +25085,10 @@ Run /doctor --fix to automatically fix ${fixableCount} issue(s)`
         const finalize = async (text, data) => {
           if (outputPath) {
             try {
-              const fs45 = await import('fs/promises');
-              const path55 = await import('path');
-              const abs = path55.resolve(outputPath);
-              await fs45.writeFile(abs, text, "utf-8");
+              const fs46 = await import('fs/promises');
+              const path56 = await import('path');
+              const abs = path56.resolve(outputPath);
+              await fs46.writeFile(abs, text, "utf-8");
               const msg = `Saved doctor report to ${abs}`;
               return { ok: true, message: msg, data: { path: abs, bytes: Buffer.byteLength(text, "utf-8") } };
             } catch (e2) {
@@ -25178,10 +25178,10 @@ Run /doctor --fix to automatically fix ${fixableCount} issue(s)`
         const finalize = async (text, data) => {
           if (outputPath) {
             try {
-              const fs45 = await import('fs/promises');
-              const path55 = await import('path');
-              const abs = path55.resolve(outputPath);
-              await fs45.writeFile(abs, text, "utf-8");
+              const fs46 = await import('fs/promises');
+              const path56 = await import('path');
+              const abs = path56.resolve(outputPath);
+              await fs46.writeFile(abs, text, "utf-8");
               const msg = `Saved metrics to ${abs}`;
               return { ok: true, message: msg, data: { path: abs, bytes: Buffer.byteLength(text, "utf-8") } };
             } catch (e2) {
@@ -25564,15 +25564,15 @@ var init_SessionOrchestrator = __esm({
       /**
        * 設定の取得
        */
-      getConfig(path55) {
-        return this._configService?.getNestedValue(path55);
+      getConfig(path56) {
+        return this._configService?.getNestedValue(path56);
       }
       /**
        * 設定の更新
        */
-      async setConfig(path55, value) {
+      async setConfig(path56, value) {
         if (this._configService) {
-          await this._configService.setNestedValue(path55, value);
+          await this._configService.setNestedValue(path56, value);
         }
       }
       /**
@@ -25690,11 +25690,11 @@ var init_interactive_session = __esm({
       getStats() {
         return this.orchestrator.getSessionStats();
       }
-      getConfig(path55) {
-        return this.orchestrator.getConfig(path55);
+      getConfig(path56) {
+        return this.orchestrator.getConfig(path56);
       }
-      async setConfig(path55, value) {
-        await this.orchestrator.setConfig(path55, value);
+      async setConfig(path56, value) {
+        await this.orchestrator.setConfig(path56, value);
       }
     };
   }
@@ -25705,8 +25705,8 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@bonginkan/maria",
-      version: "4.3.9",
-      description: "\u{1F680} MARIA v4.3.9 - 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.",
+      version: "4.3.10",
+      description: "\u{1F680} MARIA v4.3.10 - 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",
@@ -26222,27 +26222,30 @@ var require_package = __commonJS({
   }
 });
 function loadEnvironmentVariables() {
-  const _envPath = path54__namespace.join(process.cwd(), ".env");
+  const _envPath = path55__namespace.join(process.cwd(), ".env");
   if (fs22__namespace.existsSync(_envPath)) {
     const _result = dotenv__namespace.config({ path: _envPath });
     if (_result.error) {
       console.warn("Error loading .env:", _result.error);
     }
   }
-  const _envLocalPath = path54__namespace.join(process.cwd(), ".env.local");
+  const _envLocalPath = path55__namespace.join(process.cwd(), ".env.local");
   if (fs22__namespace.existsSync(_envLocalPath)) {
     const _result = dotenv__namespace.config({ path: _envLocalPath, override: true });
     if (_result.error) {
       console.warn("Error loading .env.local:", _result.error);
     }
   }
-  const _lmstudioEnvPath = path54__namespace.join(process.cwd(), ".env.lmstudio");
+  const _lmstudioEnvPath = path55__namespace.join(process.cwd(), ".env.lmstudio");
   if (fs22__namespace.existsSync(_lmstudioEnvPath)) {
     const _result = dotenv__namespace.config({ path: _lmstudioEnvPath, override: false });
     if (_result.error) {
       console.warn("Error loading .env.lmstudio:", _result.error);
     }
   }
+  if (!process.env.MARIA_API_BASE) process.env.MARIA_API_BASE = "https://api.maria-code.ai";
+  if (!process.env.MARIA_USE_API) process.env.MARIA_USE_API = "1";
+  if (!process.env.MARIA_USE_REMOTE_MEDIA) process.env.MARIA_USE_REMOTE_MEDIA = "1";
 }
 var init_env_loader = __esm({
   "src/utils/env-loader.ts"() {
@@ -26561,11 +26564,11 @@ var init_OAuth2PKCEClient = __esm({
           redirectUri: config2.redirectUri || "http://127.0.0.1:9876/callback",
           authServerUrl: config2.authServerUrl || "https://maria-code.ai"
         };
-        const configDir = path54__namespace.join(os16__namespace.homedir(), ".maria");
+        const configDir = path55__namespace.join(os16__namespace.homedir(), ".maria");
         if (!fs22__namespace.existsSync(configDir)) {
           fs22__namespace.mkdirSync(configDir, { recursive: true });
         }
-        this.tokenStoragePath = path54__namespace.join(configDir, "auth-tokens.json");
+        this.tokenStoragePath = path55__namespace.join(configDir, "auth-tokens.json");
       }
       /**
        * Generate cryptographically secure random string
@@ -26744,13 +26747,13 @@ var init_OAuth2PKCEClient = __esm({
       /**
        * Store tokens securely
        */
-      async storeTokens(tokens) {
+      async storeTokens(tokens2) {
         const storedTokens = {
-          accessToken: tokens.access_token,
-          refreshToken: tokens.refresh_token,
-          idToken: tokens.id_token,
-          expiresAt: Date.now() + tokens.expires_in * 1e3,
-          scopes: tokens.scope?.split(" ") || this.config.scopes,
+          accessToken: tokens2.access_token,
+          refreshToken: tokens2.refresh_token,
+          idToken: tokens2.id_token,
+          expiresAt: Date.now() + tokens2.expires_in * 1e3,
+          scopes: tokens2.scope?.split(" ") || this.config.scopes,
           obtainedAt: Date.now()
         };
         fs22__namespace.writeFileSync(
@@ -26769,16 +26772,16 @@ var init_OAuth2PKCEClient = __esm({
         }
         try {
           const data = fs22__namespace.readFileSync(this.tokenStoragePath, "utf-8");
-          const tokens = JSON.parse(data);
-          if (Date.now() >= tokens.expiresAt) {
-            if (tokens.refreshToken) {
-              const newTokens = await this.refreshAccessToken(tokens.refreshToken);
+          const tokens2 = JSON.parse(data);
+          if (Date.now() >= tokens2.expiresAt) {
+            if (tokens2.refreshToken) {
+              const newTokens = await this.refreshAccessToken(tokens2.refreshToken);
               await this.storeTokens(newTokens);
               return this.loadStoredTokens();
             }
             return null;
           }
-          return tokens;
+          return tokens2;
         } catch (error2) {
           console.error("Failed to load stored tokens:", error2);
           return null;
@@ -26831,8 +26834,8 @@ ${authUrl}
           const code = await codePromise;
           console.log("\u2705 Authorization code received");
           console.log("\u{1F504} Exchanging code for tokens...");
-          const tokens = await this.exchangeCodeForTokens(code);
-          await this.storeTokens(tokens);
+          const tokens2 = await this.exchangeCodeForTokens(code);
+          await this.storeTokens(tokens2);
           console.log("\u2705 Authentication complete! Tokens stored securely.");
           return this.loadStoredTokens();
         } finally {
@@ -26852,15 +26855,15 @@ ${authUrl}
        * Get current access token
        */
       async getAccessToken() {
-        const tokens = await this.loadStoredTokens();
-        return tokens?.accessToken || null;
+        const tokens2 = await this.loadStoredTokens();
+        return tokens2?.accessToken || null;
       }
       /**
        * Check if authenticated
        */
       async isAuthenticated() {
-        const tokens = await this.loadStoredTokens();
-        return tokens !== null;
+        const tokens2 = await this.loadStoredTokens();
+        return tokens2 !== null;
       }
     };
   }
@@ -26911,10 +26914,10 @@ var init_MariaAPIClient = __esm({
             const responseData = await response.json();
             if (!response.ok) {
               if (response.status === 401) {
-                const tokens = await this.authClient.loadStoredTokens();
-                if (tokens?.refreshToken) {
+                const tokens2 = await this.authClient.loadStoredTokens();
+                if (tokens2?.refreshToken) {
                   try {
-                    await this.authClient.refreshAccessToken(tokens.refreshToken);
+                    await this.authClient.refreshAccessToken(tokens2.refreshToken);
                     continue;
                   } catch {
                     throw new Error("Session expired. Please login again.");
@@ -27143,11 +27146,11 @@ var init_CLIAuthService = __esm({
       configPath;
       config;
       constructor(config2) {
-        const configDir = path54__namespace.join(os16__namespace.homedir(), ".maria");
+        const configDir = path55__namespace.join(os16__namespace.homedir(), ".maria");
         if (!fs22__namespace.existsSync(configDir)) {
           fs22__namespace.mkdirSync(configDir, { recursive: true });
         }
-        this.configPath = path54__namespace.join(configDir, "cli-config.json");
+        this.configPath = path55__namespace.join(configDir, "cli-config.json");
         this.config = this.loadConfig(config2);
         this.authClient = new OAuth2PKCEClient({
           authorizationEndpoint: `${this.config.authServerUrl}/oauth/authorize`,
@@ -27250,7 +27253,7 @@ var init_CLIAuthService = __esm({
           }
           console.log("\u{1F4F1} Starting authentication flow...");
           console.log("A browser window will open for you to authenticate.\n");
-          const tokens = await this.authClient.authenticate();
+          const tokens2 = await this.authClient.authenticate();
           this.config.lastLogin = (/* @__PURE__ */ new Date()).toISOString();
           this.saveConfig();
           console.log("\n\u2705 Authentication successful!");
@@ -27469,13 +27472,13 @@ var init_TokenStorage = __esm({
     TokenStorage = class {
       SERVICE_NAME = "maria-cli";
       ACCOUNT_NAME = "default";
-      CONFIG_DIR = path54__namespace.default.join(os16__namespace.default.homedir(), ".maria");
-      TOKEN_FILE = path54__namespace.default.join(this.CONFIG_DIR, "auth-tokens.json");
+      CONFIG_DIR = path55__namespace.default.join(os16__namespace.default.homedir(), ".maria");
+      TOKEN_FILE = path55__namespace.default.join(this.CONFIG_DIR, "auth-tokens.json");
       /**
        * Save tokens securely
        */
-      async save(tokens) {
-        const tokenData = JSON.stringify(tokens);
+      async save(tokens2) {
+        const tokenData = JSON.stringify(tokens2);
         if (keytar) {
           try {
             await keytar.setPassword(this.SERVICE_NAME, this.ACCOUNT_NAME, tokenData);
@@ -27484,7 +27487,7 @@ var init_TokenStorage = __esm({
             console.warn("Keychain storage failed, falling back to encrypted file");
           }
         }
-        await this.saveToFile(tokens);
+        await this.saveToFile(tokens2);
       }
       /**
        * Load tokens securely
@@ -27520,12 +27523,12 @@ var init_TokenStorage = __esm({
       /**
        * Save tokens to encrypted file
        */
-      async saveToFile(tokens) {
+      async saveToFile(tokens2) {
         await fsp__namespace.default.mkdir(this.CONFIG_DIR, { recursive: true });
         const key = await this.getEncryptionKey();
         const iv = crypto6__namespace.default.randomBytes(16);
         const cipher = crypto6__namespace.default.createCipheriv("aes-256-gcm", key, iv);
-        const tokenData = JSON.stringify(tokens);
+        const tokenData = JSON.stringify(tokens2);
         let encrypted = cipher.update(tokenData, "utf8", "hex");
         encrypted += cipher.final("hex");
         const authTag = cipher.getAuthTag();
@@ -27585,9 +27588,9 @@ var init_TokenStorage = __esm({
           const decipher = crypto6__namespace.default.createDecipheriv("aes-256-cbc", keyBuffer, Buffer.alloc(16, 0));
           let decrypted = decipher.update(fileData.data, "hex", "utf8");
           decrypted += decipher.final("utf8");
-          const tokens = JSON.parse(decrypted);
-          await this.saveToFile(tokens);
-          return tokens;
+          const tokens2 = JSON.parse(decrypted);
+          await this.saveToFile(tokens2);
+          return tokens2;
         } catch {
           return null;
         }
@@ -27887,9 +27890,9 @@ var init_AuthenticationManager = __esm({
       async isAuthenticated() {
         await this.ensureInitialized();
         try {
-          const tokens = await this.tokenStorage.load();
-          if (!tokens) return false;
-          if (Date.now() >= tokens.expiresAt + this.CLOCK_SKEW) {
+          const tokens2 = await this.tokenStorage.load();
+          if (!tokens2) return false;
+          if (Date.now() >= tokens2.expiresAt + this.CLOCK_SKEW) {
             return await this.refreshToken();
           }
           return true;
@@ -27914,8 +27917,8 @@ var init_AuthenticationManager = __esm({
       async getCurrentUser() {
         await this.ensureInitialized();
         if (process.env.MARIA_AUTH_MODE === "local") {
-          const tokens2 = await this.tokenStorage.load();
-          if (!tokens2) {
+          const tokens3 = await this.tokenStorage.load();
+          if (!tokens3) {
             throw new AuthenticationRequiredError(ERROR_MESSAGES.AUTH_REQUIRED);
           }
           return {
@@ -27932,15 +27935,15 @@ var init_AuthenticationManager = __esm({
             models: []
           };
         }
-        const tokens = await this.getValidTokens();
-        if (!tokens) {
+        const tokens2 = await this.getValidTokens();
+        if (!tokens2) {
           throw new AuthenticationRequiredError(ERROR_MESSAGES.AUTH_REQUIRED);
         }
         try {
           const response = await fetch(`${this.apiBase}/api/user/profile`, {
             headers: {
-              "Authorization": `Bearer ${tokens.accessToken}`,
-              "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.3.9"}`
+              "Authorization": `Bearer ${tokens2.accessToken}`,
+              "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.3.10"}`
             }
           });
           if (response.status === 401) {
@@ -27975,16 +27978,16 @@ var init_AuthenticationManager = __esm({
           if (process.env.MARIA_AUTH_MODE === "local") {
             return await this.loginWithLocalMock();
           }
-          let tokens;
+          let tokens2;
           const forceDevice = options.device || process.env.MARIA_AUTH_DEVICE_FLOW === "true" || !this.canLaunchBrowser();
           if (forceDevice) {
             if (!options.device) {
               console.warn("PKCE is unavailable in this environment; using device flow.");
             }
-            tokens = await this.loginWithDeviceFlow();
+            tokens2 = await this.loginWithDeviceFlow();
           } else {
             try {
-              tokens = await this.loginWithPKCEFlow();
+              tokens2 = await this.loginWithPKCEFlow();
             } catch (error2) {
               console.error("PKCE flow error:", error2);
               if (error2.message?.includes("ECONNREFUSED") || error2.message?.includes("fetch failed")) {
@@ -28001,12 +28004,12 @@ var init_AuthenticationManager = __esm({
                 throw new Error("Authentication service unavailable. See above for alternatives.");
               }
               console.warn("PKCE flow failed, falling back to device flow");
-              tokens = await this.loginWithDeviceFlow();
+              tokens2 = await this.loginWithDeviceFlow();
             }
           }
-          await this.tokenStorage.save(tokens);
+          await this.tokenStorage.save(tokens2);
           const user = await this.getCurrentUser();
-          return { success: true, user, tokens };
+          return { success: true, user, tokens: tokens2 };
         } catch (error2) {
           console.error("Login failed:", error2);
           return {
@@ -28056,10 +28059,10 @@ var init_AuthenticationManager = __esm({
       async logout(options = {}) {
         await this.ensureInitialized();
         try {
-          const tokens = await this.tokenStorage.load();
-          if (tokens && !options.force) {
+          const tokens2 = await this.tokenStorage.load();
+          if (tokens2 && !options.force) {
             try {
-              await this.revokeTokens(tokens, options.all || false);
+              await this.revokeTokens(tokens2, options.all || false);
             } catch (error2) {
               console.warn("Server token revocation failed:", error2);
             }
@@ -28078,14 +28081,14 @@ var init_AuthenticationManager = __esm({
       async refreshToken() {
         await this.ensureInitialized();
         try {
-          const tokens = await this.tokenStorage.load();
-          if (!tokens?.refreshToken) return false;
+          const tokens2 = await this.tokenStorage.load();
+          if (!tokens2?.refreshToken) return false;
           const response = await fetch(`${this.authBase}/auth/token`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({
               grant_type: "refresh_token",
-              refresh_token: tokens.refreshToken,
+              refresh_token: tokens2.refreshToken,
               client_id: this.clientId
             })
           });
@@ -28094,7 +28097,7 @@ var init_AuthenticationManager = __esm({
           const updatedTokens = {
             idToken: newTokens.id_token,
             accessToken: newTokens.access_token,
-            refreshToken: newTokens.refresh_token || tokens.refreshToken,
+            refreshToken: newTokens.refresh_token || tokens2.refreshToken,
             customToken: newTokens.custom_token,
             expiresAt: Date.now() + newTokens.expires_in * 1e3
           };
@@ -28209,13 +28212,13 @@ var init_AuthenticationManager = __esm({
             if (!finishResponse.ok) {
               throw new Error(`Device flow failed: ${finishResponse.statusText}`);
             }
-            const tokens = await finishResponse.json();
+            const tokens2 = await finishResponse.json();
             return {
-              idToken: tokens.id_token || tokens.access_token || "",
-              accessToken: tokens.access_token || tokens.id_token || "",
-              refreshToken: tokens.refresh_token || "",
-              customToken: tokens.custom_token,
-              expiresAt: Date.now() + (tokens.expires_in ? Number(tokens.expires_in) : 600) * 1e3
+              idToken: tokens2.id_token || tokens2.access_token || "",
+              accessToken: tokens2.access_token || tokens2.id_token || "",
+              refreshToken: tokens2.refresh_token || "",
+              customToken: tokens2.custom_token,
+              expiresAt: Date.now() + (tokens2.expires_in ? Number(tokens2.expires_in) : 600) * 1e3
             };
           }
           throw new Error(ERROR_MESSAGES.LOGIN_TIMEOUT);
@@ -28356,13 +28359,13 @@ var init_AuthenticationManager = __esm({
             console.error("Token exchange failed:", response.status, response.statusText, bodyText);
             throw new Error(`Token exchange failed: ${response.status} ${response.statusText}`);
           }
-          const tokens = await response.json();
+          const tokens2 = await response.json();
           return {
-            idToken: tokens.id_token,
-            accessToken: tokens.access_token,
-            refreshToken: tokens.refresh_token,
-            customToken: tokens.custom_token,
-            expiresAt: Date.now() + tokens.expires_in * 1e3
+            idToken: tokens2.id_token,
+            accessToken: tokens2.access_token,
+            refreshToken: tokens2.refresh_token,
+            customToken: tokens2.custom_token,
+            expiresAt: Date.now() + tokens2.expires_in * 1e3
           };
         } catch (error2) {
           console.error("Token exchange request error:", error2);
@@ -28372,15 +28375,15 @@ var init_AuthenticationManager = __esm({
       /**
        * Revoke tokens on server
        */
-      async revokeTokens(tokens, allDevices) {
+      async revokeTokens(tokens2, allDevices) {
         const response = await fetch(`${this.apiBase}/api/auth/revoke`, {
           method: "POST",
           headers: {
             "Content-Type": "application/json",
-            "Authorization": `Bearer ${tokens.accessToken}`
+            "Authorization": `Bearer ${tokens2.accessToken}`
           },
           body: JSON.stringify({
-            refresh_token: tokens.refreshToken,
+            refresh_token: tokens2.refreshToken,
             all_devices: allDevices
           })
         });
@@ -28392,17 +28395,17 @@ var init_AuthenticationManager = __esm({
        * Get valid tokens (refresh if needed)
        */
       async getValidTokens() {
-        const tokens = await this.tokenStorage.load();
-        if (!tokens) return null;
+        const tokens2 = await this.tokenStorage.load();
+        if (!tokens2) return null;
         const now2 = Date.now();
-        const expiresWithBuffer = tokens.expiresAt - this.REFRESH_THRESHOLD + this.CLOCK_SKEW;
+        const expiresWithBuffer = tokens2.expiresAt - this.REFRESH_THRESHOLD + this.CLOCK_SKEW;
         if (now2 >= expiresWithBuffer) {
           if (await this.refreshToken()) {
             return await this.tokenStorage.load();
           }
           return null;
         }
-        return tokens;
+        return tokens2;
       }
       /**
        * Secure string comparison
@@ -28481,15 +28484,15 @@ function withAuth(fn) {
   return async (...args2) => {
     const testMode = process.env.MARIA_TEST_MODE === "1" || process.env.VITEST === "true" || process.env.NODE_ENV === "test";
     try {
-      const tokens = await authManager.getValidTokens();
-      if (!tokens) {
+      const tokens2 = await authManager.getValidTokens();
+      if (!tokens2) {
         console.log(chalk36__default.default.red("\u{1F510} Authentication required \xB7 Run: maria /login"));
         if (!testMode) process.exit(AUTH_EXIT_CODES.AUTH_REQUIRED);
         return { success: false, message: "AUTH_REQUIRED" };
       }
-      global.MARIA_ID_TOKEN = tokens.idToken;
-      global.MARIA_ACCESS_TOKEN = tokens.accessToken;
-      global.MARIA_SESSION_ID = tokens.sessionId;
+      global.MARIA_ID_TOKEN = tokens2.idToken;
+      global.MARIA_ACCESS_TOKEN = tokens2.accessToken;
+      global.MARIA_SESSION_ID = tokens2.sessionId;
       return await fn(...args2);
     } catch (error2) {
       if (error2.code === "AUTH_REQUIRED") {
@@ -28559,11 +28562,11 @@ function getDeviceId() {
 function getSessionId() {
   return global.MARIA_SESSION_ID;
 }
-async function callApi(path55, init2 = {}) {
+async function callApi(path56, init2 = {}) {
   const apiBase = process.env.MARIA_API_BASE || "http://localhost:3001";
-  const fullUrl = `${apiBase}${path55}`;
-  let tokens = await authManager.getValidTokens();
-  if (!tokens) {
+  const fullUrl = `${apiBase}${path56}`;
+  let tokens2 = await authManager.getValidTokens();
+  if (!tokens2) {
     console.log(chalk36__default.default.red(ERR.AUTH_REQUIRED.msg));
     process.exit(ERR.AUTH_REQUIRED.code);
   }
@@ -28572,7 +28575,7 @@ async function callApi(path55, init2 = {}) {
     "Authorization": `Bearer ${token}`,
     "X-Device-Id": getDeviceId(),
     "X-Session-Id": getSessionId() || "",
-    "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.3.9"}`,
+    "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.3.10"}`,
     "Content-Type": init2.headers?.["Content-Type"] || "application/json"
   });
   const doFetch = async (token) => {
@@ -28589,7 +28592,7 @@ async function callApi(path55, init2 = {}) {
       throw error2;
     }
   };
-  let response = await doFetch(tokens.accessToken);
+  let response = await doFetch(tokens2.accessToken);
   if (response.status === 401) {
     console.log(chalk36__default.default.gray("Token expired, refreshing..."));
     const refreshed = await authManager.refreshToken();
@@ -28597,12 +28600,12 @@ async function callApi(path55, init2 = {}) {
       console.log(chalk36__default.default.red(ERR.REAUTH_REQUIRED.msg));
       process.exit(ERR.REAUTH_REQUIRED.code);
     }
-    tokens = await authManager.getValidTokens();
-    if (!tokens) {
+    tokens2 = await authManager.getValidTokens();
+    if (!tokens2) {
       console.log(chalk36__default.default.red(ERR.REAUTH_REQUIRED.msg));
       process.exit(ERR.REAUTH_REQUIRED.code);
     }
-    response = await doFetch(tokens.accessToken);
+    response = await doFetch(tokens2.accessToken);
     if (response.status === 401) {
       console.log(chalk36__default.default.red(ERR.REAUTH_REQUIRED.msg));
       process.exit(ERR.REAUTH_REQUIRED.code);
@@ -28615,7 +28618,7 @@ async function callApi(path55, init2 = {}) {
     const waitTime = Math.min(retryAfter, 60);
     console.log(chalk36__default.default.yellow(`\u23F1\uFE0F Rate limit: wait ${waitTime}s`));
     await new Promise((resolve17) => setTimeout(resolve17, waitTime * 1e3));
-    response = await doFetch(tokens.accessToken);
+    response = await doFetch(tokens2.accessToken);
   }
   if (response.status === 402) {
     console.log(chalk36__default.default.yellow(ERR.QUOTA.msg));
@@ -28630,8 +28633,8 @@ async function callApi(path55, init2 = {}) {
   }
   return response;
 }
-async function callApiJson(path55, init2 = {}) {
-  const response = await callApi(path55, init2);
+async function callApiJson(path56, init2 = {}) {
+  const response = await callApi(path56, init2);
   if (!response.ok) {
     const error2 = await response.json().catch(() => ({
       message: `API error: ${response.status} ${response.statusText}`
@@ -28692,7 +28695,7 @@ var init_chat_context_service = __esm({
           // 400K session window
           compressionThreshold: config2?.compressionThreshold || 0.8,
           summaryTokenLimit: config2?.summaryTokenLimit || 2e3,
-          persistPath: config2?.persistPath || path54__namespace.join(process.env["HOME"] || "", ".maria", "context")
+          persistPath: config2?.persistPath || path55__namespace.join(process.env["HOME"] || "", ".maria", "context")
         };
         this.sessionId = this.generateSessionId();
       }
@@ -28713,16 +28716,16 @@ var init_chat_context_service = __esm({
         }
       }
       async addMessage(message) {
-        const tokens = this.countTokens(message.content);
+        const tokens2 = this.countTokens(message.content);
         const fullMessage = {
           ...message,
           timestamp: /* @__PURE__ */ new Date(),
-          tokens
+          tokens: tokens2
         };
         this.fullHistory.push(fullMessage);
         this.contextWindow.push(fullMessage);
-        this.currentTokens += tokens;
-        this.sessionTokens += tokens;
+        this.currentTokens += tokens2;
+        this.sessionTokens += tokens2;
         await this.optimizeMemory();
         this.emit("message-added", fullMessage);
         this.emit("context-updated", this.getStats());
@@ -28816,7 +28819,7 @@ var init_chat_context_service = __esm({
         if (!this.config.persistPath) return;
         try {
           await fsp__namespace.mkdir(this.config.persistPath, { recursive: true });
-          const sessionFile = path54__namespace.join(
+          const sessionFile = path55__namespace.join(
             this.config.persistPath,
             `${this.sessionId}.json`
           );
@@ -28887,8 +28890,8 @@ var init_conversation_persistence = __esm({
       autoSaveInterval = null;
       pendingWrites = [];
       constructor(maxHistorySize = 100) {
-        const configDir = path54__namespace.join(os16__namespace.homedir(), ".maria");
-        this.sessionFile = path54__namespace.join(configDir, "conversation-history.json");
+        const configDir = path55__namespace.join(os16__namespace.homedir(), ".maria");
+        this.sessionFile = path55__namespace.join(configDir, "conversation-history.json");
         this.maxHistorySize = maxHistorySize;
         this.ensureConfigDir();
         this.startAutoSave();
@@ -28898,7 +28901,7 @@ var init_conversation_persistence = __esm({
        */
       async ensureConfigDir() {
         try {
-          const configDir = path54__namespace.dirname(this.sessionFile);
+          const configDir = path55__namespace.dirname(this.sessionFile);
           await fs22.promises.mkdir(configDir, { recursive: true });
         } catch (error2) {
           console.warn("Failed to create config directory:", error2);
@@ -30427,8 +30430,8 @@ __export(api_caller_exports, {
   executeCode: () => executeCode
 });
 async function callAPI(endpoint, options = {}) {
-  const tokens = await authManager2.getValidTokens();
-  if (!tokens) {
+  const tokens2 = await authManager2.getValidTokens();
+  if (!tokens2) {
     throw new Error("Authentication required. Please run /login first.");
   }
   const apiBase = process.env.MARIA_API_BASE || "https://api.maria-code.ai";
@@ -30443,7 +30446,7 @@ async function callAPI(endpoint, options = {}) {
     const response = await fetch(url2, {
       method: options.method || "GET",
       headers: {
-        "Authorization": `Bearer ${tokens.accessToken}`,
+        "Authorization": `Bearer ${tokens2.accessToken}`,
         "Content-Type": "application/json",
         ...options.headers
       },
@@ -31284,14 +31287,14 @@ var init_ReadyCommandsService = __esm({
         } else {
           const possiblePaths = [
             // For bundled dist version
-            path54__namespace.join(__dirname, "READY.manifest.json"),
-            path54__namespace.join(__dirname, "../READY.manifest.json"),
-            path54__namespace.join(process.cwd(), "dist/READY.manifest.json"),
+            path55__namespace.join(__dirname, "READY.manifest.json"),
+            path55__namespace.join(__dirname, "../READY.manifest.json"),
+            path55__namespace.join(process.cwd(), "dist/READY.manifest.json"),
             // For development/source version
-            path54__namespace.join(__dirname, "../../../src/slash-commands/READY.manifest.json"),
-            path54__namespace.join(__dirname, "../../slash-commands/READY.manifest.json"),
-            path54__namespace.join(process.cwd(), "src/slash-commands/READY.manifest.json"),
-            path54__namespace.join(process.cwd(), "READY.manifest.json")
+            path55__namespace.join(__dirname, "../../../src/slash-commands/READY.manifest.json"),
+            path55__namespace.join(__dirname, "../../slash-commands/READY.manifest.json"),
+            path55__namespace.join(process.cwd(), "src/slash-commands/READY.manifest.json"),
+            path55__namespace.join(process.cwd(), "READY.manifest.json")
           ];
           this.manifestPath = possiblePaths[0];
         }
@@ -31302,17 +31305,17 @@ var init_ReadyCommandsService = __esm({
       async findManifestPath() {
         const possiblePaths = [
           // For bundled dist version
-          path54__namespace.join(__dirname, "READY.manifest.json"),
-          path54__namespace.join(__dirname, "../READY.manifest.json"),
-          path54__namespace.join(process.cwd(), "dist/READY.manifest.json"),
+          path55__namespace.join(__dirname, "READY.manifest.json"),
+          path55__namespace.join(__dirname, "../READY.manifest.json"),
+          path55__namespace.join(process.cwd(), "dist/READY.manifest.json"),
           // For development/source version
-          path54__namespace.join(__dirname, "../../../src/slash-commands/READY.manifest.json"),
-          path54__namespace.join(__dirname, "../../slash-commands/READY.manifest.json"),
-          path54__namespace.join(process.cwd(), "src/slash-commands/READY.manifest.json"),
-          path54__namespace.join(process.cwd(), "READY.manifest.json"),
+          path55__namespace.join(__dirname, "../../../src/slash-commands/READY.manifest.json"),
+          path55__namespace.join(__dirname, "../../slash-commands/READY.manifest.json"),
+          path55__namespace.join(process.cwd(), "src/slash-commands/READY.manifest.json"),
+          path55__namespace.join(process.cwd(), "READY.manifest.json"),
           // Additional paths for different build scenarios
-          path54__namespace.resolve(__dirname, "../../../src/slash-commands/READY.manifest.json"),
-          path54__namespace.resolve(process.cwd(), "src/slash-commands/READY.manifest.json")
+          path55__namespace.resolve(__dirname, "../../../src/slash-commands/READY.manifest.json"),
+          path55__namespace.resolve(process.cwd(), "src/slash-commands/READY.manifest.json")
         ];
         for (const testPath of possiblePaths) {
           try {
@@ -31874,7 +31877,7 @@ async function loadFirebaseAdmin() {
   try {
     const firebaseAdminModule = await import('firebase-admin/app');
     const firestoreModule = await import('firebase-admin/firestore');
-    const keyPath = path54__namespace.join(process.cwd(), "config", "maria-cli-firestore-key.json");
+    const keyPath = path55__namespace.join(process.cwd(), "config", "maria-cli-firestore-key.json");
     if (!adminApp && firebaseAdminModule.getApps().length === 0) {
       adminApp = firebaseAdminModule.initializeApp({
         credential: firebaseAdminModule.cert(keyPath),
@@ -32246,8 +32249,8 @@ var init_bigquery_telemetry = __esm({
 });
 async function getUserContext() {
   try {
-    const configDir = path54__namespace.join(process.env.HOME || process.env.USERPROFILE || "", ".maria");
-    const authFile = path54__namespace.join(configDir, "auth.json");
+    const configDir = path55__namespace.join(process.env.HOME || process.env.USERPROFILE || "", ".maria");
+    const authFile = path55__namespace.join(configDir, "auth.json");
     if (await fs10__namespace.pathExists(authFile)) {
       const authData = await fs10__namespace.readJson(authFile);
       return {
@@ -33423,7 +33426,7 @@ var init_setup_command = __esm({
           if (_setupRecord.filesGenerated) {
             for (const file of _setupRecord.filesGenerated) {
               try {
-                const _filePath = path54__namespace.default.join(context2.environment.cwd, file);
+                const _filePath = path55__namespace.default.join(context2.environment.cwd, file);
                 await fsp__namespace.default.unlink(_filePath);
                 restoredFiles.push(file);
               } catch (innerError) {
@@ -33433,7 +33436,7 @@ var init_setup_command = __esm({
               }
             }
           }
-          const _setupRecordPath = path54__namespace.default.join(
+          const _setupRecordPath = path55__namespace.default.join(
             context2.environment.cwd,
             ".maria",
             "setup.json"
@@ -33501,7 +33504,7 @@ var init_setup_command = __esm({
         }
       }
       async recordSetupCompletion(_context, result) {
-        const _mariaDir = path54__namespace.default.join(_context.environment.cwd, ".maria");
+        const _mariaDir = path55__namespace.default.join(_context.environment.cwd, ".maria");
         await fsp__namespace.default.mkdir(_mariaDir, { recursive: true });
         const _setupRecord = {
           ...result,
@@ -33509,7 +33512,7 @@ var init_setup_command = __esm({
           version: "1.0.0",
           environment: _context.environment
         };
-        const _recordPath = path54__namespace.default.join(_mariaDir, "setup.json");
+        const _recordPath = path55__namespace.default.join(_mariaDir, "setup.json");
         await fsp__namespace.default.writeFile(
           _recordPath,
           JSON.stringify(_setupRecord, null, 2),
@@ -33608,14 +33611,14 @@ Estimated time: 3-5 minutes
       }
       async detectConfigurationIssues(context2) {
         const _issues = [];
-        if (!await this.fileExists(path54__namespace.default.join(context2.environment.cwd, ".env.local"))) {
+        if (!await this.fileExists(path55__namespace.default.join(context2.environment.cwd, ".env.local"))) {
           _issues.push({
             description: "Missing .env.local file",
             severity: "error"
           });
         }
         if (!await this.fileExists(
-          path54__namespace.default.join(context2.environment.cwd, ".maria-code.toml")
+          path55__namespace.default.join(context2.environment.cwd, ".maria-code.toml")
         )) {
           _issues.push({
             description: "Missing .maria-code.toml file",
@@ -33631,7 +33634,7 @@ Estimated time: 3-5 minutes
       }
       async getSetupRecord(context2) {
         try {
-          const _recordPath = path54__namespace.default.join(
+          const _recordPath = path55__namespace.default.join(
             context2.environment.cwd,
             ".maria",
             "setup.json"
@@ -33643,11 +33646,11 @@ Estimated time: 3-5 minutes
         }
       }
       async validateEnvironmentFile(context2) {
-        return this.fileExists(path54__namespace.default.join(context2.environment.cwd, ".env.local"));
+        return this.fileExists(path55__namespace.default.join(context2.environment.cwd, ".env.local"));
       }
       async validateConfigFile(context2) {
         return this.fileExists(
-          path54__namespace.default.join(context2.environment.cwd, ".maria-code.toml")
+          path55__namespace.default.join(context2.environment.cwd, ".maria-code.toml")
         );
       }
       async validateProviderConnections(_context) {
@@ -33674,7 +33677,7 @@ VLLM_API_URL=http://localhost:8000
 DEBUG=false
 LOG_LEVEL=info
 `;
-          const _envPath = path54__namespace.default.join(process.cwd(), ".env.local");
+          const _envPath = path55__namespace.default.join(process.cwd(), ".env.local");
           await fsp__namespace.default.writeFile(_envPath, _envContent, "utf-8");
           return this.success("Environment template generated successfully", {
             files: [".env.local"],
@@ -33748,8 +33751,8 @@ var init_ConfigurationCommandService = __esm({
 var DIR, FILE, QuickPersistence;
 var init_quick_persistence = __esm({
   "src/services/memory-system/quick-persistence.ts"() {
-    DIR = path54__namespace.join(os16__namespace.homedir(), ".maria", "memory");
-    FILE = path54__namespace.join(DIR, "memories.jsonl");
+    DIR = path55__namespace.join(os16__namespace.homedir(), ".maria", "memory");
+    FILE = path55__namespace.join(DIR, "memories.jsonl");
     QuickPersistence = class {
       static async init() {
         await fsp__namespace.mkdir(DIR, { recursive: true });
@@ -33871,8 +33874,8 @@ var init_quick_persistence = __esm({
         const mine = rows.filter((r2) => r2.userId === userId);
         const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
         const filename = `maria-memory-export-${timestamp}.${format}`;
-        const exportDir = path54__namespace.join(os16__namespace.homedir(), ".maria", "exports");
-        const exportPath = path54__namespace.join(exportDir, filename);
+        const exportDir = path55__namespace.join(os16__namespace.homedir(), ".maria", "exports");
+        const exportPath = path55__namespace.join(exportDir, filename);
         await fsp__namespace.mkdir(exportDir, { recursive: true });
         if (format === "jsonl") {
           await fsp__namespace.writeFile(
@@ -36506,7 +36509,7 @@ var init_StateManager = __esm({
       maxCheckpointAge = 7 * 24 * 60 * 60 * 1e3;
       // 7 days
       constructor() {
-        this.checkpointsDir = path54__namespace.join(os16__namespace.homedir(), ".maria", "checkpoints");
+        this.checkpointsDir = path55__namespace.join(os16__namespace.homedir(), ".maria", "checkpoints");
       }
       /**
        * Initialize checkpoints directory
@@ -36532,7 +36535,7 @@ var init_StateManager = __esm({
         const checkpointId = `${planId}_${Date.now()}`;
         const timestamp = Date.now();
         try {
-          const checkpointPath = path54__namespace.join(this.checkpointsDir, checkpointId);
+          const checkpointPath = path55__namespace.join(this.checkpointsDir, checkpointId);
           await fsp__namespace.mkdir(checkpointPath, { recursive: true });
           const backups = await this.createBackups(actions, checkpointPath);
           const configSnapshots = await this.createConfigSnapshots(
@@ -36551,7 +36554,7 @@ var init_StateManager = __esm({
               riskScore
             }
           };
-          const metadataPath = path54__namespace.join(checkpointPath, "checkpoint.json");
+          const metadataPath = path55__namespace.join(checkpointPath, "checkpoint.json");
           await fsp__namespace.writeFile(
             metadataPath,
             JSON.stringify(checkpoint, null, 2),
@@ -36723,7 +36726,7 @@ var init_StateManager = __esm({
        */
       async removeCheckpoint(checkpointId) {
         try {
-          const checkpointPath = path54__namespace.join(this.checkpointsDir, checkpointId);
+          const checkpointPath = path55__namespace.join(this.checkpointsDir, checkpointId);
           await fsp__namespace.rm(checkpointPath, { recursive: true, force: true });
           logger.info(`StateManager: Removed checkpoint ${checkpointId}`);
           return true;
@@ -36754,7 +36757,7 @@ var init_StateManager = __esm({
        */
       async createBackups(actions, checkpointPath) {
         const backups = [];
-        const backupDir = path54__namespace.join(checkpointPath, "backups");
+        const backupDir = path55__namespace.join(checkpointPath, "backups");
         await fsp__namespace.mkdir(backupDir, { recursive: true });
         for (const action of actions) {
           const filesToBackup = this.extractFilePathsFromAction(action);
@@ -36763,7 +36766,7 @@ var init_StateManager = __esm({
               const resolvedPath = this.resolvePath(filePath);
               const stats = await fsp__namespace.stat(resolvedPath);
               const backupFileName = this.sanitizeFileName(resolvedPath);
-              const backupPath = path54__namespace.join(backupDir, backupFileName);
+              const backupPath = path55__namespace.join(backupDir, backupFileName);
               await fsp__namespace.copyFile(resolvedPath, backupPath);
               backups.push({
                 originalPath: resolvedPath,
@@ -36786,7 +36789,7 @@ var init_StateManager = __esm({
        */
       async createConfigSnapshots(actions, checkpointPath) {
         const snapshots = [];
-        const configDir = path54__namespace.join(checkpointPath, "configs");
+        const configDir = path55__namespace.join(checkpointPath, "configs");
         await fsp__namespace.mkdir(configDir, { recursive: true });
         const configPaths = /* @__PURE__ */ new Set();
         for (const action of actions) {
@@ -36819,7 +36822,7 @@ var init_StateManager = __esm({
        * Load checkpoint from disk
        */
       async loadCheckpoint(checkpointId) {
-        const metadataPath = path54__namespace.join(
+        const metadataPath = path55__namespace.join(
           this.checkpointsDir,
           checkpointId,
           "checkpoint.json"
@@ -36845,9 +36848,9 @@ var init_StateManager = __esm({
        */
       resolvePath(filePath) {
         if (filePath.startsWith("~/")) {
-          return path54__namespace.join(os16__namespace.homedir(), filePath.slice(2));
+          return path55__namespace.join(os16__namespace.homedir(), filePath.slice(2));
         }
-        return path54__namespace.resolve(filePath);
+        return path55__namespace.resolve(filePath);
       }
       /**
        * Sanitize filename for backup storage
@@ -36911,7 +36914,7 @@ var init_StateManager = __esm({
           } catch {
           }
         } else {
-          await fsp__namespace.mkdir(path54__namespace.dirname(config2.configPath), { recursive: true });
+          await fsp__namespace.mkdir(path55__namespace.dirname(config2.configPath), { recursive: true });
           await fsp__namespace.writeFile(config2.configPath, config2.content, "utf-8");
         }
         logger.debug(`StateManager: Restored config ${config2.configPath}`);
@@ -37029,9 +37032,9 @@ var init_SafetyGuard = __esm({
           }
         }
         if (action.args.paths && Array.isArray(action.args.paths)) {
-          for (const path55 of action.args.paths) {
-            if (!this.validatePath(path55)) {
-              violations.push(`Invalid path: ${path55}`);
+          for (const path56 of action.args.paths) {
+            if (!this.validatePath(path56)) {
+              violations.push(`Invalid path: ${path56}`);
             }
           }
         }
@@ -37087,15 +37090,15 @@ var init_SafetyGuard = __esm({
        * Validate file path against allowed/blocked lists
        */
       validatePath(filePath) {
-        const path55 = __require("path");
-        const resolvedPath = path55.resolve(filePath);
+        const path56 = __require("path");
+        const resolvedPath = path56.resolve(filePath);
         for (const blockedPath of this.constraints.blockedPaths) {
-          if (resolvedPath.startsWith(path55.resolve(blockedPath))) {
+          if (resolvedPath.startsWith(path56.resolve(blockedPath))) {
             return false;
           }
         }
         for (const allowedPath of this.constraints.allowedPaths) {
-          if (resolvedPath.startsWith(path55.resolve(allowedPath))) {
+          if (resolvedPath.startsWith(path56.resolve(allowedPath))) {
             return true;
           }
         }
@@ -37124,9 +37127,9 @@ var init_SafetyGuard = __esm({
             violations.push(`Invalid path in ${action.type}: ${action.args.path}`);
           }
           if (action.args.paths && Array.isArray(action.args.paths)) {
-            for (const path55 of action.args.paths) {
-              if (!this.validatePath(path55)) {
-                violations.push(`Invalid path in ${action.type}: ${path55}`);
+            for (const path56 of action.args.paths) {
+              if (!this.validatePath(path56)) {
+                violations.push(`Invalid path in ${action.type}: ${path56}`);
               }
             }
           }
@@ -37225,7 +37228,7 @@ var init_AuditLogger = __esm({
       constructor(sessionId, options = {}) {
         this.sessionId = sessionId;
         this.options = {
-          logDir: path54__namespace.join(os16__namespace.homedir(), ".maria", "audit"),
+          logDir: path55__namespace.join(os16__namespace.homedir(), ".maria", "audit"),
           maxLogSize: 10 * 1024 * 1024,
           // 10MB
           maxLogFiles: 30,
@@ -37235,7 +37238,7 @@ var init_AuditLogger = __esm({
           ...options
         };
         const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-        this.logFilePath = path54__namespace.join(this.options.logDir, `audit-${date}.jsonl`);
+        this.logFilePath = path55__namespace.join(this.options.logDir, `audit-${date}.jsonl`);
       }
       /**
        * Initialize audit logging
@@ -37524,7 +37527,7 @@ var init_AuditLogger = __esm({
         try {
           const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
           const timestamp = Date.now();
-          const archivePath = path54__namespace.join(
+          const archivePath = path55__namespace.join(
             this.options.logDir,
             `audit-${date}-${timestamp}.jsonl`
           );
@@ -37564,7 +37567,7 @@ var init_AuditLogger = __esm({
           if (logFiles.length > this.options.maxLogFiles) {
             const toRemove = logFiles.slice(this.options.maxLogFiles);
             for (const file of toRemove) {
-              const filePath = path54__namespace.join(this.options.logDir, file);
+              const filePath = path55__namespace.join(this.options.logDir, file);
               await fsp__namespace.unlink(filePath);
               logger.debug(`AuditLogger: Removed old log file ${file}`);
             }
@@ -37606,7 +37609,7 @@ var init_FileActionExecutor = __esm({
     FileActionExecutor = class {
       ALLOWED_PATHS = [
         process.cwd(),
-        path54__namespace.join(os16__namespace.homedir(), ".maria")
+        path55__namespace.join(os16__namespace.homedir(), ".maria")
       ];
       /**
        * Execute file action
@@ -37668,7 +37671,7 @@ var init_FileActionExecutor = __esm({
           await fsp__namespace.access(resolvedPath);
           return { action: "already_exists", path: resolvedPath };
         } catch {
-          await fsp__namespace.mkdir(path54__namespace.dirname(resolvedPath), { recursive: true });
+          await fsp__namespace.mkdir(path55__namespace.dirname(resolvedPath), { recursive: true });
           await fsp__namespace.writeFile(resolvedPath, "", "utf-8");
           logger.info(`Created file: ${resolvedPath}`);
           return { action: "created", path: resolvedPath };
@@ -37885,20 +37888,20 @@ var init_FileActionExecutor = __esm({
        */
       resolvePath(filePath) {
         if (filePath.startsWith("~/")) {
-          return path54__namespace.join(os16__namespace.homedir(), filePath.slice(2));
+          return path55__namespace.join(os16__namespace.homedir(), filePath.slice(2));
         }
-        if (path54__namespace.isAbsolute(filePath)) {
+        if (path55__namespace.isAbsolute(filePath)) {
           return filePath;
         }
-        return path54__namespace.resolve(process.cwd(), filePath);
+        return path55__namespace.resolve(process.cwd(), filePath);
       }
       /**
        * Validate path is within allowed directories
        */
       validatePath(filePath) {
-        const resolvedPath = path54__namespace.resolve(filePath);
+        const resolvedPath = path55__namespace.resolve(filePath);
         for (const allowedPath of this.ALLOWED_PATHS) {
-          const allowedResolved = path54__namespace.resolve(allowedPath);
+          const allowedResolved = path55__namespace.resolve(allowedPath);
           if (resolvedPath.startsWith(allowedResolved)) {
             return;
           }
@@ -37913,7 +37916,7 @@ var init_ConfigActionExecutor = __esm({
   "src/services/self-healing/executors/ConfigActionExecutor.ts"() {
     init_logger();
     ConfigActionExecutor = class {
-      DEFAULT_CONFIG_PATH = path54__namespace.join(
+      DEFAULT_CONFIG_PATH = path55__namespace.join(
         os16__namespace.homedir(),
         ".maria",
         "config.json"
@@ -37960,7 +37963,7 @@ var init_ConfigActionExecutor = __esm({
           };
         }
         try {
-          await fsp__namespace.mkdir(path54__namespace.dirname(resolvedPath), { recursive: true });
+          await fsp__namespace.mkdir(path55__namespace.dirname(resolvedPath), { recursive: true });
           let config2 = {};
           try {
             const content = await fsp__namespace.readFile(resolvedPath, "utf-8");
@@ -37995,7 +37998,7 @@ var init_ConfigActionExecutor = __esm({
           };
         }
         try {
-          await fsp__namespace.mkdir(path54__namespace.dirname(resolvedPath), { recursive: true });
+          await fsp__namespace.mkdir(path55__namespace.dirname(resolvedPath), { recursive: true });
           let config2 = {};
           try {
             const content = await fsp__namespace.readFile(resolvedPath, "utf-8");
@@ -38095,8 +38098,8 @@ var init_ConfigActionExecutor = __esm({
       /**
        * Set nested configuration value using dot notation
        */
-      setNestedValue(obj, path55, value) {
-        const keys = path55.split(".");
+      setNestedValue(obj, path56, value) {
+        const keys = path56.split(".");
         let current = obj;
         for (let i2 = 0; i2 < keys.length - 1; i2++) {
           const key = keys[i2];
@@ -38113,9 +38116,9 @@ var init_ConfigActionExecutor = __esm({
       resolveConfigPath(configPath) {
         if (configPath) {
           if (configPath.startsWith("~/")) {
-            return path54__namespace.join(os16__namespace.homedir(), configPath.slice(2));
+            return path55__namespace.join(os16__namespace.homedir(), configPath.slice(2));
           }
-          return path54__namespace.resolve(configPath);
+          return path55__namespace.resolve(configPath);
         }
         return this.DEFAULT_CONFIG_PATH;
       }
@@ -38128,10 +38131,10 @@ var init_CacheActionExecutor = __esm({
     init_logger();
     CacheActionExecutor = class {
       CACHE_PATHS = [
-        path54__namespace.join(os16__namespace.homedir(), ".maria", "cache"),
-        path54__namespace.join(process.cwd(), ".turbo"),
-        path54__namespace.join(process.cwd(), ".cache", "maria"),
-        path54__namespace.join(process.cwd(), "node_modules", ".cache")
+        path55__namespace.join(os16__namespace.homedir(), ".maria", "cache"),
+        path55__namespace.join(process.cwd(), ".turbo"),
+        path55__namespace.join(process.cwd(), ".cache", "maria"),
+        path55__namespace.join(process.cwd(), "node_modules", ".cache")
       ];
       /**
        * Execute cache action
@@ -38312,10 +38315,10 @@ var init_CacheActionExecutor = __esm({
        * Warmup specific target
        */
       async warmupTarget(target) {
-        const cacheDir = path54__namespace.join(os16__namespace.homedir(), ".maria", "cache");
+        const cacheDir = path55__namespace.join(os16__namespace.homedir(), ".maria", "cache");
         switch (target) {
           case "models:list":
-            const modelsDir = path54__namespace.join(cacheDir, "models");
+            const modelsDir = path55__namespace.join(cacheDir, "models");
             await fsp__namespace.mkdir(modelsDir, { recursive: true });
             const modelsData = {
               timestamp: Date.now(),
@@ -38326,12 +38329,12 @@ var init_CacheActionExecutor = __esm({
               ]
             };
             await fsp__namespace.writeFile(
-              path54__namespace.join(modelsDir, "available.json"),
+              path55__namespace.join(modelsDir, "available.json"),
               JSON.stringify(modelsData, null, 2)
             );
             return { itemsCreated: 1, size: JSON.stringify(modelsData).length };
           case "aliases":
-            const aliasesDir = path54__namespace.join(cacheDir, "aliases");
+            const aliasesDir = path55__namespace.join(cacheDir, "aliases");
             await fsp__namespace.mkdir(aliasesDir, { recursive: true });
             const aliasesData = {
               timestamp: Date.now(),
@@ -38342,12 +38345,12 @@ var init_CacheActionExecutor = __esm({
               }
             };
             await fsp__namespace.writeFile(
-              path54__namespace.join(aliasesDir, "model-aliases.json"),
+              path55__namespace.join(aliasesDir, "model-aliases.json"),
               JSON.stringify(aliasesData, null, 2)
             );
             return { itemsCreated: 1, size: JSON.stringify(aliasesData).length };
           case "templates":
-            const templatesDir = path54__namespace.join(cacheDir, "templates");
+            const templatesDir = path55__namespace.join(cacheDir, "templates");
             await fsp__namespace.mkdir(templatesDir, { recursive: true });
             const templatesData = {
               timestamp: Date.now(),
@@ -38358,7 +38361,7 @@ var init_CacheActionExecutor = __esm({
               }
             };
             await fsp__namespace.writeFile(
-              path54__namespace.join(templatesDir, "prompt-templates.json"),
+              path55__namespace.join(templatesDir, "prompt-templates.json"),
               JSON.stringify(templatesData, null, 2)
             );
             return { itemsCreated: 1, size: JSON.stringify(templatesData).length };
@@ -38404,7 +38407,7 @@ var init_CacheActionExecutor = __esm({
         try {
           const entries = await fsp__namespace.readdir(dirPath, { withFileTypes: true });
           for (const entry of entries) {
-            const entryPath = path54__namespace.join(dirPath, entry.name);
+            const entryPath = path55__namespace.join(dirPath, entry.name);
             if (entry.isDirectory()) {
               totalSize += await this.getDirectorySize(entryPath);
             } else {
@@ -38425,7 +38428,7 @@ var init_CacheActionExecutor = __esm({
           const entries = await fsp__namespace.readdir(dirPath, { withFileTypes: true });
           for (const entry of entries) {
             if (entry.isDirectory()) {
-              const entryPath = path54__namespace.join(dirPath, entry.name);
+              const entryPath = path55__namespace.join(dirPath, entry.name);
               count += await this.countFiles(entryPath);
             } else {
               count++;
@@ -38453,12 +38456,12 @@ var init_CacheActionExecutor = __esm({
        */
       resolvePath(cachePath) {
         if (cachePath.startsWith("~/")) {
-          return path54__namespace.join(os16__namespace.homedir(), cachePath.slice(2));
+          return path55__namespace.join(os16__namespace.homedir(), cachePath.slice(2));
         }
-        if (path54__namespace.isAbsolute(cachePath)) {
+        if (path55__namespace.isAbsolute(cachePath)) {
           return cachePath;
         }
-        return path54__namespace.resolve(process.cwd(), cachePath);
+        return path55__namespace.resolve(process.cwd(), cachePath);
       }
     };
   }
@@ -38731,7 +38734,7 @@ var init_SelfHealingService = __esm({
         const timestamp = /* @__PURE__ */ new Date();
         await this.auditLogger.logDiagnosis("started", { diagnostics: context2 });
         try {
-          const envPath = path54__namespace.join(context2.cwd, ".env.local");
+          const envPath = path55__namespace.join(context2.cwd, ".env.local");
           try {
             await fsp__namespace.access(envPath);
           } catch {
@@ -38746,7 +38749,7 @@ var init_SelfHealingService = __esm({
               suggestion: "Create .env.local with API keys template"
             });
           }
-          const nodeModulesPath = path54__namespace.join(context2.cwd, "node_modules");
+          const nodeModulesPath = path55__namespace.join(context2.cwd, "node_modules");
           try {
             await fsp__namespace.access(nodeModulesPath);
           } catch {
@@ -38761,7 +38764,7 @@ var init_SelfHealingService = __esm({
               suggestion: "Run package manager install command"
             });
           }
-          const cachePath = path54__namespace.join(process.env.HOME || "", ".maria", "cache");
+          const cachePath = path55__namespace.join(process.env.HOME || "", ".maria", "cache");
           try {
             const stats = await fsp__namespace.stat(cachePath);
             if (stats.size > 100 * 1024 * 1024) {
@@ -39343,7 +39346,7 @@ function createConfigCheck() {
     runsIn: "read-only",
     estimateMs: 20,
     async run(ctx2) {
-      const pkgPath = path54.resolve(ctx2.cwd, "package.json");
+      const pkgPath = path55.resolve(ctx2.cwd, "package.json");
       try {
         const raw = await fsp.readFile(pkgPath, "utf-8");
         const pkg = JSON.parse(raw);
@@ -39412,7 +39415,7 @@ function createDependenciesCheck() {
     runsIn: "read-only",
     estimateMs: 25,
     async run(ctx2) {
-      const nm = path54.resolve(ctx2.cwd, "node_modules");
+      const nm = path55.resolve(ctx2.cwd, "node_modules");
       try {
         const s2 = await fsp.stat(nm);
         if (!s2.isDirectory()) {
@@ -39507,7 +39510,7 @@ function createGitRepoCheck() {
     runsIn: "read-only",
     estimateMs: 10,
     async run(ctx2) {
-      const dotgit = path54.resolve(ctx2.cwd, ".git");
+      const dotgit = path55.resolve(ctx2.cwd, ".git");
       try {
         await fsp.access(dotgit);
         return { name: "Git Repository", category: "config", status: "pass", message: "Git repo detected" };
@@ -39593,9 +39596,9 @@ function createProvidersSecretConfigCheck() {
         groq: !!process.env.GROQ_API_KEY
       };
       const candidates = [
-        path54.resolve(ctx2.cwd, ".maria/secrets.local.json"),
-        path54.resolve(ctx2.cwd, "secrets/local.json"),
-        path54.resolve(ctx2.cwd, ".secrets.local.json")
+        path55.resolve(ctx2.cwd, ".maria/secrets.local.json"),
+        path55.resolve(ctx2.cwd, "secrets/local.json"),
+        path55.resolve(ctx2.cwd, ".secrets.local.json")
       ];
       let fileCfg = null;
       for (const p of candidates) {
@@ -39667,8 +39670,8 @@ async function applyPlans(plans, opts) {
   try {
     for (const plan of plans) {
       if (opts.signal?.aborted) throw abortErr();
-      const target = path54__namespace.default.join(opts.root, plan.path);
-      const dir = path54__namespace.default.dirname(target);
+      const target = path55__namespace.default.join(opts.root, plan.path);
+      const dir = path55__namespace.default.dirname(target);
       await fs22.promises.mkdir(dir, { recursive: true });
       const exists = await fileExists(target);
       const perFileAllowed = plan.overwritePolicy === "allow";
@@ -39697,7 +39700,7 @@ async function applyPlans(plans, opts) {
     if (opts.rollback) {
       for (const rel of created) {
         try {
-          await fs22.promises.unlink(path54__namespace.default.join(opts.root, rel));
+          await fs22.promises.unlink(path55__namespace.default.join(opts.root, rel));
         } catch {
         }
       }
@@ -39818,7 +39821,7 @@ async function applyFixes(plans, opts) {
         continue;
       }
       if (plan.action === "file.create") {
-        const full = path54.resolve(opts.cwd, plan.path);
+        const full = path55.resolve(opts.cwd, plan.path);
         try {
           await fsp.access(full);
           results.push({ plan, status: "skipped", message: "File exists" });
@@ -39831,7 +39834,7 @@ async function applyFixes(plans, opts) {
         continue;
       }
       if (plan.action === "file.modify") {
-        const full = path54.resolve(opts.cwd, plan.path);
+        const full = path55.resolve(opts.cwd, plan.path);
         const st = await fsp.stat(full).catch(() => null);
         if (!st) {
           await ensureDir(full);
@@ -39848,7 +39851,7 @@ ${plan.diff ?? plan.content ?? ""}`;
         continue;
       }
       if (plan.action === "file.json-merge") {
-        const full = path54.resolve(opts.cwd, plan.path);
+        const full = path55.resolve(opts.cwd, plan.path);
         const raw = await readFileSafe(full);
         let json = {};
         if (raw) {
@@ -39883,14 +39886,14 @@ function validatePath2(rel, cwd2) {
   if (rel.includes("..")) return { valid: false, reason: "path traversal" };
   if (rel.startsWith("/") || rel.includes("\\")) return { valid: false, reason: "absolute or backslashes not allowed" };
   if (rel.startsWith(".env") || rel.endsWith(".pem") || rel.endsWith("id_rsa")) return { valid: false, reason: "sensitive path" };
-  const full = path54.resolve(cwd2, rel);
-  const normCwd = path54.normalize(cwd2) + path54.sep;
-  const normFull = path54.normalize(full);
+  const full = path55.resolve(cwd2, rel);
+  const normCwd = path55.normalize(cwd2) + path55.sep;
+  const normFull = path55.normalize(full);
   if (!normFull.startsWith(normCwd)) return { valid: false, reason: "outside cwd" };
   return { valid: true };
 }
 async function ensureDir(fullPath) {
-  const i2 = fullPath.lastIndexOf(path54.sep);
+  const i2 = fullPath.lastIndexOf(path55.sep);
   if (i2 <= 0) return;
   const dir = fullPath.slice(0, i2);
   try {
@@ -44012,12 +44015,12 @@ var init_esm4 = __esm({
       /**
        * Get the Path object referenced by the string path, resolved from this Path
        */
-      resolve(path55) {
-        if (!path55) {
+      resolve(path56) {
+        if (!path56) {
           return this;
         }
-        const rootPath = this.getRootString(path55);
-        const dir = path55.substring(rootPath.length);
+        const rootPath = this.getRootString(path56);
+        const dir = path56.substring(rootPath.length);
         const dirParts = dir.split(this.splitSep);
         const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
         return result;
@@ -44769,8 +44772,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      getRootString(path55) {
-        return path54.win32.parse(path55).root;
+      getRootString(path56) {
+        return path55.win32.parse(path56).root;
       }
       /**
        * @internal
@@ -44816,8 +44819,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      getRootString(path55) {
-        return path55.startsWith("/") ? "/" : "";
+      getRootString(path56) {
+        return path56.startsWith("/") ? "/" : "";
       }
       /**
        * @internal
@@ -44866,8 +44869,8 @@ var init_esm4 = __esm({
        *
        * @internal
        */
-      constructor(cwd2 = process.cwd(), pathImpl, sep4, { nocase, childrenCacheSize = 16 * 1024, fs: fs45 = defaultFS } = {}) {
-        this.#fs = fsFromOption(fs45);
+      constructor(cwd2 = process.cwd(), pathImpl, sep4, { nocase, childrenCacheSize = 16 * 1024, fs: fs46 = defaultFS } = {}) {
+        this.#fs = fsFromOption(fs46);
         if (cwd2 instanceof URL || cwd2.startsWith("file://")) {
           cwd2 = url.fileURLToPath(cwd2);
         }
@@ -44906,11 +44909,11 @@ var init_esm4 = __esm({
       /**
        * Get the depth of a provided path, string, or the cwd
        */
-      depth(path55 = this.cwd) {
-        if (typeof path55 === "string") {
-          path55 = this.cwd.resolve(path55);
+      depth(path56 = this.cwd) {
+        if (typeof path56 === "string") {
+          path56 = this.cwd.resolve(path56);
         }
-        return path55.depth();
+        return path56.depth();
       }
       /**
        * Return the cache of child entries.  Exposed so subclasses can create
@@ -45397,9 +45400,9 @@ var init_esm4 = __esm({
         process11();
         return results;
       }
-      chdir(path55 = this.cwd) {
+      chdir(path56 = this.cwd) {
         const oldCwd = this.cwd;
-        this.cwd = typeof path55 === "string" ? this.cwd.resolve(path55) : path55;
+        this.cwd = typeof path56 === "string" ? this.cwd.resolve(path56) : path56;
         this.cwd[setAsCwd](oldCwd);
       }
     };
@@ -45410,7 +45413,7 @@ var init_esm4 = __esm({
       sep = "\\";
       constructor(cwd2 = process.cwd(), opts = {}) {
         const { nocase = true } = opts;
-        super(cwd2, path54.win32, "\\", { ...opts, nocase });
+        super(cwd2, path55.win32, "\\", { ...opts, nocase });
         this.nocase = nocase;
         for (let p = this.cwd; p; p = p.parent) {
           p.nocase = this.nocase;
@@ -45420,13 +45423,13 @@ var init_esm4 = __esm({
        * @internal
        */
       parseRootPath(dir) {
-        return path54.win32.parse(dir).root.toUpperCase();
+        return path55.win32.parse(dir).root.toUpperCase();
       }
       /**
        * @internal
        */
-      newRoot(fs45) {
-        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs45 });
+      newRoot(fs46) {
+        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs46 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -45442,7 +45445,7 @@ var init_esm4 = __esm({
       sep = "/";
       constructor(cwd2 = process.cwd(), opts = {}) {
         const { nocase = false } = opts;
-        super(cwd2, path54.posix, "/", { ...opts, nocase });
+        super(cwd2, path55.posix, "/", { ...opts, nocase });
         this.nocase = nocase;
       }
       /**
@@ -45454,8 +45457,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      newRoot(fs45) {
-        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs45 });
+      newRoot(fs46) {
+        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs46 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -45774,8 +45777,8 @@ var init_processor = __esm({
       }
       // match, absolute, ifdir
       entries() {
-        return [...this.store.entries()].map(([path55, n]) => [
-          path55,
+        return [...this.store.entries()].map(([path56, n]) => [
+          path56,
           !!(n & 2),
           !!(n & 1)
         ]);
@@ -45988,9 +45991,9 @@ var init_walker = __esm({
       signal;
       maxDepth;
       includeChildMatches;
-      constructor(patterns, path55, opts) {
+      constructor(patterns, path56, opts) {
         this.patterns = patterns;
-        this.path = path55;
+        this.path = path56;
         this.opts = opts;
         this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
         this.includeChildMatches = opts.includeChildMatches !== false;
@@ -46009,11 +46012,11 @@ var init_walker = __esm({
           });
         }
       }
-      #ignored(path55) {
-        return this.seen.has(path55) || !!this.#ignore?.ignored?.(path55);
+      #ignored(path56) {
+        return this.seen.has(path56) || !!this.#ignore?.ignored?.(path56);
       }
-      #childrenIgnored(path55) {
-        return !!this.#ignore?.childrenIgnored?.(path55);
+      #childrenIgnored(path56) {
+        return !!this.#ignore?.childrenIgnored?.(path56);
       }
       // backpressure mechanism
       pause() {
@@ -46228,8 +46231,8 @@ var init_walker = __esm({
     };
     GlobWalker = class extends GlobUtil {
       matches = /* @__PURE__ */ new Set();
-      constructor(patterns, path55, opts) {
-        super(patterns, path55, opts);
+      constructor(patterns, path56, opts) {
+        super(patterns, path56, opts);
       }
       matchEmit(e2) {
         this.matches.add(e2);
@@ -46266,8 +46269,8 @@ var init_walker = __esm({
     };
     GlobStream = class extends GlobUtil {
       results;
-      constructor(patterns, path55, opts) {
-        super(patterns, path55, opts);
+      constructor(patterns, path56, opts) {
+        super(patterns, path56, opts);
         this.results = new Minipass({
           signal: this.signal,
           objectMode: true
@@ -46816,7 +46819,7 @@ ${usageLine}`;
       async autoRegister(directory) {
         logger.info(`Auto-registering commands from ${directory}`);
         try {
-          const pattern = path54__namespace.join(directory, "**/*.command.{ts,js}");
+          const pattern = path55__namespace.join(directory, "**/*.command.{ts,js}");
           const files = await glob(pattern);
           logger.info(`Found ${files.length} command files`);
           for (const file of files) {
@@ -47520,7 +47523,7 @@ ${fixPlan.note}` : ""));
       async runConfigurationChecks(context2) {
         const checks = [];
         const cwd2 = context2.environment?.cwd || process.cwd();
-        const packageJsonPath = path54__namespace.join(cwd2, "package.json");
+        const packageJsonPath = path55__namespace.join(cwd2, "package.json");
         try {
           await fsp__namespace.access(packageJsonPath);
           const content = await fsp__namespace.readFile(packageJsonPath, "utf-8");
@@ -47546,7 +47549,7 @@ ${fixPlan.note}` : ""));
             fixable: true
           });
         }
-        const envPath = path54__namespace.join(cwd2, ".env.local");
+        const envPath = path55__namespace.join(cwd2, ".env.local");
         try {
           await fsp__namespace.access(envPath);
           checks.push({
@@ -47564,7 +47567,7 @@ ${fixPlan.note}` : ""));
             fixable: true
           });
         }
-        const gitPath = path54__namespace.join(cwd2, ".git");
+        const gitPath = path55__namespace.join(cwd2, ".git");
         try {
           await fsp__namespace.access(gitPath);
           checks.push({
@@ -47588,7 +47591,7 @@ ${fixPlan.note}` : ""));
       async runDependencyChecks(context2) {
         const checks = [];
         const cwd2 = context2.environment?.cwd || process.cwd();
-        const nodeModulesPath = path54__namespace.join(cwd2, "node_modules");
+        const nodeModulesPath = path55__namespace.join(cwd2, "node_modules");
         try {
           await fsp__namespace.access(nodeModulesPath);
           const stats = await fsp__namespace.stat(nodeModulesPath);
@@ -47820,7 +47823,7 @@ ${fixPlan.note}` : ""));
             }
             break;
           case "CACHE_CORRUPT":
-            const cacheDir = path54__namespace.join(
+            const cacheDir = path55__namespace.join(
               context2.environment?.cwd || process.cwd(),
               ".maria",
               "cache"
@@ -47839,7 +47842,7 @@ ${fixPlan.note}` : ""));
        * Create environment template
        */
       async createEnvTemplate(context2) {
-        const envPath = path54__namespace.join(
+        const envPath = path55__namespace.join(
           context2.environment?.cwd || process.cwd(),
           ".env.local"
         );
@@ -47895,7 +47898,7 @@ LOG_LEVEL=info
       async getSystemInfo(context2) {
         let mariaVersion = "Unknown";
         try {
-          const packagePath = path54__namespace.join(
+          const packagePath = path55__namespace.join(
             context2.environment?.cwd || process.cwd(),
             "package.json"
           );
@@ -49566,7 +49569,7 @@ var init_TerminalSetupCommand = __esm({
         if (_shell.includes("fish")) return "fish";
         if (_shell.includes("powershell")) return "powershell";
         if (_shell.includes("cmd")) return "cmd";
-        return path54__namespace.basename(_shell) || "unknown";
+        return path55__namespace.basename(_shell) || "unknown";
       }
       generateTerminalRecommendations(type, _features, _shell) {
         const _recommendations = [];
@@ -49883,9 +49886,9 @@ function clampInt(v, min, max, name2) {
   return Math.min(max, Math.max(min, Math.floor(n)));
 }
 function sanitizeOut(outDir, root) {
-  const full = path54__namespace.default.resolve(root, outDir);
-  const rel = path54__namespace.default.relative(root, full);
-  if (rel.startsWith("..") || path54__namespace.default.isAbsolute(rel)) throw new Error("out path escapes root");
+  const full = path55__namespace.default.resolve(root, outDir);
+  const rel = path55__namespace.default.relative(root, full);
+  if (rel.startsWith("..") || path55__namespace.default.isAbsolute(rel)) throw new Error("out path escapes root");
   return rel.replace(/\\/g, "/");
 }
 var init_Normalizer = __esm({
@@ -49897,15 +49900,15 @@ function ensureDirSync(p) {
   fs22__namespace.mkdirSync(p, { recursive: true });
 }
 function safeJoin(root, ...segs) {
-  const full = path54__namespace.resolve(root, ...segs);
-  const rel = path54__namespace.relative(root, full);
-  if (rel.startsWith("..") || path54__namespace.isAbsolute(rel)) {
+  const full = path55__namespace.resolve(root, ...segs);
+  const rel = path55__namespace.relative(root, full);
+  if (rel.startsWith("..") || path55__namespace.isAbsolute(rel)) {
     throw new Error(`path escapes root: ${segs.join("/")}`);
   }
   return { full, rel };
 }
 function stageDir(root, trace) {
-  return path54__namespace.join(root, `.stage/${trace}`);
+  return path55__namespace.join(root, `.stage/${trace}`);
 }
 async function existsSameHash(destFull) {
   try {
@@ -49970,10 +49973,10 @@ async function saveArtifacts(ctx2, items, manifest) {
       const fname = `${contentHash}${ext2}`;
       const dest = safeJoin(root, `${outDirSeg}/${fname}`);
       validateWinPathEdge(dest.full);
-      if (await hasCaseInsensitiveCollision(path54__namespace.dirname(dest.full), path54__namespace.basename(dest.full))) {
+      if (await hasCaseInsensitiveCollision(path55__namespace.dirname(dest.full), path55__namespace.basename(dest.full))) {
         throw new Error("case-insensitive filename collision");
       }
-      const stg = path54__namespace.join(stage, `${fname}.part`);
+      const stg = path55__namespace.join(stage, `${fname}.part`);
       if (await existsSameHash(dest.full)) {
         saved.push(dest.rel);
         continue;
@@ -49986,10 +49989,10 @@ async function saveArtifacts(ctx2, items, manifest) {
       manifestVersion: 1,
       ...manifest,
       createdAt: manifest.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
-      artifacts: manifest.artifacts && manifest.artifacts.length > 0 ? manifest.artifacts : saved.map((file) => ({ file, hash: `sha256:${path54__namespace.basename(file).split(".")[0]}` }))
+      artifacts: manifest.artifacts && manifest.artifacts.length > 0 ? manifest.artifacts : saved.map((file) => ({ file, hash: `sha256:${path55__namespace.basename(file).split(".")[0]}` }))
     };
     const manifestPathRel = `${outDirSeg}/manifest.json`;
-    const manifestStage = path54__namespace.join(stage, "manifest.json.part");
+    const manifestStage = path55__namespace.join(stage, "manifest.json.part");
     const manifestFull = safeJoin(root, manifestPathRel).full;
     await fsp__namespace.writeFile(manifestStage, JSON.stringify(manifestObj, null, 2), "utf8");
     await atomicRename(manifestStage, manifestFull);
@@ -50346,10 +50349,10 @@ var init_session = __esm({
         this.root = root;
       }
       file() {
-        return path54__namespace.default.join(this.root, ".maria", "memory", "session.json");
+        return path55__namespace.default.join(this.root, ".maria", "memory", "session.json");
       }
       lockFile() {
-        return path54__namespace.default.join(this.root, ".maria", "memory", ".session.lock");
+        return path55__namespace.default.join(this.root, ".maria", "memory", ".session.lock");
       }
       load() {
         try {
@@ -50364,7 +50367,7 @@ var init_session = __esm({
        */
       save(data) {
         const target = this.file();
-        const dir = path54__namespace.default.dirname(target);
+        const dir = path55__namespace.default.dirname(target);
         fs22__namespace.default.mkdirSync(dir, { recursive: true });
         try {
           this.rotateIfStale(target, 7 * 24 * 60 * 60 * 1e3);
@@ -50397,7 +50400,7 @@ var init_session = __esm({
         const body = `${pid}
 ${(/* @__PURE__ */ new Date()).toISOString()}`;
         const start = Date.now();
-        fs22__namespace.default.mkdirSync(path54__namespace.default.dirname(lockPath), { recursive: true });
+        fs22__namespace.default.mkdirSync(path55__namespace.default.dirname(lockPath), { recursive: true });
         const maxWaitTime = Date.now() + waitMs;
         while (Date.now() < maxWaitTime) {
           try {
@@ -50436,10 +50439,10 @@ ${(/* @__PURE__ */ new Date()).toISOString()}`;
           if (age > ttlMs) {
             const d = new Date(st.mtimeMs);
             const yyyymmdd = `${d.getUTCFullYear()}${String(d.getUTCMonth() + 1).padStart(2, "0")}${String(d.getUTCDate()).padStart(2, "0")}`;
-            const archiveDir = path54__namespace.default.join(path54__namespace.default.dirname(filePath), "archive", yyyymmdd);
+            const archiveDir = path55__namespace.default.join(path55__namespace.default.dirname(filePath), "archive", yyyymmdd);
             fs22__namespace.default.mkdirSync(archiveDir, { recursive: true });
             const ts = d.toISOString().replace(/[:]/g, "-");
-            const dest = path54__namespace.default.join(archiveDir, `session-${ts}.json`);
+            const dest = path55__namespace.default.join(archiveDir, `session-${ts}.json`);
             fs22__namespace.default.renameSync(filePath, dest);
           }
         } catch {
@@ -50561,7 +50564,7 @@ var init_firestore = __esm({
         return s2.slice(0, limit);
       }
       readLocal() {
-        const sessionPath = path54__namespace.default.join(this.cwd, ".maria", "memory", "session.json");
+        const sessionPath = path55__namespace.default.join(this.cwd, ".maria", "memory", "session.json");
         const candidates = [];
         try {
           const raw = JSON.parse(fs22__namespace.default.readFileSync(sessionPath, "utf8"));
@@ -50810,13 +50813,13 @@ async function hasFfmpeg() {
   });
 }
 async function muxFramesToMp4(framesDir, fps) {
-  const outFile = path54__namespace.join(framesDir, `out-${Date.now()}.mp4`);
+  const outFile = path55__namespace.join(framesDir, `out-${Date.now()}.mp4`);
   await execFfmpeg([
     "-y",
     "-framerate",
     String(fps),
     "-i",
-    path54__namespace.join(framesDir, "%06d.png"),
+    path55__namespace.join(framesDir, "%06d.png"),
     "-pix_fmt",
     "yuv420p",
     "-c:v",
@@ -50882,11 +50885,11 @@ async function runVideoPipeline(params2, opts) {
   let saved;
   let warnFallback = false;
   if (frames.length > 0 && await hasFfmpeg()) {
-    const tmpDir = path54__namespace.join(opts.root, ".stage", manifest.trace || "FFMPEG");
+    const tmpDir = path55__namespace.join(opts.root, ".stage", manifest.trace || "FFMPEG");
     await fsp__namespace.mkdir(tmpDir, { recursive: true });
     for (let i2 = 0; i2 < frames.length; i2++) {
       const fname = String(i2 + 1).padStart(6, "0") + ".png";
-      await fsp__namespace.writeFile(path54__namespace.join(tmpDir, fname), frames[i2]);
+      await fsp__namespace.writeFile(path55__namespace.join(tmpDir, fname), frames[i2]);
     }
     const outBuf = await muxFramesToMp4(tmpDir, params2.fps);
     saved = await saveArtifacts({ root: opts.root, kind: "video", baseDir: opts.outDir }, [{ bytes: outBuf, ext: ".mp4" }], manifest);
@@ -51574,7 +51577,7 @@ var init_about_command = __esm({
       async execute(args2, context2) {
         const output3 = [];
         output3.push("");
-        output3.push(chalk36__default.default.cyan.bold("\u{1F916} About MARIA v4.3.9"));
+        output3.push(chalk36__default.default.cyan.bold("\u{1F916} About MARIA v4.3.10"));
         output3.push(chalk36__default.default.gray("\u2550".repeat(40)));
         output3.push("");
         output3.push(chalk36__default.default.white.bold("MARIA - Minimal API, Maximum Power"));
@@ -53123,11 +53126,11 @@ var init_ConfigPortAdapter = __esm({
         backupCount: 5
       };
       constructor() {
-        this.globalConfigPath = path54__namespace.default.join(os16__namespace.default.homedir(), ".maria", "config.json");
-        this.userConfigPath = path54__namespace.default.join(os16__namespace.default.homedir(), ".maria", "user-config.json");
-        this.projectConfigPath = path54__namespace.default.join(process.cwd(), ".maria-config.json");
-        this.historyPath = path54__namespace.default.join(os16__namespace.default.homedir(), ".maria", "config-history.json");
-        this.templatesPath = path54__namespace.default.join(os16__namespace.default.homedir(), ".maria", "templates");
+        this.globalConfigPath = path55__namespace.default.join(os16__namespace.default.homedir(), ".maria", "config.json");
+        this.userConfigPath = path55__namespace.default.join(os16__namespace.default.homedir(), ".maria", "user-config.json");
+        this.projectConfigPath = path55__namespace.default.join(process.cwd(), ".maria-config.json");
+        this.historyPath = path55__namespace.default.join(os16__namespace.default.homedir(), ".maria", "config-history.json");
+        this.templatesPath = path55__namespace.default.join(os16__namespace.default.homedir(), ".maria", "templates");
       }
       async get(key) {
         const layered = await this.getLayered(key);
@@ -53384,7 +53387,7 @@ var init_ConfigPortAdapter = __esm({
           for (const file of files) {
             if (file.endsWith(".json")) {
               try {
-                const templatePath = path54__namespace.default.join(this.templatesPath, file);
+                const templatePath = path55__namespace.default.join(this.templatesPath, file);
                 const content = await fsp__namespace.default.readFile(templatePath, "utf-8");
                 const template = JSON.parse(content);
                 templates.push(template);
@@ -53466,7 +53469,7 @@ var init_ConfigPortAdapter = __esm({
       }
       async saveLayerConfig(layer, config2) {
         const configPath = this.getLayerConfigPath(layer);
-        await fsp__namespace.default.mkdir(path54__namespace.default.dirname(configPath), { recursive: true });
+        await fsp__namespace.default.mkdir(path55__namespace.default.dirname(configPath), { recursive: true });
         await fsp__namespace.default.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
       }
       getLayerConfigPath(layer) {
@@ -53478,7 +53481,7 @@ var init_ConfigPortAdapter = __esm({
           case "project":
             return this.projectConfigPath;
           case "runtime":
-            return path54__namespace.default.join(os16__namespace.default.tmpdir(), "maria-runtime-config.json");
+            return path55__namespace.default.join(os16__namespace.default.tmpdir(), "maria-runtime-config.json");
           default:
             return this.userConfigPath;
         }
@@ -53532,7 +53535,7 @@ var init_ConfigPortAdapter = __esm({
           const history = JSON.parse(historyContent);
           history.push(entry);
           const trimmedHistory = history.slice(-1e3);
-          await fsp__namespace.default.mkdir(path54__namespace.default.dirname(this.historyPath), { recursive: true });
+          await fsp__namespace.default.mkdir(path55__namespace.default.dirname(this.historyPath), { recursive: true });
           await fsp__namespace.default.writeFile(
             this.historyPath,
             JSON.stringify(trimmedHistory, null, 2),
@@ -53544,7 +53547,7 @@ var init_ConfigPortAdapter = __esm({
       }
       async loadTemplate(templateId) {
         try {
-          const templatePath = path54__namespace.default.join(this.templatesPath, `${templateId}.json`);
+          const templatePath = path55__namespace.default.join(this.templatesPath, `${templateId}.json`);
           const content = await fsp__namespace.default.readFile(templatePath, "utf-8");
           return JSON.parse(content);
         } catch (error2) {
@@ -54723,7 +54726,7 @@ var init_rate_limit_handler = __esm({
 async function scanRepo(cwd2) {
   if (_cache && _cache.root === cwd2) return _cache;
   const root = cwd2;
-  const pkgPath = path54.join(root, "package.json");
+  const pkgPath = path55.join(root, "package.json");
   let pkg = {};
   try {
     pkg = JSON.parse(await fsp.readFile(pkgPath, "utf8"));
@@ -54733,17 +54736,17 @@ async function scanRepo(cwd2) {
   const usesReact = !!deps["react"];
   const usesNext = !!deps["next"];
   const jsModuleType = pkg.type === "module" ? "esm" : "cjs";
-  const hasSrc = fs22.existsSync(path54.join(root, "src"));
+  const hasSrc = fs22.existsSync(path55.join(root, "src"));
   const srcRoot = hasSrc ? "src" : "";
-  const tsconfigPath = path54.join(root, "tsconfig.json");
+  const tsconfigPath = path55.join(root, "tsconfig.json");
   let usesTS = fs22.existsSync(tsconfigPath) || !!deps["typescript"];
   if (!usesTS && hasSrc) {
     const candidates = ["index.ts", "main.ts", "App.tsx"];
-    usesTS = candidates.some((f3) => fs22.existsSync(path54.join(root, "src", f3)));
+    usesTS = candidates.some((f3) => fs22.existsSync(path55.join(root, "src", f3)));
   }
-  const nextAppDir = usesNext && fs22.existsSync(path54.join(root, "app"));
+  const nextAppDir = usesNext && fs22.existsSync(path55.join(root, "app"));
   const testRunner = deps["vitest"] ? "vitest" : deps["jest"] ? "jest" : null;
-  const isMonorepo2 = fs22.existsSync(path54.join(root, "pnpm-workspace.yaml")) || fs22.existsSync(path54.join(root, "packages")) || fs22.existsSync(path54.join(root, "apps"));
+  const isMonorepo2 = fs22.existsSync(path55.join(root, "pnpm-workspace.yaml")) || fs22.existsSync(path55.join(root, "packages")) || fs22.existsSync(path55.join(root, "apps"));
   const packages = [];
   let aliasPaths = {};
   try {
@@ -54753,7 +54756,7 @@ async function scanRepo(cwd2) {
   }
   let eol = "lf";
   try {
-    const ec = await fsp.readFile(path54.join(root, ".editorconfig"), "utf8");
+    const ec = await fsp.readFile(path55.join(root, ".editorconfig"), "utf8");
     if (/end_of_line\s*=\s*crlf/i.test(ec)) eol = "crlf";
     if (/end_of_line\s*=\s*lf/i.test(ec)) eol = "lf";
   } catch {
@@ -54772,7 +54775,7 @@ function normalizePlanItem(fp, p) {
   const base = decideBaseDir(fp, p);
   const desired = sanitize(fp.path || suggestName(fp));
   const withExt = ensureExt(desired, ext2, fp.kind);
-  const rel = base ? path54.join(base, withExt) : withExt;
+  const rel = base ? path55.join(base, withExt) : withExt;
   return { ...fp, path: rel.replace(/\\/g, "/") };
 }
 function decideExt(fp, p) {
@@ -54812,10 +54815,10 @@ function suggestName(fp, p) {
   const base = (fp.description || "file").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
   return base || "file";
 }
-function guessKindByPath(path55) {
-  if (/__tests__|\.spec\.(t|j)sx?$|^tests\//.test(path55)) return "test";
-  if (/^docs\//.test(path55) || /\.md$/.test(path55)) return "doc";
-  if (/\.(json|cjs|js|ts)$/.test(path55) && !/src\//.test(path55)) return "config";
+function guessKindByPath(path56) {
+  if (/__tests__|\.spec\.(t|j)sx?$|^tests\//.test(path56)) return "test";
+  if (/^docs\//.test(path56) || /\.md$/.test(path56)) return "doc";
+  if (/\.(json|cjs|js|ts)$/.test(path56) && !/src\//.test(path56)) return "config";
   return "source";
 }
 var init_PathInferencer = __esm({
@@ -54877,15 +54880,15 @@ async function validatePlan(plans, opts) {
       skipped.push(fp.path);
       continue;
     }
-    const full = path54__namespace.default.join(opts.root, rel);
-    if (!full.startsWith(path54__namespace.default.resolve(opts.root))) {
+    const full = path55__namespace.default.join(opts.root, rel);
+    if (!full.startsWith(path55__namespace.default.resolve(opts.root))) {
       warnings.push(`Outside root denied: ${fp.path}`);
       skipped.push(fp.path);
       continue;
     }
     if (process.platform === "win32" || process.env.MOCK_WIN32 === "1") {
       const invalidChars = /[<>:"/\\|?*]/;
-      const name2 = path54__namespace.default.basename(rel);
+      const name2 = path55__namespace.default.basename(rel);
       if (invalidChars.test(rel)) {
         warnings.push(`Invalid characters in path (Windows): ${fp.path}`);
         skipped.push(fp.path);
@@ -54924,7 +54927,7 @@ async function validatePlan(plans, opts) {
     }
   }
   for (const fp of clamped) {
-    const full = path54__namespace.default.join(opts.root, fp.path);
+    const full = path55__namespace.default.join(opts.root, fp.path);
     const exists = await exists(full);
     const willModify = exists;
     if (willModify) {
@@ -54975,6 +54978,9 @@ function formatPlan(summary, opts) {
   const sep4 = " ".repeat(leftPad);
   const lines = [];
   lines.push(`Plan: ${summary.planned} files`);
+  if (opts.mode === "diff") {
+    return formatPlanAsDiff(summary.files, opts);
+  }
   for (const f3 of summary.files) {
     const kind = f3.action.padEnd(kindCol);
     const p = truncate(f3.path, pathCol);
@@ -54989,7 +54995,7 @@ function formatPlan(summary, opts) {
   return lines.join("\n");
 }
 function nextHintForPlan(requestText) {
-  return `Next: /code --apply --yes "${requestText}"  (or preview: --output detail --preview-lines 20)`;
+  return `Next: /code --apply --yes "${requestText}"  (or preview: --output diff --diff-lines 200)`;
 }
 function okLine(text) {
   return `OK: ${text}`;
@@ -55003,6 +55009,86 @@ function truncate(s2, n) {
 function headLines(s2, n) {
   return s2.split(/\r?\n/).slice(0, n);
 }
+function formatPlanAsDiff(files, opts) {
+  const budget = normalizeDiffBudget(opts.diffBudget);
+  const lines = [];
+  let bytesUsed = 0;
+  let shownFiles = 0;
+  for (const f3 of files) {
+    if (budget.globalMaxFiles !== void 0 && shownFiles >= budget.globalMaxFiles) break;
+    const before = readCurrentFileSafe(opts.root, f3.path);
+    const after = f3.preview || "";
+    const diff = unifiedSingleHunkDiff(f3.path, before, after, budget);
+    const diffBytes = Buffer.byteLength(diff, "utf8");
+    if (budget.globalMaxBytes !== void 0 && bytesUsed + diffBytes > budget.globalMaxBytes && shownFiles > 0) {
+      lines.push(`
+[truncated: global diff byte budget reached]`);
+      break;
+    }
+    lines.push(diff);
+    bytesUsed += diffBytes;
+    shownFiles++;
+  }
+  if (files.length > shownFiles) {
+    lines.push(`
+[${files.length - shownFiles} more file(s) omitted; re-run with --output diff --diff-lines ${budget.diffLines ?? 200}]`);
+  }
+  return lines.join("\n");
+}
+function readCurrentFileSafe(root, rel) {
+  if (!root) return "";
+  try {
+    const fs46 = __require("fs");
+    const p = __require("path").join(root, rel);
+    return fs46.existsSync(p) ? fs46.readFileSync(p, "utf8") : "";
+  } catch {
+    return "";
+  }
+}
+function normalizeDiffBudget(b) {
+  const envGlobalBytes = Number(process.env.MARIA_DIFF_GLOBAL_MAX_BYTES || "262144");
+  const envGlobalFiles = Number(process.env.MARIA_DIFF_GLOBAL_MAX_FILES || "20");
+  return {
+    diffLines: b?.diffLines && b.diffLines > 0 ? b.diffLines : 200,
+    diffBytes: b?.diffBytes && b.diffBytes > 0 ? b.diffBytes : 64 * 1024,
+    diffHunks: b?.diffHunks && b.diffHunks > 0 ? b.diffHunks : 8,
+    globalMaxBytes: Number.isFinite(b?.globalMaxBytes) ? b.globalMaxBytes : envGlobalBytes,
+    globalMaxFiles: Number.isFinite(b?.globalMaxFiles) ? b.globalMaxFiles : envGlobalFiles
+  };
+}
+function unifiedSingleHunkDiff(relPath, before, after, b) {
+  const beforeLines = before.split(/\r?\n/);
+  const afterLines = after.split(/\r?\n/);
+  let i2 = 0;
+  while (i2 < beforeLines.length && i2 < afterLines.length && beforeLines[i2] === afterLines[i2]) i2++;
+  let j = 0;
+  while (j < beforeLines.length - i2 && j < afterLines.length - i2 && beforeLines[beforeLines.length - 1 - j] === afterLines[afterLines.length - 1 - j]) j++;
+  const oldMid = beforeLines.slice(i2, beforeLines.length - j);
+  const newMid = afterLines.slice(i2, afterLines.length - j);
+  const header = [`--- a/${relPath}`, `+++ b/${relPath}`];
+  const body = [];
+  const ctxPrefix = Math.max(0, i2 - 3);
+  Math.min(beforeLines.length, beforeLines.length - j + 3);
+  const preCtx = beforeLines.slice(ctxPrefix, i2).map((l) => ` ${l}`);
+  const postCtx = beforeLines.slice(beforeLines.length - j, Math.min(beforeLines.length - j + 3, beforeLines.length)).map((l) => ` ${l}`);
+  const del = oldMid.map((l) => `-${l}`);
+  const add = newMid.map((l) => `+${l}`);
+  body.push(...preCtx);
+  body.push(...del);
+  body.push(...add);
+  body.push(...postCtx);
+  const maxLines = b.diffLines;
+  let sliced = body.slice(0, maxLines);
+  let out = header.concat(sliced).join("\n");
+  if (sliced.length < body.length) out += `
+[truncated ${body.length - sliced.length} line(s); re-run with higher --diff-lines]`;
+  if (Buffer.byteLength(out, "utf8") > b.diffBytes) {
+    while (sliced.length > 0 && Buffer.byteLength(header.concat(sliced).join("\n"), "utf8") > b.diffBytes) sliced = sliced.slice(0, Math.max(0, sliced.length - 10));
+    out = header.concat(sliced).join("\n") + `
+[truncated by byte budget]`;
+  }
+  return out;
+}
 var init_OutputFormatter = __esm({
   "src/services/code-orchestrator/OutputFormatter.ts"() {
   }
@@ -55013,64 +55099,63 @@ async function interactiveApprovePlan(files, opts = {}) {
   if (!process.stdin.isTTY) {
     return { approveAll: false, approved: /* @__PURE__ */ new Set(), skipped: /* @__PURE__ */ new Set(), cancelled: true };
   }
-  const first = await ask(`Approve entire plan? [a=all / q=cancel] `, timeoutMs);
+  const first = await ask(`Approve all [A] / review [r] / cancel [q]: `, timeoutMs);
   if (!first.ok) {
     return { approveAll: false, approved: /* @__PURE__ */ new Set(), skipped: /* @__PURE__ */ new Set(), cancelled: true };
   }
-  const ans1 = (first.line || "").trim().toLowerCase();
-  if (ans1 === "q") return { approveAll: false, approved: /* @__PURE__ */ new Set(), skipped: /* @__PURE__ */ new Set(), cancelled: true };
-  if (ans1 === "a" || autoSelect && ans1 === "") return { approveAll: true, approved: /* @__PURE__ */ new Set(), skipped: /* @__PURE__ */ new Set(), cancelled: false };
+  const a1 = (first.line || "").trim().toLowerCase();
+  if (a1 === "q") return { approveAll: false, approved: /* @__PURE__ */ new Set(), skipped: /* @__PURE__ */ new Set(), cancelled: true };
+  if (a1 === "a" || autoSelect && a1 === "") return { approveAll: true, approved: /* @__PURE__ */ new Set(), skipped: /* @__PURE__ */ new Set(), cancelled: false };
   const approved = /* @__PURE__ */ new Set();
   const skipped = /* @__PURE__ */ new Set();
-  for (const f3 of files) {
-    const short = `${f3.action} ${f3.path}`;
-    const out = await ask(`${short}  [a=approve / s=skip / v=view / d=diff / q=cancel] `, timeoutMs);
+  let i2 = 0;
+  const total = files.length;
+  while (i2 >= 0 && i2 < total) {
+    const f3 = files[i2];
+    process.stdout.write(`\rfile ${i2 + 1}/${total}: ${f3.action} ${f3.path}           
+`);
+    const out = await ask(`[n]ext [p]rev [a]pprove [s]kip [v]iew [d]iff [aa] all [ss] skip [q]uit: `, timeoutMs);
     if (!out.ok) {
       console.log("Interactive prompt timed out (15s). Cancelled.");
       return { approveAll: false, approved, skipped, cancelled: true };
     }
     const ans = (out.line || "").trim().toLowerCase();
     if (ans === "q") return { approveAll: false, approved, skipped, cancelled: true };
+    if (ans === "n" || ans === "") {
+      i2++;
+      continue;
+    }
+    if (ans === "p") {
+      i2 = Math.max(0, i2 - 1);
+      continue;
+    }
+    if (ans === "aa") {
+      for (const x2 of files) approved.add(x2.path);
+      break;
+    }
+    if (ans === "ss") {
+      for (const x2 of files) skipped.add(x2.path);
+      break;
+    }
+    if (ans === "a") {
+      approved.add(f3.path);
+      i2++;
+      continue;
+    }
     if (ans === "s") {
       skipped.add(f3.path);
+      i2++;
       continue;
     }
     if (ans === "v") {
-      if (f3.preview) console.log(head(f3.preview, 20));
-      else console.log("(no preview)");
-      const again = await ask(`Approve? [a / s / q] `, timeoutMs);
-      if (!again.ok) return { approveAll: false, approved, skipped, cancelled: true };
-      const ans2 = (again.line || "").trim().toLowerCase();
-      if (ans2 === "q") return { approveAll: false, approved, skipped, cancelled: true };
-      if (ans2 === "s") {
-        skipped.add(f3.path);
-        continue;
-      }
-      approved.add(f3.path);
-    } else if (ans === "d") {
-      try {
-        const fs45 = await import('fs/promises');
-        const p = (opts.root || process.cwd()) + "/" + f3.path;
-        const current = await fs45.readFile(p, "utf8").catch(() => "");
-        console.log("--- current (head) ---");
-        console.log(head(current, 20) || "(file does not exist)");
-        console.log("--- proposed (head) ---");
-        console.log(head(f3.preview || "", 20) || "(no preview)");
-      } catch {
-      }
-      const again = await ask(`Approve? [a / s / q] `, timeoutMs);
-      if (!again.ok) return { approveAll: false, approved, skipped, cancelled: true };
-      const ans2 = (again.line || "").trim().toLowerCase();
-      if (ans2 === "q") return { approveAll: false, approved, skipped, cancelled: true };
-      if (ans2 === "s") {
-        skipped.add(f3.path);
-        continue;
-      }
-      approved.add(f3.path);
-    } else {
-      if (ans === "a" || ans === "") approved.add(f3.path);
-      else skipped.add(f3.path);
+      console.log(f3.preview ? head(f3.preview, 20) : "(no preview)");
+      continue;
     }
+    if (ans === "d") {
+      await showHeadDiff(opts.root || process.cwd(), f3.path, f3.preview || "");
+      continue;
+    }
+    i2++;
   }
   return { approveAll: false, approved, skipped, cancelled: false };
 }
@@ -55108,10 +55193,187 @@ function ask(prompt, timeoutMs) {
 function head(s2, n) {
   return s2.split(/\r?\n/).slice(0, n).join("\n");
 }
+async function showHeadDiff(root, rel, proposal) {
+  try {
+    const fs46 = await import('fs/promises');
+    const p = __require("path").join(root, rel);
+    const current = await fs46.readFile(p, "utf8").catch(() => "");
+    console.log("--- current (head) ---");
+    console.log(head(current, 20) || "(file does not exist)");
+    console.log("--- proposed (head) ---");
+    console.log(head(proposal, 20) || "(no preview)");
+  } catch {
+  }
+}
 var init_InteractiveController = __esm({
   "src/services/code-orchestrator/InteractiveController.ts"() {
   }
 });
+async function mapAttachmentsToTargets(attached, opts) {
+  const warnings = [];
+  const mapped = [];
+  const ambiguous = [];
+  const root = path55__namespace.default.resolve(opts.root);
+  const maxN = Math.min(attached.length, Math.max(1, opts.maxAttachments));
+  const pool = attached.slice(0, maxN);
+  if (attached.length > maxN) warnings.push(`Attachments clamped: ${attached.length} \u2192 ${maxN}`);
+  const repoFiles = await listRepoFiles(root);
+  for (const a of pool) {
+    if (!Number.isFinite(a.size) || a.size > PER_FILE_SIZE_CAP) {
+      warnings.push(`Attachment too large (>${PER_FILE_SIZE_CAP} bytes): ${a.originalName}`);
+      continue;
+    }
+    if (looksBinary(a.content, a.mime)) {
+      warnings.push(`Binary/non-text attachment skipped: ${a.originalName}`);
+      continue;
+    }
+    if (a.pathHint) {
+      const safeRel = sanitizeRel(a.pathHint);
+      const full = path55__namespace.default.join(root, safeRel);
+      if (!full.startsWith(root)) {
+        warnings.push(`Path traversal/absolute denied: ${a.pathHint}`);
+      } else if (!opts.allowDotfiles && hasDotSegment(safeRel)) {
+        warnings.push(`Dotfile path denied: ${a.pathHint}`);
+      } else {
+        const exists = repoFiles.has(safeRel);
+        mapped.push({ path: safeRel, exists, reason: "pathHint", attachment: a });
+        continue;
+      }
+    }
+    const name2 = a.originalName.toLowerCase();
+    const matches = Array.from(repoFiles.values()).filter((p) => path55__namespace.default.basename(p).toLowerCase() === name2);
+    if (matches.length === 1) {
+      mapped.push({ path: matches[0], exists: true, reason: "filename", attachment: a });
+      continue;
+    } else if (matches.length > 1) ;
+    const ext2 = extOf(name2);
+    const candidates = Array.from(repoFiles.values()).filter((p) => extOf(p.toLowerCase()) === ext2);
+    let best = null;
+    let second = null;
+    const head2 = headText(a.content, 20);
+    const tail = tailText(a.content, 20);
+    for (const p of candidates.slice(0, 500)) {
+      let score = 0;
+      try {
+        const full = path55__namespace.default.join(root, p);
+        const body = await safeReadHeadTail(full, 20);
+        score = jaccard(tokens(head2), tokens(body.head)) * 0.6 + jaccard(tokens(tail), tokens(body.tail)) * 0.4;
+      } catch {
+      }
+      if (!best || score > best.score) {
+        second = best;
+        best = { p, score };
+      } else if (!second || score > second.score) {
+        second = { p, score };
+      }
+    }
+    if (best && (second ? best.score - second.score >= 0.2 : best.score >= 0.3)) {
+      mapped.push({ path: best.p, exists: true, reason: "fuzzy", attachment: a });
+      continue;
+    }
+    const proposed = proposePath(root, a.originalName);
+    if (!opts.allowDotfiles && hasDotSegment(proposed)) {
+      if (opts.mode === "strict") {
+        warnings.push(`Proposed dotfile denied under strict mode: ${proposed}`);
+        continue;
+      }
+    }
+    if (opts.mode === "strict" && (matches.length > 1 || best && second && best.score - second.score < 0.2)) {
+      ambiguous.push({ attachment: a, candidates: matches, reason: "ambiguous" });
+      continue;
+    }
+    mapped.push({ path: proposed, exists: false, reason: "proposed", attachment: a });
+  }
+  return { mapped, ambiguous, warnings };
+}
+function sanitizeRel(rel) {
+  const s2 = rel.replace(/^\/+/, "").replace(/\r|\n/g, "").replace(/\\/g, "/");
+  return s2.replace(/\.\.+/g, "");
+}
+function hasDotSegment(p) {
+  return p.split(/\/+|\\+/).some((seg) => seg.startsWith("."));
+}
+function looksBinary(content, mime) {
+  if (mime && !/^text\//i.test(mime)) return true;
+  let nul = 0;
+  const len = Math.min(content.length, PER_FILE_SIZE_CAP);
+  for (let i2 = 0; i2 < len; i2++) if (content.charCodeAt(i2) === 0) nul++;
+  return len > 0 && nul / len > 0.1;
+}
+async function listRepoFiles(root) {
+  const out = /* @__PURE__ */ new Set();
+  async function walk2(dir, relBase) {
+    let entries = [];
+    try {
+      entries = await fs22.promises.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e2 of entries) {
+      const name2 = e2.name;
+      if (name2 === ".git" || name2 === "node_modules" || name2 === "dist" || name2 === ".maria") continue;
+      const full = path55__namespace.default.join(dir, name2);
+      const rel = path55__namespace.default.relative(root, full).replace(/\\/g, "/");
+      if (e2.isDirectory()) {
+        await walk2(full);
+        continue;
+      }
+      out.add(rel);
+    }
+  }
+  await walk2(root);
+  return out;
+}
+function extOf(name2) {
+  const i2 = name2.lastIndexOf(".");
+  return i2 >= 0 ? name2.slice(i2 + 1) : "";
+}
+function headText(s2, n) {
+  return s2.split(/\r?\n/).slice(0, n).join("\n");
+}
+function tailText(s2, n) {
+  const a = s2.split(/\r?\n/);
+  return a.slice(Math.max(0, a.length - n)).join("\n");
+}
+async function safeReadHeadTail(full, n) {
+  try {
+    const buf = await fs22.promises.readFile(full, "utf8");
+    return { head: headText(buf, n), tail: tailText(buf, n) };
+  } catch {
+    return { head: "", tail: "" };
+  }
+}
+function tokens(s2) {
+  return new Set(s2.toLowerCase().split(/[^a-z0-9_]+/).filter(Boolean));
+}
+function jaccard(a, b) {
+  if (a.size === 0 && b.size === 0) return 1;
+  let inter = 0;
+  for (const t2 of a) if (b.has(t2)) inter++;
+  const union = a.size + b.size - inter;
+  return union === 0 ? 0 : inter / union;
+}
+function proposePath(root, original) {
+  const base = path55__namespace.default.basename(original).replace(/\s+/g, "-").replace(/[^a-zA-Z0-9._-]/g, "").toLowerCase();
+  const src = path55__namespace.default.join(root, "src");
+  const dir = existsSync8(src) ? "src" : "";
+  const rel = dir ? path55__namespace.default.join(dir, base) : base;
+  return rel.replace(/\\/g, "/");
+}
+function existsSync8(p) {
+  try {
+    __require("fs").accessSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var PER_FILE_SIZE_CAP;
+var init_AttachmentMapper = __esm({
+  "src/services/code-orchestrator/AttachmentMapper.ts"() {
+    PER_FILE_SIZE_CAP = 256 * 1024;
+  }
+});
 
 // src/services/code-orchestrator/Orchestrator.ts
 var Orchestrator_exports = {};
@@ -55120,26 +55382,92 @@ __export(Orchestrator_exports, {
 });
 async function orchestrate(request, opts) {
   const profile = await scanRepo(opts.root);
-  const result = process.env.MARIA_E2E_FAKE_CODE === "1" ? { output: "```ts\nexport const demo=1;\n```" } : await executeCode(request);
-  const blocks = extractBlocks(result.output || "");
-  const initial = blocks.map((b, i2) => ({
-    path: suggestName2(request, b.language, i2),
-    kind: "source",
-    action: "create",
-    description: describe2(b.language, ""),
-    language: b.language,
-    preview: b.code
-  }));
+  const initial = [];
+  let attachWarnings = [];
+  if (opts.attachedFiles && opts.attachedFiles.length > 0) {
+    const mapRes = await mapAttachmentsToTargets(opts.attachedFiles, {
+      root: opts.root,
+      mode: opts.flags.attachMode || "assist",
+      maxAttachments: opts.flags.maxAttachments || 50,
+      allowDotfiles: !!opts.flags.allowDotfiles
+    });
+    attachWarnings = mapRes.warnings.slice();
+    for (const m2 of mapRes.mapped) {
+      initial.push({
+        path: m2.path,
+        kind: "source",
+        action: m2.exists ? "modify" : "create",
+        description: m2.exists ? "Modify (attachment)" : "Create (attachment)",
+        preview: m2.attachment.content
+      });
+    }
+  }
+  const onlyAttached = !!opts.flags.onlyAttached;
+  const explicitFiles = parseExplicitFilenames(request);
+  if (!onlyAttached) {
+    const result = process.env.MARIA_E2E_FAKE_CODE === "1" ? { output: "```ts\nexport const demo=1;\n```" } : await executeCode(request);
+    const blocks = extractBlocks(result.output || "");
+    if (explicitFiles.length > 0) {
+      const mapped = /* @__PURE__ */ new Set();
+      const htmlIdx = blocks.findIndex((b) => /html/i.test(b.language));
+      const htmlFile = explicitFiles.find((f3) => f3.toLowerCase().endsWith(".html"));
+      if (htmlIdx >= 0 && htmlFile) {
+        initial.push({ path: htmlFile, kind: "source", action: "create", description: "HTML page", language: "html", preview: blocks[htmlIdx].code });
+        mapped.add(htmlFile);
+      }
+      const jsIdx = blocks.findIndex((b) => /(ts|tsx|jsx|javascript|js)/i.test(b.language));
+      const jsFile = explicitFiles.find((f3) => f3.toLowerCase().endsWith(".js"));
+      if (jsIdx >= 0 && jsFile && !mapped.has(jsFile)) {
+        initial.push({ path: jsFile, kind: "source", action: "create", description: "Script", language: "javascript", preview: blocks[jsIdx].code });
+        mapped.add(jsFile);
+      }
+      const cssIdx = blocks.findIndex((b) => /css/i.test(b.language));
+      const cssFile = explicitFiles.find((f3) => f3.toLowerCase().endsWith(".css"));
+      if (cssIdx >= 0 && cssFile && !mapped.has(cssFile)) {
+        initial.push({ path: cssFile, kind: "source", action: "create", description: "Stylesheet", language: "css", preview: blocks[cssIdx].code });
+        mapped.add(cssFile);
+      }
+      for (const f3 of explicitFiles) {
+        if (mapped.has(f3)) continue;
+        initial.push(scaffoldForFilename(f3, explicitFiles));
+      }
+    } else {
+      for (let i2 = 0; i2 < blocks.length; i2++) {
+        const b = blocks[i2];
+        initial.push({
+          path: suggestName2(request, b.language, i2),
+          kind: "source",
+          action: "create",
+          description: describe2(b.language, ""),
+          language: b.language,
+          preview: b.code
+        });
+      }
+    }
+  }
+  if (explicitFiles.length > 0 && initial.filter((f3) => !!f3.preview).length === 0) {
+    for (const f3 of explicitFiles) {
+      initial.push(scaffoldForFilename(f3, explicitFiles));
+    }
+  }
   const normalized = await normalizePlans(initial, { root: opts.root });
   const validated = await validatePlan(normalized, { root: opts.root, profile, flags: { maxFiles: opts.flags.maxFiles, yes: opts.flags.yes, interactive: !!opts.flags.interactive, ...opts.flags } });
   const outputMode = resolveOutputMode(opts.flags.output, validated.files.length, !!opts.flags.hideCode);
   const summary = summarizePlan(validated.files);
   const lines = [
-    formatPlan(summary, { mode: outputMode, previewLines: normalizePreviewLines(opts.flags.previewLines) })
+    formatPlan(summary, {
+      mode: outputMode,
+      previewLines: normalizePreviewLines(opts.flags.previewLines),
+      diffBudget: collectDiffBudget(opts.flags),
+      root: opts.root
+    })
   ];
   if (validated.warnings.length) {
     for (const w of validated.warnings) lines.push(`WARN: ${w}`);
   }
+  if (attachWarnings.length) {
+    for (const w of attachWarnings) lines.push(`WARN: ${w}`);
+  }
   if (opts.flags.planOnly || opts.flags.dryRun || !opts.flags.apply) {
     lines.push("", nextHintForPlan(request));
     return { plan: normalized, validated, summaryLines: lines };
@@ -55161,6 +55489,14 @@ async function orchestrate(request, opts) {
     }
     approved = approved.map((f3) => f3.action === "modify" ? { ...f3, overwritePolicy: "allow" } : f3);
   }
+  const softIssues = scanSoftIssues(approved);
+  if ((softIssues.hasTrailingWhitespace || softIssues.hasConflictMarkers) && !opts.flags.interactive && !opts.flags.yes && opts.flags.apply) {
+    lines.push("");
+    if (softIssues.hasTrailingWhitespace) lines.push(warnLine("Proposed changes contain trailing whitespace"));
+    if (softIssues.hasConflictMarkers) lines.push(warnLine("Proposed changes contain conflict markers"));
+    lines.push("Tip: Re-run with --yes to apply anyway, or use --interactive to review.");
+    return { plan: normalized, validated, summaryLines: lines };
+  }
   let appliedCount = 0;
   let durationMs = 0;
   let rolledBack = false;
@@ -55217,6 +55553,15 @@ function resolveOutputMode(mode, count, hideCode) {
   if (mode) return mode;
   return count >= 5 ? "summary" : "detail";
 }
+function collectDiffBudget(flags) {
+  return {
+    diffLines: normalizePreviewLines(flags?.diffLines) || void 0,
+    diffBytes: normalizePreviewLines(flags?.diffBytes) || void 0,
+    diffHunks: normalizePreviewLines(flags?.diffHunks) || void 0,
+    globalMaxBytes: typeof flags?.diffGlobalMaxBytes === "number" ? flags.diffGlobalMaxBytes : void 0,
+    globalMaxFiles: typeof flags?.diffGlobalMaxFiles === "number" ? flags.diffGlobalMaxFiles : void 0
+  };
+}
 function extractBlocks(content) {
   const blocks = [];
   const re = /```(\w*)\n([\s\S]*?)```/g;
@@ -55254,12 +55599,12 @@ function languageExt(lang) {
 }
 async function journalResume(root, request, files) {
   try {
-    const fs45 = await import('fs/promises');
-    const dir = path54__namespace.default.join(root, ".maria", "memory");
-    await fs45.mkdir(dir, { recursive: true });
-    const out = path54__namespace.default.join(dir, "resume-plan.json");
+    const fs46 = await import('fs/promises');
+    const dir = path55__namespace.default.join(root, ".maria", "memory");
+    await fs46.mkdir(dir, { recursive: true });
+    const out = path55__namespace.default.join(dir, "resume-plan.json");
     const payload = { request, createdAt: (/* @__PURE__ */ new Date()).toISOString(), files };
-    await fs45.writeFile(out, JSON.stringify(payload, null, 2), "utf8");
+    await fs46.writeFile(out, JSON.stringify(payload, null, 2), "utf8");
   } catch {
   }
 }
@@ -55355,6 +55700,72 @@ async function buildAutoTag(prefix) {
     return `${prefix}${Date.now()}`;
   }
 }
+function scanSoftIssues(files) {
+  let tw = false;
+  let cm = false;
+  for (const f3 of files) {
+    const body = f3.preview || "";
+    if (!tw && /\s+$/.test(body.split(/\r?\n/).find((l) => /\s+$/.test(l)) || "")) tw = true;
+    if (!cm && /(<<<<<<<|=======|>>>>>>>)\s/.test(body)) cm = true;
+    if (tw && cm) break;
+  }
+  return { hasTrailingWhitespace: tw, hasConflictMarkers: cm };
+}
+function parseExplicitFilenames(request) {
+  const matches = request.match(/([\w.-]+\.(?:html|css|js|jsx|ts|tsx))/gi);
+  if (!matches) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const m2 of matches) {
+    const rel = m2.replace(/^\/+/, "").replace(/\r|\n/g, "");
+    if (rel.includes("..")) continue;
+    if (!seen.has(rel)) {
+      seen.add(rel);
+      out.push(rel);
+    }
+  }
+  return out;
+}
+function scaffoldForFilename(filename, all) {
+  const lower2 = filename.toLowerCase();
+  if (lower2.endsWith(".html")) {
+    const css = all.find((f3) => f3.toLowerCase().endsWith(".css")) || "style.css";
+    const js = all.find((f3) => f3.toLowerCase().endsWith(".js")) || "script.js";
+    const body = `<!doctype html>
+<html lang="ja">
+<head>
+  <meta charset="utf-8"/>
+  <meta name="viewport" content="width=device-width, initial-scale=1"/>
+  <title>Pong</title>
+  <link rel="stylesheet" href="${css}">
+</head>
+<body>
+  <canvas id="game" width="640" height="480"></canvas>
+  <script src="${js}"></script>
+</body>
+</html>
+`;
+    return { path: filename, kind: "source", action: "create", description: "HTML page", language: "html", preview: body };
+  }
+  if (lower2.endsWith(".css")) {
+    const body = `html,body{margin:0;height:100%;background:#111;color:#eee;font-family:system-ui,sans-serif}
+#game{display:block;margin:0 auto;background:#000;border:2px solid #444}`;
+    return { path: filename, kind: "source", action: "create", description: "Stylesheet", language: "css", preview: body };
+  }
+  if (lower2.endsWith(".js")) {
+    const body = `// Minimal Pong scaffold
+const canvas = document.getElementById('game');
+const ctx = canvas.getContext('2d');
+let last = 0;
+const state = { ball:{x:320,y:240,vx:3,vy:2,r:6}, p1:{y:200}, p2:{y:200} };
+function step(t){ const dt=(t-last)||16; last=t; update(dt); draw(); requestAnimationFrame(step); }
+function update(dt){ const b=state.ball; b.x+=b.vx; b.y+=b.vy; if(b.y<0||b.y>canvas.height) b.vy*=-1; if(b.x<0||b.x>canvas.width) b.vx*=-1; }
+function draw(){ ctx.clearRect(0,0,canvas.width,canvas.height); const b=state.ball; ctx.fillStyle='#0f0'; ctx.fillRect(20,state.p1.y,10,80); ctx.fillRect(canvas.width-30,state.p2.y,10,80); ctx.fillStyle='#fff'; ctx.beginPath(); ctx.arc(b.x,b.y,b.r,0,Math.PI*2); ctx.fill(); }
+requestAnimationFrame(step);`;
+    return { path: filename, kind: "source", action: "create", description: "Script", language: "javascript", preview: body };
+  }
+  return { path: filename, kind: "source", action: "create", description: "Source file", preview: "" };
+}
 var init_Orchestrator = __esm({
   "src/services/code-orchestrator/Orchestrator.ts"() {
     init_RepoScanner();
@@ -55366,6 +55777,7 @@ var init_Orchestrator = __esm({
     init_api_caller();
     init_AuthenticationManager();
     init_MariaAPIClient();
+    init_AttachmentMapper();
   }
 });
 
@@ -55403,7 +55815,7 @@ var init_code_command = __esm({
       name = "code";
       category = "code";
       description = "Generate code with AI";
-      usage = "<request> [--plan-only|--sow] [--apply] [--dry-run] [--interactive] [--yes] [--max-files N] [--root DIR] [--rollback on|off] [--output names|summary|detail] [--no-code] [--preview-lines N]";
+      usage = "<request> [--plan-only|--sow] [--apply] [--dry-run] [--interactive] [--yes] [--max-files N] [--root DIR] [--rollback on|off] [--output names|summary|detail|diff] [--no-code] [--preview-lines N] [--only-attached] [--attach-mode strict|assist] [--max-attachments N] [--diff-lines N] [--diff-bytes N] [--diff-hunks N]";
       aliases = ["c"];
       examples = [
         {
@@ -55426,11 +55838,12 @@ var init_code_command = __esm({
           const opts = this.parseV2Options(commandArgs.raw);
           const root = opts.root || process.cwd();
           const { orchestrate: orchestrate2 } = await Promise.resolve().then(() => (init_Orchestrator(), Orchestrator_exports));
+          const attachments = await this.collectAttachedFiles(context2).catch(() => []);
           const abort = new AbortController();
           const onSigint = () => abort.abort();
           process.once("SIGINT", onSigint);
           try {
-            const res = await orchestrate2(request, { root, flags: { planOnly: opts.planOnly, apply: opts.apply, dryRun: opts.dryRun, interactive: opts.interactive, yes: opts.yes, maxFiles: opts.maxFiles, output: opts.output, hideCode: opts.noCode, previewLines: this.normalizePreviewLines(opts.previewLines), verbose: opts.verbose }, abortSignal: abort.signal });
+            const res = await orchestrate2(request, { root, flags: { planOnly: opts.planOnly, apply: opts.apply, dryRun: opts.dryRun, interactive: opts.interactive, yes: opts.yes, maxFiles: opts.maxFiles, output: opts.output, hideCode: opts.noCode, previewLines: this.normalizePreviewLines(opts.previewLines), verbose: opts.verbose, onlyAttached: opts.onlyAttached, attachMode: opts.attachMode, maxAttachments: opts.maxAttachments, diffLines: opts.diffLines, diffBytes: opts.diffBytes, diffHunks: opts.diffHunks, allowDotfiles: opts.allowDotfiles }, abortSignal: abort.signal, attachedFiles: attachments });
             const out = res.summaryLines.join("\n");
             return this.success(out);
           } finally {
@@ -55479,7 +55892,7 @@ ${pretty}`);
       }
       // v2.0 helpers
       parseV2Options(raw) {
-        const opts = { planOnly: false, apply: false, dryRun: false, interactive: false, yes: false, rollback: true, output: void 0, noCode: false, previewLines: 0, root: void 0, maxFiles: void 0, verbose: false, gitGuard: void 0, allowDotfiles: false, confirmOverwrites: [], gitCommit: void 0, gitBranch: void 0, gitTag: void 0, gitTagPrefix: void 0, gitPush: void 0, gitPushRemote: void 0 };
+        const opts = { planOnly: false, apply: false, dryRun: false, interactive: false, yes: false, rollback: true, output: void 0, noCode: false, previewLines: 0, root: void 0, maxFiles: void 0, verbose: false, gitGuard: void 0, allowDotfiles: false, confirmOverwrites: [], gitCommit: void 0, gitBranch: void 0, gitTag: void 0, gitTagPrefix: void 0, gitPush: void 0, gitPushRemote: void 0, onlyAttached: false, attachMode: "assist", maxAttachments: 50, diffLines: void 0, diffBytes: void 0, diffHunks: void 0 };
         const a = raw.slice();
         while (a.length) {
           const x2 = a.shift();
@@ -55534,6 +55947,26 @@ ${pretty}`);
             case "allow-dotfiles":
               opts.allowDotfiles = true;
               break;
+            case "only-attached":
+              opts.onlyAttached = true;
+              break;
+            case "attach-mode": {
+              const val = (v || a.shift() || "").toLowerCase();
+              opts.attachMode = val === "strict" || val === "assist" ? val : "assist";
+              break;
+            }
+            case "max-attachments":
+              opts.maxAttachments = Number(v || a.shift());
+              break;
+            case "diff-lines":
+              opts.diffLines = Number(v || a.shift());
+              break;
+            case "diff-bytes":
+              opts.diffBytes = Number(v || a.shift());
+              break;
+            case "diff-hunks":
+              opts.diffHunks = Number(v || a.shift());
+              break;
             case "confirm-overwrites": {
               const list = (v || a.shift() || "").split(",").map((s2) => s2.trim()).filter(Boolean);
               opts.confirmOverwrites = list;
@@ -55595,7 +56028,7 @@ ${pretty}`);
         const { normalizePlans: normalizePlans2 } = await Promise.resolve().then(() => (init_FilePlanBuilder(), FilePlanBuilder_exports));
         const normalized = await normalizePlans2(plans, { root });
         for (const p of normalized) {
-          const exists = await this.pathExists(path54__namespace.join(root, p.path));
+          const exists = await this.pathExists(path55__namespace.join(root, p.path));
           p.action = exists ? "modify" : "create";
         }
         return normalized;
@@ -55610,16 +56043,16 @@ ${pretty}`);
       }
       async persistLastPlan(root, plans) {
         try {
-          const fs45 = await import('fs/promises');
-          const p = path54__namespace.join(root, ".maria");
-          await fs45.mkdir(p, { recursive: true });
-          const out = path54__namespace.join(p, "last-plan.json");
-          await fs45.writeFile(out, JSON.stringify({ createdAt: (/* @__PURE__ */ new Date()).toISOString(), plans }, null, 2), "utf8");
+          const fs46 = await import('fs/promises');
+          const p = path55__namespace.join(root, ".maria");
+          await fs46.mkdir(p, { recursive: true });
+          const out = path55__namespace.join(p, "last-plan.json");
+          await fs46.writeFile(out, JSON.stringify({ createdAt: (/* @__PURE__ */ new Date()).toISOString(), plans }, null, 2), "utf8");
         } catch {
         }
       }
       async applyPlan(plans, options) {
-        const fs45 = await import('fs/promises');
+        const fs46 = await import('fs/promises');
         const created = [];
         const modified = [];
         const skipped = [];
@@ -55629,7 +56062,7 @@ ${pretty}`);
         try {
           for (const plan of plans) {
             if (options.signal?.aborted) throw new Error("INTERRUPTED");
-            const full = path54__namespace.join(options.root, plan.path);
+            const full = path55__namespace.join(options.root, plan.path);
             const exists = await this.pathExists(full);
             if (exists && !options.overwriteAllowed) {
               skipped.push(plan.path);
@@ -55638,9 +56071,9 @@ ${pretty}`);
               continue;
             }
             const tmp = full + `.tmp-${process.pid}-${Date.now()}`;
-            await fs45.mkdir(path54__namespace.dirname(full), { recursive: true });
-            await fs45.writeFile(tmp, plan.preview || "", "utf8");
-            await fs45.rename(tmp, full);
+            await fs46.mkdir(path55__namespace.dirname(full), { recursive: true });
+            await fs46.writeFile(tmp, plan.preview || "", "utf8");
+            await fs46.rename(tmp, full);
             if (exists) modified.push(plan.path);
             else created.push(plan.path);
             written++;
@@ -55651,7 +56084,7 @@ ${pretty}`);
           if (options.rollback) {
             for (const p of [...created, ...modified]) {
               try {
-                await fs45.unlink(path54__namespace.join(options.root, p));
+                await fs46.unlink(path55__namespace.join(options.root, p));
               } catch {
               }
             }
@@ -55661,8 +56094,8 @@ ${pretty}`);
       }
       async pathExists(p) {
         try {
-          const fs45 = await import('fs/promises');
-          await fs45.access(p);
+          const fs46 = await import('fs/promises');
+          await fs46.access(p);
           return true;
         } catch {
           return false;
@@ -55731,13 +56164,13 @@ ${pretty}`);
         const extension = LANGUAGE_EXTENSIONS[block.language] || ".txt";
         const timestamp = Date.now().toString(36);
         const filename = index === 0 ? `${baseName}${extension}` : `${baseName}_${index + 1}${extension}`;
-        const fullPath = path54__namespace.join(process.cwd(), filename);
+        const fullPath = path55__namespace.join(process.cwd(), filename);
         try {
           await fsp.writeFile(fullPath, block.code, "utf8");
           return fullPath;
         } catch (error2) {
           const fallbackName = `code_${timestamp}${extension}`;
-          const fallbackPath = path54__namespace.join(process.cwd(), fallbackName);
+          const fallbackPath = path55__namespace.join(process.cwd(), fallbackName);
           await fsp.writeFile(fallbackPath, block.code, "utf8");
           return fallbackPath;
         }
@@ -55767,6 +56200,28 @@ ${pretty}`);
         }
         return null;
       }
+      // Attempt to collect attached files from context; map to AttachedFileContext
+      async collectAttachedFiles(context2) {
+        const list = [];
+        const fs46 = await import('fs/promises');
+        const path56 = await import('path');
+        const att = context2 && (context2.attachments || context2.input?.attachments) || [];
+        for (const a of att) {
+          try {
+            const p = a.path || a.filePath || a.name || "";
+            const originalName = a.name || path56.basename(p || `attachment_${Date.now().toString(36)}`);
+            let content = a.content;
+            if (!content && p) {
+              const abs = path56.isAbsolute(p) ? p : path56.join(process.cwd(), p);
+              content = await fs46.readFile(abs, "utf8");
+            }
+            if (!content) continue;
+            list.push({ originalName, pathHint: p || void 0, content, size: Buffer.byteLength(content, "utf8"), mime: a.mime || a.type });
+          } catch {
+          }
+        }
+        return list;
+      }
     };
     codeCommand = new CodeCommand();
     metadata4 = {
@@ -55867,7 +56322,7 @@ function getKnowledgeProviderFromEnv(root = process.cwd()) {
 function safeListFiles(dir) {
   try {
     return fs22__namespace.default.readdirSync(dir, { withFileTypes: true }).flatMap((d) => {
-      const p = path54__namespace.default.join(dir, d.name);
+      const p = path55__namespace.default.join(dir, d.name);
       if (d.isDirectory()) {
         if (/node_modules|\.git|dist|coverage|artifacts|reports/.test(p)) return [];
         return safeListFiles(p);
@@ -55903,7 +56358,7 @@ var init_KnowledgeProvider = __esm({
       }
       async getPrinciples(_projectId, _taskId) {
         const candidates = [
-          path54__namespace.default.join(this.root, "docs"),
+          path55__namespace.default.join(this.root, "docs"),
           this.root
         ];
         const out = [];
@@ -55965,7 +56420,7 @@ function promptLine(timeoutMs = 15e3) {
 }
 async function readLastDebugStatusSafe(cwd2) {
   try {
-    const p = path54__namespace.join(cwd2, ".maria", "memory", "debug-resume.json");
+    const p = path55__namespace.join(cwd2, ".maria", "memory", "debug-resume.json");
     const buf = await fsp__namespace.readFile(p, "utf8");
     const arr = JSON.parse(buf);
     if (Array.isArray(arr) && arr.length) return arr[arr.length - 1];
@@ -55976,7 +56431,7 @@ async function readLastDebugStatusSafe(cwd2) {
 }
 async function readDebugJournalListSafe(cwd2, count) {
   try {
-    const p = path54__namespace.join(cwd2, ".maria", "memory", "debug-resume.json");
+    const p = path55__namespace.join(cwd2, ".maria", "memory", "debug-resume.json");
     const buf = await fsp__namespace.readFile(p, "utf8");
     const arr = JSON.parse(buf);
     if (!Array.isArray(arr) || arr.length === 0) return [];
@@ -56271,11 +56726,11 @@ async function runWithBudget(tasks, totalMs = 6e3, perStepMs = 600) {
   return out;
 }
 function isSensitive(filepath) {
-  const basename15 = path54__namespace.basename(filepath);
+  const basename15 = path55__namespace.basename(filepath);
   return SENSITIVE_PATTERNS2.some((pattern) => pattern.test(basename15) || pattern.test(filepath));
 }
 function isBinary(filepath) {
-  const ext2 = path54__namespace.extname(filepath).toLowerCase();
+  const ext2 = path55__namespace.extname(filepath).toLowerCase();
   return BINARY_EXTENSIONS.has(ext2);
 }
 async function safeRead(file, maxBytes = 512 * 1024, maxLines = 200, signal) {
@@ -56331,7 +56786,7 @@ async function scanRoot(opts) {
     ];
     for (const { name: name2, maxLines } of rootFiles) {
       if (signal.aborted || remainMs() < 100) break;
-      const filepath = path54__namespace.join(cwd2, name2);
+      const filepath = path55__namespace.join(cwd2, name2);
       const result = await safeRead(filepath, 512 * 1024, maxLines, signal);
       if (result.head || result.meta) {
         let meta24 = result.meta || object;
@@ -56387,7 +56842,7 @@ async function scanBuild(opts) {
     ];
     for (const name2 of buildFiles) {
       if (signal.aborted || remainMs() < 100) break;
-      const filepath = path54__namespace.join(cwd2, name2);
+      const filepath = path55__namespace.join(cwd2, name2);
       const result = await safeRead(filepath, 512 * 1024, 100, signal);
       if (result.head || result.meta) {
         findings.push({
@@ -56424,7 +56879,7 @@ async function scanQuality(opts) {
     ];
     for (const name2 of qualityFiles) {
       if (signal.aborted || remainMs() < 100) break;
-      const filepath = path54__namespace.join(cwd2, name2);
+      const filepath = path55__namespace.join(cwd2, name2);
       const result = await safeRead(filepath, 512 * 1024, 50, signal);
       if (result.head || result.meta) {
         findings.push({
@@ -56469,7 +56924,7 @@ async function scanScripts(opts) {
       const sample = files.slice(0, 5);
       for (const file of sample) {
         if (signal.aborted || remainMs() < 100) break;
-        const result = await safeRead(path54__namespace.join(cwd2, file), 512 * 1024, 100, signal);
+        const result = await safeRead(path55__namespace.join(cwd2, file), 512 * 1024, 100, signal);
         if (result.head || result.meta) {
           findings.push({
             file,
@@ -56511,7 +56966,7 @@ async function scanEntries(opts) {
     ];
     for (const name2 of entryFiles) {
       if (signal.aborted || remainMs() < 100) break;
-      const filepath = path54__namespace.join(cwd2, name2);
+      const filepath = path55__namespace.join(cwd2, name2);
       const result = await safeRead(filepath, 512 * 1024, 80, signal);
       if (result.head || result.meta) {
         findings.push({
@@ -56592,9 +57047,9 @@ function checkBinAlignment(pkg, cwd2) {
   const bin = typeof pkg.bin === "string" ? { [pkg.name]: pkg.bin } : pkg.bin;
   for (const [name2, rel] of Object.entries(bin)) {
     const binPath = rel;
-    const srcPath = path54__namespace.join(cwd2, binPath);
+    const srcPath = path55__namespace.join(cwd2, binPath);
     if (!fs22__namespace.existsSync(srcPath)) {
-      const distGuess = path54__namespace.join(
+      const distGuess = path55__namespace.join(
         cwd2,
         "dist",
         binPath.replace(/^src\//, "").replace(/^bin\//, "bin/")
@@ -57103,7 +57558,7 @@ async function detectMonorepoType(root) {
     const files = await fsp__namespace.readdir(root);
     if (files.includes("package.json")) {
       const pkg = JSON.parse(
-        await fsp__namespace.readFile(path54__namespace.join(root, "package.json"), "utf8")
+        await fsp__namespace.readFile(path55__namespace.join(root, "package.json"), "utf8")
       );
       if (pkg.workspaces) {
         if (files.includes("pnpm-workspace.yaml")) return "pnpm";
@@ -57126,7 +57581,7 @@ async function findWorkspaces(root, type) {
   try {
     switch (type) {
       case "pnpm": {
-        const wsFile = path54__namespace.join(root, "pnpm-workspace.yaml");
+        const wsFile = path55__namespace.join(root, "pnpm-workspace.yaml");
         try {
           const content = await fsp__namespace.readFile(wsFile, "utf8");
           const patterns = content.match(/packages:\s*\n((?:\s+-\s+.+\n?)+)/);
@@ -57148,7 +57603,7 @@ async function findWorkspaces(root, type) {
       }
       case "yarn":
       case "npm": {
-        const pkgPath = path54__namespace.join(root, "package.json");
+        const pkgPath = path55__namespace.join(root, "package.json");
         try {
           const pkg = JSON.parse(await fsp__namespace.readFile(pkgPath, "utf8"));
           const patterns = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages || [];
@@ -57167,7 +57622,7 @@ async function findWorkspaces(root, type) {
       }
       case "lerna": {
         try {
-          const lernaPath = path54__namespace.join(root, "lerna.json");
+          const lernaPath = path55__namespace.join(root, "lerna.json");
           const lerna = JSON.parse(await fsp__namespace.readFile(lernaPath, "utf8"));
           const patterns = lerna.packages || ["packages/*"];
           for (const pattern of patterns) {
@@ -57226,13 +57681,13 @@ async function findWorkspaces(root, type) {
 }
 async function analyzeWorkspace(workspacePath, root) {
   const info = {
-    name: path54__namespace.basename(workspacePath),
+    name: path55__namespace.basename(workspacePath),
     path: workspacePath,
     type: "unknown",
     language: "unknown"
   };
   try {
-    const pkgPath = path54__namespace.join(root, workspacePath, "package.json");
+    const pkgPath = path55__namespace.join(root, workspacePath, "package.json");
     const pkgContent = await safeRead(pkgPath, 512 * 1024, 1e3);
     if (pkgContent.head) {
       try {
@@ -57275,7 +57730,7 @@ async function analyzeWorkspace(workspacePath, root) {
     }
     const globby = await loadGlobby();
     const files = await globby(["**/*.{ts,tsx,js,jsx,mjs,cjs}"], {
-      cwd: path54__namespace.join(root, workspacePath),
+      cwd: path55__namespace.join(root, workspacePath),
       deep: 2,
       ignore: ["node_modules", "dist", "build"],
       stats: false
@@ -57830,12 +58285,12 @@ function getModuleName(filePath) {
   if (srcIndex >= 0 && srcIndex < parts.length - 1) {
     return parts[srcIndex + 1];
   }
-  return path54__namespace.dirname(filePath).split("/").pop() || "root";
+  return path55__namespace.dirname(filePath).split("/").pop() || "root";
 }
 function resolveLocalImport(fromFile2, importPath) {
   if (!importPath.startsWith(".")) return null;
-  const dir = path54__namespace.dirname(fromFile2);
-  const resolved = path54__namespace.resolve(dir, importPath);
+  const dir = path55__namespace.dirname(fromFile2);
+  const resolved = path55__namespace.resolve(dir, importPath);
   return getModuleName(resolved);
 }
 function getMetricStatus(metric, value) {
@@ -57965,7 +58420,7 @@ async function extractCodeSnippets(files, projectRoot, maxSnippets, includeExamp
 }
 async function extractFileSnippet(file, projectRoot, category) {
   try {
-    const fullPath = path54__namespace.join(projectRoot, file.path);
+    const fullPath = path55__namespace.join(projectRoot, file.path);
     const content = await safeRead(fullPath, 512 * 1024, 50);
     if (!content.head) return null;
     const lines = content.head.split("\n");
@@ -57976,7 +58431,7 @@ async function extractFileSnippet(file, projectRoot, category) {
     const codeLines = lines.slice(codeStart, codeStart + 30);
     return {
       file: file.path,
-      title: `${path54__namespace.basename(file.path)} - ${category}`,
+      title: `${path55__namespace.basename(file.path)} - ${category}`,
       description: getFileDescription(file),
       code: codeLines.join("\n"),
       language: file.language || "javascript",
@@ -58064,7 +58519,7 @@ function extractAPIDocumentation(files) {
 async function extractConfigurationDetails(projectRoot) {
   const details = [];
   try {
-    const pkgPath = path54__namespace.join(projectRoot, "package.json");
+    const pkgPath = path55__namespace.join(projectRoot, "package.json");
     const pkgContent = await fsp__namespace.readFile(pkgPath, "utf8");
     const pkg = JSON.parse(pkgContent);
     if (pkg.engines) {
@@ -58097,7 +58552,7 @@ async function extractConfigurationDetails(projectRoot) {
   } catch {
   }
   try {
-    const tsconfigPath = path54__namespace.join(projectRoot, "tsconfig.json");
+    const tsconfigPath = path55__namespace.join(projectRoot, "tsconfig.json");
     const tsconfigContent = await fsp__namespace.readFile(tsconfigPath, "utf8");
     const tsconfig = JSON.parse(tsconfigContent);
     if (tsconfig.compilerOptions?.strict !== void 0) {
@@ -58121,7 +58576,7 @@ async function extractConfigurationDetails(projectRoot) {
   } catch {
   }
   try {
-    const envExamplePath = path54__namespace.join(projectRoot, ".env.example");
+    const envExamplePath = path55__namespace.join(projectRoot, ".env.example");
     const envContent = await fsp__namespace.readFile(envExamplePath, "utf8");
     const envVars = envContent.match(/^[A-Z_]+=/gm);
     if (envVars) {
@@ -59059,7 +59514,7 @@ function generateFooter3(data) {
 }
 function generateFallbackMariaMd(error2, projectPath) {
   const data = {
-    projectName: path54__namespace.basename(projectPath),
+    projectName: path55__namespace.basename(projectPath),
     projectPath,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     errors: [error2.message]
@@ -59074,13 +59529,13 @@ var init_maria_template = __esm({
 });
 async function writeAtomic(filePath, content, options = {}) {
   const { encoding = "utf8", mode = 420, fsync = true, tmpDir } = options;
-  const dir = path54__namespace.dirname(filePath);
-  const basename15 = path54__namespace.basename(filePath);
+  const dir = path55__namespace.dirname(filePath);
+  const basename15 = path55__namespace.basename(filePath);
   const tmpSuffix = `.tmp-${Date.now()}-${crypto6.randomBytes(4).toString("hex")}`;
-  const tmpPath = tmpDir ? path54__namespace.join(tmpDir, `${basename15}${tmpSuffix}`) : path54__namespace.join(dir, `${basename15}${tmpSuffix}`);
+  const tmpPath = tmpDir ? path55__namespace.join(tmpDir, `${basename15}${tmpSuffix}`) : path55__namespace.join(dir, `${basename15}${tmpSuffix}`);
   let fileHandle = null;
   try {
-    await fsp__namespace.mkdir(path54__namespace.dirname(tmpPath), { recursive: true });
+    await fsp__namespace.mkdir(path55__namespace.dirname(tmpPath), { recursive: true });
     if (Buffer.isBuffer(content)) {
       await fsp__namespace.writeFile(tmpPath, content, { mode });
     } else {
@@ -59800,13 +60255,13 @@ var init_initialization_manager = __esm({
           if (!stats.isDirectory()) {
             this.errors.push(`Working directory is not a directory: ${cwd2}`);
           }
-          const packagePath = path54__namespace.join(cwd2, "package.json");
+          const packagePath = path55__namespace.join(cwd2, "package.json");
           try {
             await fsp__namespace.access(packagePath);
           } catch {
             this.warnings.push("No package.json found in working directory");
           }
-          const gitPath = path54__namespace.join(cwd2, ".git");
+          const gitPath = path55__namespace.join(cwd2, ".git");
           try {
             await fsp__namespace.access(gitPath);
           } catch {
@@ -59858,7 +60313,7 @@ var init_initialization_manager = __esm({
       }
       async validateMonorepoConfig(cwd2) {
         try {
-          const packagePath = path54__namespace.join(cwd2, "package.json");
+          const packagePath = path55__namespace.join(cwd2, "package.json");
           const content = await fsp__namespace.readFile(packagePath, "utf-8");
           const pkg = JSON.parse(content);
           if (pkg.workspaces) {
@@ -60248,7 +60703,7 @@ var init_initialization_manager = __esm({
       async generateEnhancedMariaMd(summary, opts) {
         try {
           return generateMariaMd2({
-            projectName: summary.projectName || path54__namespace.basename(opts.cwd || process.cwd()),
+            projectName: summary.projectName || path55__namespace.basename(opts.cwd || process.cwd()),
             projectPath: opts.cwd || process.cwd(),
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
             summary,
@@ -60269,7 +60724,7 @@ var init_initialization_manager = __esm({
         const cwd2 = opts.cwd || process.cwd();
         for (const [filename, content] of Object.entries(artifacts)) {
           if (typeof content === "string") {
-            const filePath = path54__namespace.join(cwd2, filename);
+            const filePath = path55__namespace.join(cwd2, filename);
             try {
               await writeAtomic(filePath, content);
               this.progressTracker.addMetric(
@@ -60294,7 +60749,7 @@ var init_initialization_manager = __esm({
        */
       async verifyOutput(opts) {
         const cwd2 = opts.cwd || process.cwd();
-        const mariaMdPath = path54__namespace.join(cwd2, "MARIA.md");
+        const mariaMdPath = path55__namespace.join(cwd2, "MARIA.md");
         try {
           const content = await fsp__namespace.readFile(mariaMdPath, "utf-8");
           const minLength = 2e3;
@@ -60327,7 +60782,7 @@ var init_initialization_manager = __esm({
       createMinimalSummary(opts) {
         const cwd2 = opts.cwd || process.cwd();
         return {
-          projectName: path54__namespace.basename(cwd2),
+          projectName: path55__namespace.basename(cwd2),
           projectPath: cwd2,
           description: "Project analysis incomplete due to errors",
           techStack: {
@@ -60362,7 +60817,7 @@ var init_initialization_manager = __esm({
        */
       async generateFallbackArtifacts(error2, opts) {
         const cwd2 = opts.cwd || process.cwd();
-        path54__namespace.basename(cwd2);
+        path55__namespace.basename(cwd2);
         const mariaMd = generateFallbackMariaMd({
           });
         const initReport = `# Init Report - Error Recovery Mode
@@ -60419,7 +60874,7 @@ async function safeBackup(_filePath) {
     await fsp__namespace.copyFile(_filePath, bakPath);
     if (!process.env.MARIA_INIT_QUIET) {
       console.log(
-        chalk36__default.default.gray(`  \u21B3 backup: ${path54__namespace.relative(process.cwd(), bakPath)}`)
+        chalk36__default.default.gray(`  \u21B3 backup: ${path55__namespace.relative(process.cwd(), bakPath)}`)
       );
     }
   } catch {
@@ -60457,7 +60912,7 @@ async function writeArtifacts(artifacts, opts, cwd2, reporter) {
     { name: "INIT_SUMMARY.txt", content: artifacts.initSummaryTxt }
   ];
   for (const { name: name2, content } of files) {
-    const _filePath = path54__namespace.join(cwd2, name2);
+    const _filePath = path55__namespace.join(cwd2, name2);
     if (await fileExists2(_filePath) && !opts.force) {
       await safeBackup(_filePath);
     }
@@ -60567,7 +61022,7 @@ This process will:
   );
   const artifacts = generateArtifacts(summary, findings, startTime);
   const mariaMdContent = generateMariaMd2({
-    projectName: summary.projectName || path54__namespace.basename(cwd2),
+    projectName: summary.projectName || path55__namespace.basename(cwd2),
     projectPath: cwd2,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     summary,
@@ -60727,7 +61182,7 @@ var init_delta_detector = __esm({
           const changes = stdout2.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => {
             const [status, ...rest] = line.split(/\s+/);
             const file = rest.join(" ");
-            return { status, file: path54__namespace.resolve(root, file) };
+            return { status, file: path55__namespace.resolve(root, file) };
           });
           const filtered = await this.filterFiles(
             changes.map((c) => c.file),
@@ -60736,8 +61191,8 @@ var init_delta_detector = __esm({
           );
           const filteredSet = new Set(filtered);
           const filteredChanges = changes.filter((c) => filteredSet.has(c.file));
-          const deleted = filteredChanges.filter((c) => c.status === "D").map((c) => path54__namespace.relative(root, c.file));
-          const changed = filteredChanges.filter((c) => c.status !== "D").map((c) => path54__namespace.relative(root, c.file));
+          const deleted = filteredChanges.filter((c) => c.status === "D").map((c) => path55__namespace.relative(root, c.file));
+          const changed = filteredChanges.filter((c) => c.status !== "D").map((c) => path55__namespace.relative(root, c.file));
           return {
             mode: "git",
             ref,
@@ -60769,7 +61224,7 @@ var init_delta_detector = __esm({
             break;
           }
           if (entry.mtime && entry.mtime > since) {
-            changed.push(path54__namespace.relative(root, entry.file));
+            changed.push(path55__namespace.relative(root, entry.file));
           }
           if (options.maxFiles && changed.length >= options.maxFiles) {
             break;
@@ -60793,7 +61248,7 @@ var init_delta_detector = __esm({
        * Detect changes by comparing with state.json
        */
       async detectByState(root, options) {
-        const statePath = path54__namespace.join(root, ".maria", "state.json");
+        const statePath = path55__namespace.join(root, ".maria", "state.json");
         let lastHashes = {};
         try {
           const stateContent = await fsp__namespace.readFile(statePath, "utf-8");
@@ -60809,7 +61264,7 @@ var init_delta_detector = __esm({
           if (options.budgetMs && Date.now() - this.startTime > options.budgetMs) {
             break;
           }
-          const relativePath = path54__namespace.relative(root, entry.file);
+          const relativePath = path55__namespace.relative(root, entry.file);
           const hash = entry.hash || await this.hashFile(entry.file);
           nowHashes[relativePath] = hash;
           if (!lastHashes[relativePath] || lastHashes[relativePath] !== hash) {
@@ -60889,7 +61344,7 @@ var init_delta_detector = __esm({
         }
         const patterns = options.include || ["**/*"];
         const ignore = options.exclude || [];
-        const relativePaths = files.map((f3) => path54__namespace.relative(root, f3));
+        const relativePaths = files.map((f3) => path55__namespace.relative(root, f3));
         const globby = await loadGlobby();
         const matched = await globby(patterns, {
           cwd: root,
@@ -60914,8 +61369,8 @@ var init_delta_detector = __esm({
        * Update state.json with new hashes
        */
       async updateState(root, delta) {
-        const statePath = path54__namespace.join(root, ".maria", "state.json");
-        await fsp__namespace.mkdir(path54__namespace.dirname(statePath), { recursive: true });
+        const statePath = path55__namespace.join(root, ".maria", "state.json");
+        await fsp__namespace.mkdir(path55__namespace.dirname(statePath), { recursive: true });
         let state;
         try {
           const content = await fsp__namespace.readFile(statePath, "utf-8");
@@ -60940,7 +61395,7 @@ var init_delta_detector = __esm({
             delete currentHashes[file];
           });
           for (const file of delta.changed) {
-            const fullPath = path54__namespace.join(root, file);
+            const fullPath = path55__namespace.join(root, file);
             try {
               const hash = await this.hashFile(fullPath);
               if (hash) {
@@ -61800,8 +62255,8 @@ var init_init_command = __esm({
       async execute(options = {}) {
         const startTime = Date.now();
         const root = options.root || process.cwd();
-        const stateDir = path54__namespace.join(root, ".maria");
-        const statePath = path54__namespace.join(stateDir, "state.json");
+        const stateDir = path55__namespace.join(root, ".maria");
+        const statePath = path55__namespace.join(stateDir, "state.json");
         this.logger.header("MARIA /init - Enhanced Codebase Analysis");
         const hasExistingState = await this.fileExists(statePath);
         if (hasExistingState && !options.force) {
@@ -61926,7 +62381,7 @@ var init_init_command = __esm({
           nodes.push({
             id: file._path,
             type: "file",
-            name: path54__namespace.basename(file._path),
+            name: path55__namespace.basename(file._path),
             language: file.language,
             size: file.size,
             complexity: file.complexity
@@ -62031,7 +62486,7 @@ ${file.summary || ""}`,
       async generateArtifacts(root, scanResult, graphResult) {
         this.logger.start("artifacts", "Generating artifacts...");
         const mariaMd = this.generateMariaMd(scanResult, graphResult);
-        const mariaMdPath = path54__namespace.join(root, "MARIA.md");
+        const mariaMdPath = path55__namespace.join(root, "MARIA.md");
         await fsp__namespace.writeFile(mariaMdPath, mariaMd, "utf-8");
         const depMapJson = {
           version: "3.2.2",
@@ -62048,7 +62503,7 @@ ${file.summary || ""}`,
             edges: graphResult.edgesCreated
           }
         };
-        const depMapPath = path54__namespace.join(root, "DEPENDENCY_MAP.json");
+        const depMapPath = path55__namespace.join(root, "DEPENDENCY_MAP.json");
         await fsp__namespace.writeFile(
           depMapPath,
           JSON.stringify(depMapJson, null, 2),
@@ -62229,7 +62684,7 @@ Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}
       }
       async saveState(stateDir, state) {
         await fsp__namespace.mkdir(stateDir, { recursive: true });
-        const statePath = path54__namespace.join(stateDir, "state.json");
+        const statePath = path55__namespace.join(stateDir, "state.json");
         await fsp__namespace.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
       }
       async fileExists(_path) {
@@ -62333,8 +62788,8 @@ var init_GraphEngine = __esm({
         this.nameIndex.get(lname).add(node.id);
         const p = (node.path || node._path || "") + "";
         if (p) this.pathIndex.set(p, node.id);
-        const tokens = this.tokenize(`${lname} ${p.toLowerCase()}`);
-        for (const tok of tokens) {
+        const tokens2 = this.tokenize(`${lname} ${p.toLowerCase()}`);
+        for (const tok of tokens2) {
           if (!this.tokenIndex.has(tok)) this.tokenIndex.set(tok, /* @__PURE__ */ new Set());
           this.tokenIndex.get(tok).add(node.id);
           this.tokenTrie.insert(tok, node.id);
@@ -62374,8 +62829,8 @@ var init_GraphEngine = __esm({
           }
           const p = (node.path || node._path || "") + "";
           if (p) this.pathIndex.delete(p);
-          const tokens = this.tokenize(`${(node.name || "").toLowerCase()} ${p.toLowerCase()}`);
-          for (const tok of tokens) {
+          const tokens2 = this.tokenize(`${(node.name || "").toLowerCase()} ${p.toLowerCase()}`);
+          for (const tok of tokens2) {
             const set2 = this.tokenIndex.get(tok);
             if (set2) {
               set2.delete(id);
@@ -62457,17 +62912,17 @@ var init_GraphEngine = __esm({
         const visited = /* @__PURE__ */ new Set();
         const queue = [{ id: from, path: [from] }];
         while (queue.length) {
-          const { id, path: path55 } = queue.shift();
+          const { id, path: path56 } = queue.shift();
           if (visited.has(id)) continue;
           visited.add(id);
           const neighbors = this.edges.get(id) || /* @__PURE__ */ new Set();
           for (const e2 of neighbors) {
             if (e2.to === to) {
-              const res = [...path55, to];
+              const res = [...path56, to];
               this.recordQueryTime(Date.now() - start);
               return res;
             }
-            if (!visited.has(e2.to)) queue.push({ id: e2.to, path: [...path55, e2.to] });
+            if (!visited.has(e2.to)) queue.push({ id: e2.to, path: [...path56, e2.to] });
           }
         }
         this.recordQueryTime(Date.now() - start);
@@ -62654,8 +63109,8 @@ var init_GraphStore = __esm({
       accessCounter = 0;
       constructor(_maxNodes = 1e4) {
         this._maxNodes = _maxNodes;
-        this.storageDir = path54__namespace.default.join(process.cwd(), ".maria", "graph");
-        this.graphFile = path54__namespace.default.join(this.storageDir, "knowledge-graph.json");
+        this.storageDir = path55__namespace.default.join(process.cwd(), ".maria", "graph");
+        this.graphFile = path55__namespace.default.join(this.storageDir, "knowledge-graph.json");
         this.startPeriodicSave();
       }
       /**
@@ -63179,8 +63634,8 @@ var init_DependencyAnalyzer = __esm({
        */
       resolveImportPath(_importSource, fromFile2, rootDir) {
         if (_importSource.startsWith("./") || _importSource.startsWith("../")) {
-          const _fromDir = path54__namespace.default.dirname(fromFile2);
-          const _resolved = path54__namespace.default.resolve(_fromDir, _importSource);
+          const _fromDir = path55__namespace.default.dirname(fromFile2);
+          const _resolved = path55__namespace.default.resolve(_fromDir, _importSource);
           for (const _ext of this.SUPPORTED_EXTENSIONS) {
             if (_resolved.endsWith(_ext)) {
               return _resolved;
@@ -63190,7 +63645,7 @@ var init_DependencyAnalyzer = __esm({
               __require.resolve(_withExt);
               return _withExt;
             } catch {
-              const _indexFile = path54__namespace.default.join(_resolved, `index${_ext}`);
+              const _indexFile = path55__namespace.default.join(_resolved, `index${_ext}`);
               try {
                 __require.resolve(_indexFile);
                 return _indexFile;
@@ -63202,7 +63657,7 @@ var init_DependencyAnalyzer = __esm({
           return _resolved;
         }
         if (!_importSource.startsWith("@") && !_importSource.includes("node_modules")) {
-          const _resolved = path54__namespace.default.resolve(rootDir, _importSource);
+          const _resolved = path55__namespace.default.resolve(rootDir, _importSource);
           for (const _ext of this.SUPPORTED_EXTENSIONS) {
             const _withExt = _resolved + _ext;
             try {
@@ -63225,7 +63680,7 @@ var init_DependencyAnalyzer = __esm({
           try {
             const _entries = await fsp__namespace.default.readdir(dir, { withFileTypes: true });
             for (const entry of _entries) {
-              const _fullPath = path54__namespace.default.join(dir, entry.name);
+              const _fullPath = path55__namespace.default.join(dir, entry.name);
               if (entry.isDirectory()) {
                 if (!["node_modules", ".git", "dist", "build", ".next"].includes(
                   entry.name
@@ -63233,7 +63688,7 @@ var init_DependencyAnalyzer = __esm({
                   await traverse(_fullPath);
                 }
               } else if (entry.isFile()) {
-                const _ext = path54__namespace.default.extname(entry.name);
+                const _ext = path55__namespace.default.extname(entry.name);
                 if ([".ts", ".tsx", ".js", ".jsx", ".mjs"].includes(_ext)) {
                   files.push(_fullPath);
                 }
@@ -63389,7 +63844,7 @@ var init_DependencyAnalyzer = __esm({
           return {
             id: this.generateNodeId(_filePath),
             type: "file",
-            name: path54__namespace.default.basename(_filePath),
+            name: path55__namespace.default.basename(_filePath),
             _path: _filePath,
             metadata: {
               size: _stats.size,
@@ -63429,7 +63884,7 @@ var init_DependencyAnalyzer = __esm({
         }
       }
       detectLanguage(_filePath) {
-        const _ext = path54__namespace.default.extname(_filePath);
+        const _ext = path55__namespace.default.extname(_filePath);
         switch (_ext) {
           case ".ts":
           case ".tsx":
@@ -64227,7 +64682,7 @@ var init_KnowledgeGraphService = __esm({
             _filePath,
             depth
           );
-          const _fileName2 = path54__namespace.default.basename(_filePath);
+          const _fileName2 = path55__namespace.default.basename(_filePath);
           const _relatedNodes = this.graphEngine.searchNodes(_fileName2);
           const suggestions = [];
           for (const node of _graphContext.nodes.slice(0, 5)) {
@@ -64541,8 +64996,8 @@ async function legacyInit(args2) {
     const cliCwd = process.cwd();
     console.log(chalk36__default.default.blue("\u{1F680} Initializing MARIA configuration..."));
     const options = parseInitOptions(args2);
-    const repoRoot = path54__namespace.resolve(options.root || await findRepoRoot(cliCwd));
-    const tomlPath = path54__namespace.join(repoRoot, ".maria-code.toml");
+    const repoRoot = path55__namespace.resolve(options.root || await findRepoRoot(cliCwd));
+    const tomlPath = path55__namespace.join(repoRoot, ".maria-code.toml");
     const existingConfig = await fileExists3(tomlPath);
     if (existingConfig && !args2.includes("--force")) {
       const result = await prompts__default.default({
@@ -64556,7 +65011,7 @@ async function legacyInit(args2) {
         return "exit";
       }
       await safeBackup2(tomlPath);
-      const mdPath2 = path54__namespace.join(repoRoot, "MARIA.md");
+      const mdPath2 = path55__namespace.join(repoRoot, "MARIA.md");
       if (await fileExists3(mdPath2)) {
         await safeBackup2(mdPath2);
       }
@@ -64570,35 +65025,35 @@ async function legacyInit(args2) {
     const tomlContent = generateTomlConfig(projectConfig);
     try {
       const tomlStatus = await safeWriteIfChanged(tomlPath, tomlContent);
-      const rel = path54__namespace.relative(cliCwd, tomlPath);
+      const rel = path55__namespace.relative(cliCwd, tomlPath);
       if (tomlStatus.status === "up-to-date") {
         console.log(chalk36__default.default.gray(`\u2139\uFE0F  Up-to-date: ${rel}`));
       } else if (tomlStatus.status === "created") {
         console.log(chalk36__default.default.green(`\u2705 Created: ${rel}`));
       } else if (tomlStatus.status === "updated") {
-        console.log(chalk36__default.default.green(`\u2705 Updated: ${rel}`) + (tomlStatus.backup ? chalk36__default.default.gray(` (backup: ${path54__namespace.relative(cliCwd, tomlStatus.backup)})`) : ""));
+        console.log(chalk36__default.default.green(`\u2705 Updated: ${rel}`) + (tomlStatus.backup ? chalk36__default.default.gray(` (backup: ${path55__namespace.relative(cliCwd, tomlStatus.backup)})`) : ""));
       }
     } catch (e2) {
       console.error(chalk36__default.default.red("\u274C Failed to write .maria-code.toml:"), adviceFromFsError(e2));
     }
-    const mdPath = path54__namespace.join(repoRoot, "MARIA.md");
+    const mdPath = path55__namespace.join(repoRoot, "MARIA.md");
     const lang = resolveLang(options.lang);
     const mdContent = generateMariaMd3(projectConfig, lang);
     try {
       const mdStatus = await safeWriteIfChanged(mdPath, mdContent);
-      const rel = path54__namespace.relative(cliCwd, mdPath);
+      const rel = path55__namespace.relative(cliCwd, mdPath);
       if (mdStatus.status === "up-to-date") {
         console.log(chalk36__default.default.gray(`Saved: ${rel} (up-to-date)`));
       } else if (mdStatus.status === "created") {
         console.log(chalk36__default.default.green(`Saved: ${rel} (created)`));
       } else if (mdStatus.status === "updated") {
-        const bakRel = mdStatus.backup ? path54__namespace.relative(cliCwd, mdStatus.backup) : void 0;
+        const bakRel = mdStatus.backup ? path55__namespace.relative(cliCwd, mdStatus.backup) : void 0;
         console.log(chalk36__default.default.green(`Saved: ${rel} (updated${bakRel ? `, backup: ${bakRel}` : ""})`));
       }
     } catch (e2) {
       console.error(chalk36__default.default.red("\u274C Failed to write MARIA.md:"), adviceFromFsError(e2));
     }
-    if (projectConfig.gitInit && !await fileExists3(path54__namespace.join(repoRoot, ".git"))) {
+    if (projectConfig.gitInit && !await fileExists3(path55__namespace.join(repoRoot, ".git"))) {
       try {
         const { execSync } = await import('child_process');
         execSync("git init", { cwd: repoRoot, stdio: "pipe" });
@@ -64632,13 +65087,13 @@ async function safeBackup2(_filePath) {
     const bakPath = `${_filePath}.bak.${stamp}`;
     await fsp__namespace.copyFile(_filePath, bakPath);
     console.log(
-      chalk36__default.default.gray(`  \u21B3 backup: ${path54__namespace.relative(process.cwd(), bakPath)}`)
+      chalk36__default.default.gray(`  \u21B3 backup: ${path55__namespace.relative(process.cwd(), bakPath)}`)
     );
   } catch {
   }
 }
 async function interactiveSetup() {
-  const packageJsonPath = path54__namespace.join(process.cwd(), "package.json");
+  const packageJsonPath = path55__namespace.join(process.cwd(), "package.json");
   let packageJson2 = {};
   try {
     const packageData = await fsp__namespace.readFile(packageJsonPath, "utf-8");
@@ -64650,7 +65105,7 @@ async function interactiveSetup() {
       type: "text",
       name: "name",
       message: "Project name:",
-      initial: packageJson2.name || path54__namespace.basename(process.cwd())
+      initial: packageJson2.name || path55__namespace.basename(process.cwd())
     },
     {
       type: "select",
@@ -64694,7 +65149,7 @@ async function interactiveSetup() {
 }
 function getDefaultConfig() {
   return {
-    name: path54__namespace.basename(process.cwd()),
+    name: path55__namespace.basename(process.cwd()),
     type: "auto",
     description: "AI-powered development project using MARIA",
     author: "",
@@ -64875,13 +65330,13 @@ function resolveLang(input3) {
   return "en";
 }
 async function findRepoRoot(startDir) {
-  let dir = path54__namespace.resolve(startDir);
+  let dir = path55__namespace.resolve(startDir);
   let lastGitDir = null;
   while (true) {
-    const gitPath = path54__namespace.join(dir, ".git");
+    const gitPath = path55__namespace.join(dir, ".git");
     const hasGit = await fileExists3(gitPath);
     if (hasGit) lastGitDir = dir;
-    const parent = path54__namespace.dirname(dir);
+    const parent = path55__namespace.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -64963,8 +65418,8 @@ var init_update_command = __esm({
       async execute(options = {}) {
         const startTime = Date.now();
         const root = options.root || process.cwd();
-        const stateDir = path54__namespace.join(root, ".maria");
-        const statePath = path54__namespace.join(stateDir, "state.json");
+        const stateDir = path55__namespace.join(root, ".maria");
+        const statePath = path55__namespace.join(stateDir, "state.json");
         this.reporter.thinking(`Performing incremental update to detect and process changes.
 This will:
 - Detect file changes since last update
@@ -65134,12 +65589,12 @@ This will:
         };
         const result = await this.deltaDetector.detectDelta(root, deltaOptions);
         const files = [
-          ...result.changed.map((path55) => ({
-            _path: path55,
-            type: previousState?.fileHashes?.[path55] ? "modified" : "added"
+          ...result.changed.map((path56) => ({
+            _path: path56,
+            type: previousState?.fileHashes?.[path56] ? "modified" : "added"
           })),
-          ...result.deleted.map((path55) => ({
-            _path: path55,
+          ...result.deleted.map((path56) => ({
+            _path: path56,
             type: "deleted"
           }))
         ];
@@ -65256,7 +65711,7 @@ This will:
           nodeUpdates.push({
             id: file._path,
             type: "file",
-            name: path54__namespace.basename(file._path),
+            name: path55__namespace.basename(file._path),
             language: file.language,
             size: file.size,
             complexity: file.complexity,
@@ -65356,7 +65811,7 @@ ${file.summary || ""}`,
        */
       async updateArtifacts(root, deltaResult, processResult) {
         this.logger.start("artifacts", "Updating artifacts...");
-        const mariaMdPath = path54__namespace.join(root, "MARIA.md");
+        const mariaMdPath = path55__namespace.join(root, "MARIA.md");
         let existingContent = "";
         try {
           existingContent = await fsp__namespace.readFile(mariaMdPath, "utf-8");
@@ -65370,7 +65825,7 @@ ${file.summary || ""}`,
         );
         await fsp__namespace.writeFile(mariaMdPath, updatedMariaMd, "utf-8");
         this.reporter.write("MARIA.md", updatedMariaMd.length);
-        const depMapPath = path54__namespace.join(root, "DEPENDENCY_MAP.json");
+        const depMapPath = path55__namespace.join(root, "DEPENDENCY_MAP.json");
         try {
           const existingDepMap = JSON.parse(await fsp__namespace.readFile(depMapPath, "utf-8"));
           this.reporter.read(
@@ -65489,7 +65944,7 @@ ${delta.modified > 5 ? `... and ${delta.modified - 5} more` : ""}
         }
       }
       async saveState(statePath, state) {
-        const dir = path54__namespace.dirname(statePath);
+        const dir = path55__namespace.dirname(statePath);
         await fsp__namespace.mkdir(dir, { recursive: true });
         if (state.fileHashes instanceof Map) {
           state.fileHashes = Object.fromEntries(state.fileHashes);
@@ -65932,7 +66387,7 @@ var init_ResearchCommand = __esm({
       constructor() {
         super();
         this.contentExtractor = new ContentExtractor();
-        this.knowledgeBasePath = path54__namespace.default.join(os16__namespace.default.homedir(), ".maria", "knowledge-base");
+        this.knowledgeBasePath = path55__namespace.default.join(os16__namespace.default.homedir(), ".maria", "knowledge-base");
       }
       async initialize() {
         try {
@@ -66463,7 +66918,7 @@ ${JSON.stringify(_result, null, 2)}
               readingTime: _content.metadata.readingTime
             }
           };
-          const _entryPath = path54__namespace.default.join(this.knowledgeBasePath, "entries", `${id}.json`);
+          const _entryPath = path55__namespace.default.join(this.knowledgeBasePath, "entries", `${id}.json`);
           await fsp__namespace.default.writeFile(_entryPath, JSON.stringify(_entry, null, 2));
           await this.updateKnowledgeBaseIndex(_entry);
           logger.info(`Saved to knowledge base: ${id}`);
@@ -66474,7 +66929,7 @@ ${JSON.stringify(_result, null, 2)}
         }
       }
       async updateKnowledgeBaseIndex(_entry) {
-        const _indexPath = path54__namespace.default.join(this.knowledgeBasePath, "index.json");
+        const _indexPath = path55__namespace.default.join(this.knowledgeBasePath, "index.json");
         try {
           const _indexContent = await fsp__namespace.default.readFile(_indexPath, "utf-8");
           const _index = JSON.parse(_indexContent);
@@ -66494,7 +66949,7 @@ ${JSON.stringify(_result, null, 2)}
       async ensureKnowledgeBaseDirectory() {
         try {
           await fsp__namespace.default.mkdir(this.knowledgeBasePath, { recursive: true });
-          await fsp__namespace.default.mkdir(path54__namespace.default.join(this.knowledgeBasePath, "entries"), { recursive: true });
+          await fsp__namespace.default.mkdir(path55__namespace.default.join(this.knowledgeBasePath, "entries"), { recursive: true });
         } catch (innerError) {
           logger.error("Failed to create knowledge base directory:", error);
         }
@@ -66562,7 +67017,7 @@ ${JSON.stringify(_result, null, 2)}
 `;
         }
         try {
-          const _indexPath = path54__namespace.default.join(this.knowledgeBasePath, "index.json");
+          const _indexPath = path55__namespace.default.join(this.knowledgeBasePath, "index.json");
           const _indexContent = await fsp__namespace.default.readFile(_indexPath, "utf-8");
           const _index = JSON.parse(_indexContent);
           message += `**Knowledge Base**: \u2705 Available
@@ -68836,13 +69291,13 @@ async function checkShield(commandName, userPlan = "free") {
 }
 async function loadManifest() {
   try {
-    const fs45 = await import('fs');
-    const path55 = await import('path');
-    const manifestPath = path55.join(
+    const fs46 = await import('fs');
+    const path56 = await import('path');
+    const manifestPath = path56.join(
       __dirname,
       "../command-manifest-v2.1.json"
     );
-    const content = fs45.readFileSync(manifestPath, "utf-8");
+    const content = fs46.readFileSync(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return { commands: [] };
@@ -70526,11 +70981,11 @@ var init_ImageCommand = __esm({
           const height = m2 ? parseInt(m2[2], 10) : 1024;
           const format = String(options.format || "png");
           const res = await provider.generateImage({ prompt, width, height, format });
-          const path55 = __require("path");
-          const fs45 = await import('fs/promises');
-          const outPath = path55.join(process.cwd(), "outputs", "images", `image_${Date.now()}.png`);
-          await fs45.mkdir(path55.dirname(outPath), { recursive: true });
-          await fs45.writeFile(outPath, res.bytes);
+          const path56 = __require("path");
+          const fs46 = await import('fs/promises');
+          const outPath = path56.join(process.cwd(), "outputs", "images", `image_${Date.now()}.png`);
+          await fs46.mkdir(path56.dirname(outPath), { recursive: true });
+          await fs46.writeFile(outPath, res.bytes);
           return { success: true, output: `OK: Saved image \u2192 ${outPath}` };
         } catch (e2) {
           return { success: false, output: `ERROR: Image generation failed. ${e2?.message || e2}` };
@@ -70581,12 +71036,12 @@ var init_VideoCommand = __esm({
           const fps = Math.max(1, parseInt(getVal("fps", "8"), 10) || 8);
           const duration = Math.max(1, parseInt(getVal("duration", "2"), 10) || 2);
           const frames = await provider.generateVideoFrames({ prompt, width: 640, height: 360, fps, duration, format: "mp4" });
-          const path55 = __require("path");
-          const fs45 = await import('fs/promises');
-          const dir = path55.join(process.cwd(), "outputs", "videos", `video_${Date.now()}`);
-          await fs45.mkdir(dir, { recursive: true });
+          const path56 = __require("path");
+          const fs46 = await import('fs/promises');
+          const dir = path56.join(process.cwd(), "outputs", "videos", `video_${Date.now()}`);
+          await fs46.mkdir(dir, { recursive: true });
           const framePattern = "frame_%04d.png";
-          await Promise.all(frames.frames.map((buf, i2) => fs45.writeFile(path55.join(dir, `frame_${i2.toString().padStart(4, "0")}.png`), buf)));
+          await Promise.all(frames.frames.map((buf, i2) => fs46.writeFile(path56.join(dir, `frame_${i2.toString().padStart(4, "0")}.png`), buf)));
           const wantMerge = has("merge") || has("mp4");
           if (wantMerge && process.env.CI !== "true" && process.env.MARIA_TEST_MODE !== "1") {
             const ok = await this.mergeWithFFmpeg(dir, framePattern, fps).catch(() => false);
@@ -70603,8 +71058,8 @@ var init_VideoCommand = __esm({
         if (!available) return false;
         return new Promise((resolve17) => {
           const { spawn: spawn4 } = __require("child_process");
-          const path55 = __require("path");
-          const out = path55.join(dir, "video.mp4");
+          const path56 = __require("path");
+          const out = path56.join(dir, "video.mp4");
           const ffmpeg = spawn4("ffmpeg", ["-y", "-framerate", String(fps), "-i", pattern, "-pix_fmt", "yuv420p", out], { cwd: dir, stdio: "ignore" });
           let done = false;
           ffmpeg.on("error", () => {
@@ -72044,14 +72499,14 @@ ${model.description}
         };
         return emojis[provider.toLowerCase()] || "\u{1F52E}";
       }
-      formatTokens(tokens) {
-        if (tokens >= 1e6) {
-          return `${(tokens / 1e6).toFixed(1)}M`;
+      formatTokens(tokens2) {
+        if (tokens2 >= 1e6) {
+          return `${(tokens2 / 1e6).toFixed(1)}M`;
         }
-        if (tokens >= 1e3) {
-          return `${(tokens / 1e3).toFixed(0)}K`;
+        if (tokens2 >= 1e3) {
+          return `${(tokens2 / 1e3).toFixed(0)}K`;
         }
-        return tokens.toString();
+        return tokens2.toString();
       }
       async performModelTest(model) {
         const latency = Math.random() * 1e3 + 100;
@@ -72334,8 +72789,8 @@ var init_ConfigCommand2 = __esm({
           validate: (v) => typeof v === "string"
         }
       };
-      globalConfigPath = path54__namespace.default.join(os16__namespace.default.homedir(), ".maria", "config.json");
-      localConfigPath = path54__namespace.default.join(process.cwd(), ".maria-config.json");
+      globalConfigPath = path55__namespace.default.join(os16__namespace.default.homedir(), ".maria", "config.json");
+      localConfigPath = path55__namespace.default.join(process.cwd(), ".maria-config.json");
       async execute(_args, context2) {
         try {
           const _startTime = Date.now();
@@ -72721,7 +73176,7 @@ var init_ConfigCommand2 = __esm({
       }
       async saveConfiguration(_config, _scope) {
         const _configPath = _scope === "global" ? this.globalConfigPath : this.localConfigPath;
-        await fsp__namespace.default.mkdir(path54__namespace.default.dirname(_configPath), { recursive: true });
+        await fsp__namespace.default.mkdir(path55__namespace.default.dirname(_configPath), { recursive: true });
         await fsp__namespace.default.writeFile(_configPath, JSON.stringify(_config, null, 2), "utf-8");
         this.setCache(`_config:${_scope}`, _config, 300);
       }
@@ -73138,8 +73593,8 @@ async function enforceAuth(cmd) {
     return true;
   }
   try {
-    const tokens = await authManager.getValidTokens();
-    if (!tokens) {
+    const tokens2 = await authManager.getValidTokens();
+    if (!tokens2) {
       console.log(chalk36__default.default.red("\u{1F510} Authentication required \xB7 Run: maria /login"));
       return false;
     }
@@ -73938,23 +74393,23 @@ function coerceExtension(ext2, fallback2) {
   return fallback2;
 }
 function safeResolve(root, fname) {
-  const abs = path54__namespace.resolve(root, fname);
-  const base = path54__namespace.resolve(root);
-  if (!(abs + path54__namespace.sep).startsWith(base + path54__namespace.sep) && abs !== base) {
+  const abs = path55__namespace.resolve(root, fname);
+  const base = path55__namespace.resolve(root);
+  if (!(abs + path55__namespace.sep).startsWith(base + path55__namespace.sep) && abs !== base) {
     throw new Error("Path traversal detected");
   }
   return abs;
 }
 async function ensureUniquePath(absPath) {
-  const dir = path54__namespace.dirname(absPath);
-  const ext2 = path54__namespace.extname(absPath);
-  const base = path54__namespace.basename(absPath, ext2);
+  const dir = path55__namespace.dirname(absPath);
+  const ext2 = path55__namespace.extname(absPath);
+  const base = path55__namespace.basename(absPath, ext2);
   let candidate = absPath;
   let i2 = 1;
   while (true) {
     try {
       await fsp__namespace.access(candidate);
-      candidate = path54__namespace.join(dir, `${base}(${i2})${ext2}`);
+      candidate = path55__namespace.join(dir, `${base}(${i2})${ext2}`);
       i2++;
     } catch {
       return candidate;
@@ -74033,7 +74488,7 @@ async function handleCodeCommand(prompt) {
       for (const { language, code, extension, filename: suggested } of artifacts) {
         let filename = generateCodeFilename(prompt, language, extension, code, suggested);
         filename = sanitizeFilenameStrict(filename);
-        const ext2 = path54__namespace.extname(filename).slice(1);
+        const ext2 = path55__namespace.extname(filename).slice(1);
         const isBinary2 = isLikelyBinary(code);
         const inferred = isBinary2 ? "bin" : inferExtensionFromContent(language, code) || "txt";
         const finalExt = coerceExtension(ext2, inferred);
@@ -74046,15 +74501,13 @@ async function handleCodeCommand(prompt) {
         files += 1;
         if (progress) clearInterval(progress);
         if (isTTY) rl__namespace.cursorTo(process.stdout, 0);
-        console.log(chalk36__default.default.green(`\u2705 Saved 1 file: ${path54__namespace.basename(filepath)} (${language}${isBinary2 ? ", binary-like" : ""})`));
-        console.log(chalk36__default.default.gray(`\u{1F4CD} ${filepath}`));
-        console.log(chalk36__default.default.gray(`\u2139\uFE0F  Generated from: ${prompt.slice(0, 80)}`));
+        console.log(`Saved 1 file: ${path55__namespace.basename(filepath)} (${language}${isBinary2 ? ", binary-like" : ""})`);
+        console.log(`\u{1F4CD} ${filepath}`);
         const pm = getProviderManager();
         const provider = pm.getLastUsedProvider() || "fallback";
         const model = pm.getLastUsedModel() || "n/a";
         const source = pm.getConfigSource();
-        const summary = { filename: path54__namespace.basename(filepath), lang: String(language), provider: String(provider), model: String(model), config_source: source, fallback: true, latency_ms: pm.getLastLatencyMs(), ...pm.getLastUsage() ? { total_tokens: pm.getLastUsage().totalTokens, prompt_tokens: pm.getLastUsage().promptTokens, completion_tokens: pm.getLastUsage().completionTokens } : {}, file_size: bytes };
-        console.log(chalk36__default.default.gray(`telemetry: code.saved ${JSON.stringify(summary)}`));
+        const summary = { filename: path55__namespace.basename(filepath), lang: String(language), provider: String(provider), model: String(model), config_source: source, fallback: true, latency_ms: pm.getLastLatencyMs(), ...pm.getLastUsage() ? { total_tokens: pm.getLastUsage().totalTokens, prompt_tokens: pm.getLastUsage().promptTokens, completion_tokens: pm.getLastUsage().completionTokens } : {}, file_size: bytes };
         try {
           TelemetryCollector.getInstance().trackCodeSaved(summary);
         } catch {
@@ -74062,7 +74515,6 @@ async function handleCodeCommand(prompt) {
       }
       const pmBatch = getProviderManager();
       const batch = { files, total_bytes: totalBytes, provider: String(pmBatch.getLastUsedProvider() || "fallback"), model: String(pmBatch.getLastUsedModel() || "n/a"), config_source: pmBatch.getConfigSource(), fallback_any: true, latency_ms: pmBatch.getLastLatencyMs(), total_tokens: pmBatch.getLastUsage()?.totalTokens };
-      console.log(chalk36__default.default.gray(`telemetry: code.saved_batch ${JSON.stringify(batch)}`));
       try {
         TelemetryCollector.getInstance().trackCodeSavedBatch(batch);
       } catch {
@@ -74093,7 +74545,7 @@ async function handleCodeCommand(prompt) {
       for (const { language, code, extension, filename: suggested } of artifacts) {
         let filename = generateCodeFilename(prompt, language, extension, code, suggested);
         filename = sanitizeFilenameStrict(filename);
-        const ext2 = path54__namespace.extname(filename).slice(1);
+        const ext2 = path55__namespace.extname(filename).slice(1);
         const isBinary2 = isLikelyBinary(code);
         const inferred = isBinary2 ? "bin" : inferExtensionFromContent(language, code) || "txt";
         const finalExt = coerceExtension(ext2, inferred);
@@ -74106,15 +74558,13 @@ async function handleCodeCommand(prompt) {
         files += 1;
         if (progress) clearInterval(progress);
         if (isTTY) rl__namespace.cursorTo(process.stdout, 0);
-        console.log(chalk36__default.default.green(`\u2705 Saved 1 file: ${path54__namespace.basename(filepath)} (${language}${isBinary2 ? ", binary-like" : ""})`));
-        console.log(chalk36__default.default.gray(`\u{1F4CD} ${filepath}`));
-        console.log(chalk36__default.default.gray(`\u2139\uFE0F  Generated from: ${prompt.slice(0, 80)}`));
+        console.log(`Saved 1 file: ${path55__namespace.basename(filepath)} (${language}${isBinary2 ? ", binary-like" : ""})`);
+        console.log(`\u{1F4CD} ${filepath}`);
         const pm = getProviderManager();
         const provider = pm.getLastUsedProvider() || "unknown";
         const model = pm.getLastUsedModel() || "auto";
         const source = pm.getConfigSource();
-        const summary = { filename: path54__namespace.basename(filepath), lang: String(language), provider: String(provider), model: String(model), config_source: source, fallback: false, latency_ms: pm.getLastLatencyMs(), ...pm.getLastUsage() ? { total_tokens: pm.getLastUsage().totalTokens, prompt_tokens: pm.getLastUsage().promptTokens, completion_tokens: pm.getLastUsage().completionTokens } : {}, file_size: bytes };
-        console.log(chalk36__default.default.gray(`telemetry: code.saved ${JSON.stringify(summary)}`));
+        const summary = { filename: path55__namespace.basename(filepath), lang: String(language), provider: String(provider), model: String(model), config_source: source, fallback: false, latency_ms: pm.getLastLatencyMs(), ...pm.getLastUsage() ? { total_tokens: pm.getLastUsage().totalTokens, prompt_tokens: pm.getLastUsage().promptTokens, completion_tokens: pm.getLastUsage().completionTokens } : {}, file_size: bytes };
         try {
           TelemetryCollector.getInstance().trackCodeSaved(summary);
         } catch {
@@ -74122,7 +74572,6 @@ async function handleCodeCommand(prompt) {
       }
       const pmBatch = getProviderManager();
       const batch = { files, total_bytes: totalBytes, provider: String(pmBatch.getLastUsedProvider() || "unknown"), model: String(pmBatch.getLastUsedModel() || "auto"), config_source: pmBatch.getConfigSource(), fallback_any: false, latency_ms: pmBatch.getLastLatencyMs(), total_tokens: pmBatch.getLastUsage()?.totalTokens };
-      console.log(chalk36__default.default.gray(`telemetry: code.saved_batch ${JSON.stringify(batch)}`));
       try {
         TelemetryCollector.getInstance().trackCodeSavedBatch(batch);
       } catch {
@@ -74147,7 +74596,7 @@ async function handleCodeCommand(prompt) {
       for (const { language, code, extension, filename: suggested } of artifacts) {
         let filename = generateCodeFilename(prompt, language, extension, code, suggested);
         filename = sanitizeFilenameStrict(filename);
-        const ext2 = path54__namespace.extname(filename).slice(1);
+        const ext2 = path55__namespace.extname(filename).slice(1);
         const isBinary2 = isLikelyBinary(code);
         const inferred = isBinary2 ? "bin" : inferExtensionFromContent(language, code) || "txt";
         const finalExt = coerceExtension(ext2, inferred);
@@ -74160,15 +74609,13 @@ async function handleCodeCommand(prompt) {
         files += 1;
         if (progress) clearInterval(progress);
         if (isTTY) rl__namespace.cursorTo(process.stdout, 0);
-        console.log(chalk36__default.default.green(`\u2705 Saved 1 file: ${path54__namespace.basename(filepath)} (${language}${isBinary2 ? ", binary-like" : ""})`));
-        console.log(chalk36__default.default.gray(`\u{1F4CD} ${filepath}`));
-        console.log(chalk36__default.default.gray(`\u2139\uFE0F  Generated from: ${prompt.slice(0, 80)}`));
+        console.log(`Saved 1 file: ${path55__namespace.basename(filepath)} (${language}${isBinary2 ? ", binary-like" : ""})`);
+        console.log(`\u{1F4CD} ${filepath}`);
         const pm = getProviderManager();
         const provider = pm.getLastUsedProvider() || "fallback";
         const model = pm.getLastUsedModel() || "n/a";
         const source = pm.getConfigSource();
-        const summary = { filename: path54__namespace.basename(filepath), lang: String(language), provider: String(provider), model: String(model), config_source: source, fallback: true, latency_ms: pm.getLastLatencyMs(), ...pm.getLastUsage() ? { total_tokens: pm.getLastUsage().totalTokens, prompt_tokens: pm.getLastUsage().promptTokens, completion_tokens: pm.getLastUsage().completionTokens } : {}, file_size: bytes };
-        console.log(chalk36__default.default.gray(`telemetry: code.saved ${JSON.stringify(summary)}`));
+        const summary = { filename: path55__namespace.basename(filepath), lang: String(language), provider: String(provider), model: String(model), config_source: source, fallback: true, latency_ms: pm.getLastLatencyMs(), ...pm.getLastUsage() ? { total_tokens: pm.getLastUsage().totalTokens, prompt_tokens: pm.getLastUsage().promptTokens, completion_tokens: pm.getLastUsage().completionTokens } : {}, file_size: bytes };
         try {
           TelemetryCollector.getInstance().trackCodeSaved(summary);
         } catch {
@@ -74176,7 +74623,6 @@ async function handleCodeCommand(prompt) {
       }
       const pmBatch = getProviderManager();
       const batch = { files, total_bytes: totalBytes, provider: String(pmBatch.getLastUsedProvider() || "fallback"), model: String(pmBatch.getLastUsedModel() || "n/a"), config_source: pmBatch.getConfigSource(), fallback_any: true, latency_ms: pmBatch.getLastLatencyMs(), total_tokens: pmBatch.getLastUsage()?.totalTokens };
-      console.log(chalk36__default.default.gray(`telemetry: code.saved_batch ${JSON.stringify(batch)}`));
       try {
         TelemetryCollector.getInstance().trackCodeSavedBatch(batch);
       } catch {
@@ -74234,7 +74680,7 @@ ${e2.stack}`));
       for (const { language, code, extension, filename: suggested } of artifacts) {
         let filename = generateCodeFilename(prompt, language, extension, code, suggested);
         filename = sanitizeFilenameStrict(filename);
-        const ext2 = path54__namespace.extname(filename).slice(1);
+        const ext2 = path55__namespace.extname(filename).slice(1);
         const isBinary2 = isLikelyBinary(code);
         const inferred = isBinary2 ? "bin" : inferExtensionFromContent(language, code) || "txt";
         const finalExt = coerceExtension(ext2, inferred);
@@ -74247,15 +74693,13 @@ ${e2.stack}`));
         files += 1;
         if (progress) clearInterval(progress);
         if (isTTY) rl__namespace.cursorTo(process.stdout, 0);
-        console.log(chalk36__default.default.green(`\u2705 Saved 1 file: ${path54__namespace.basename(filepath)} (${language}${isBinary2 ? ", binary-like" : ""})`));
-        console.log(chalk36__default.default.gray(`\u{1F4CD} ${filepath}`));
-        console.log(chalk36__default.default.gray(`\u2139\uFE0F  Generated from: ${prompt.slice(0, 80)}`));
+        console.log(`Saved 1 file: ${path55__namespace.basename(filepath)} (${language}${isBinary2 ? ", binary-like" : ""})`);
+        console.log(`\u{1F4CD} ${filepath}`);
         const pm = getProviderManager();
         const provider = pm.getLastUsedProvider() || "fallback";
         const model = pm.getLastUsedModel() || "n/a";
         const source = pm.getConfigSource();
-        const summary = { filename: path54__namespace.basename(filepath), lang: String(language), provider: String(provider), model: String(model), config_source: source, fallback: true, latency_ms: pm.getLastLatencyMs(), ...pm.getLastUsage() ? { total_tokens: pm.getLastUsage().totalTokens, prompt_tokens: pm.getLastUsage().promptTokens, completion_tokens: pm.getLastUsage().completionTokens } : {}, file_size: bytes };
-        console.log(chalk36__default.default.gray(`telemetry: code.saved ${JSON.stringify(summary)}`));
+        const summary = { filename: path55__namespace.basename(filepath), lang: String(language), provider: String(provider), model: String(model), config_source: source, fallback: true, latency_ms: pm.getLastLatencyMs(), ...pm.getLastUsage() ? { total_tokens: pm.getLastUsage().totalTokens, prompt_tokens: pm.getLastUsage().promptTokens, completion_tokens: pm.getLastUsage().completionTokens } : {}, file_size: bytes };
         try {
           TelemetryCollector.getInstance().trackCodeSaved(summary);
         } catch {
@@ -74263,7 +74707,6 @@ ${e2.stack}`));
       }
       const pmBatch = getProviderManager();
       const batch = { files, total_bytes: totalBytes, provider: String(pmBatch.getLastUsedProvider() || "fallback"), model: String(pmBatch.getLastUsedModel() || "n/a"), config_source: pmBatch.getConfigSource(), fallback_any: true, latency_ms: pmBatch.getLastLatencyMs(), total_tokens: pmBatch.getLastUsage()?.totalTokens };
-      console.log(chalk36__default.default.gray(`telemetry: code.saved_batch ${JSON.stringify(batch)}`));
       try {
         TelemetryCollector.getInstance().trackCodeSavedBatch(batch);
       } catch {
@@ -74813,24 +75256,24 @@ function createCLI() {
     if (options.server) {
       console.log(chalk36__default.default.green("\u{1F680} Starting MARIA server mode..."));
       try {
-        const distDir = path54__namespace.dirname(process.argv[1] || process.cwd());
+        const distDir = path55__namespace.dirname(process.argv[1] || process.cwd());
         const candidateNames = [
           "server-express.mjs",
           "server-express.cjs",
           "server-express.js",
           // tsup emits CJS for server entry as dist/server/express-server.js
-          path54__namespace.join("server", "express-server.js"),
-          path54__namespace.join("server", "express-server.cjs")
+          path55__namespace.join("server", "express-server.js"),
+          path55__namespace.join("server", "express-server.cjs")
         ];
         const candidateDirs = [
           distDir,
-          path54__namespace.resolve(distDir, ".."),
+          path55__namespace.resolve(distDir, ".."),
           process.cwd()
         ];
         let serverPath = null;
         for (const dir of candidateDirs) {
           for (const name2 of candidateNames) {
-            const p = path54__namespace.join(dir, name2);
+            const p = path55__namespace.join(dir, name2);
             try {
               await fsp__namespace.access(p);
               serverPath = p;
@@ -74850,7 +75293,7 @@ function createCLI() {
         const serverProcess = spawn4("node", [serverPath], {
           stdio: "inherit",
           env: process.env,
-          cwd: path54__namespace.dirname(serverPath)
+          cwd: path55__namespace.dirname(serverPath)
         });
         let shutdownTimer = null;
         const forceExit = (defaultCode) => {