@bonginkan/maria 4.3.13 → 4.3.14

package/dist/bin/maria.cjs

@@ -2,7 +2,7 @@
 'use strict';
 
 var fs24 = require('fs');
-var path57 = require('path');
+var path58 = require('path');
 var chalk37 = require('chalk');
 var os16 = require('os');
 var Stream = require('stream');
@@ -55,7 +55,7 @@ function _interopNamespace(e) {
 }
 
 var fs24__namespace = /*#__PURE__*/_interopNamespace(fs24);
-var path57__namespace = /*#__PURE__*/_interopNamespace(path57);
+var path58__namespace = /*#__PURE__*/_interopNamespace(path58);
 var chalk37__default = /*#__PURE__*/_interopDefault(chalk37);
 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/
-      path57.join(__dirname, "../../package.json"),
+      path58.join(__dirname, "../../package.json"),
       // When running from source
-      path57.join(__dirname, "../../../package.json"),
+      path58.join(__dirname, "../../../package.json"),
       // Current working directory
-      path57.join(process.cwd(), "package.json"),
+      path58.join(process.cwd(), "package.json"),
       // One level up from current working directory
-      path57.join(process.cwd(), "../package.json"),
+      path58.join(process.cwd(), "../package.json"),
       // For globally installed packages
-      path57.join(__dirname, "../../../../package.json"),
-      path57.join(__dirname, "../../../../../package.json"),
+      path58.join(__dirname, "../../../../package.json"),
+      path58.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
-      path57.join(
+      path58.join(
         process.env.HOME || "",
         ".npm-global/lib/node_modules/@bonginkan/maria/package.json"
       ),
-      path57.join(
+      path58.join(
         process.env.HOME || "",
         ".nvm/versions/node",
         process.version,
@@ -233,13 +233,13 @@ function getPackageJson() {
       )
     ];
     let packageJsonPath = null;
-    for (const path58 of possiblePaths) {
-      if (fs24.existsSync(path58)) {
+    for (const path59 of possiblePaths) {
+      if (fs24.existsSync(path59)) {
         try {
-          const content = fs24.readFileSync(path58, "utf-8");
+          const content = fs24.readFileSync(path59, "utf-8");
           const parsed = JSON.parse(content);
           if (parsed.name === "@bonginkan/maria") {
-            packageJsonPath = path58;
+            packageJsonPath = path59;
             break;
           }
         } catch {
@@ -523,22 +523,22 @@ function dataUriToBuffer(uri) {
   if (firstComma === -1 || firstComma <= 4) {
     throw new TypeError("malformed data: URI");
   }
-  const meta24 = uri.substring(5, firstComma).split(";");
+  const meta25 = uri.substring(5, firstComma).split(";");
   let charset = "";
   let base64 = false;
-  const type2 = meta24[0] || "text/plain";
+  const type2 = meta25[0] || "text/plain";
   let typeFull = type2;
-  for (let i2 = 1; i2 < meta24.length; i2++) {
-    if (meta24[i2] === "base64") {
+  for (let i2 = 1; i2 < meta25.length; i2++) {
+    if (meta25[i2] === "base64") {
       base64 = true;
-    } else if (meta24[i2]) {
-      typeFull += `;${meta24[i2]}`;
-      if (meta24[i2].indexOf("charset=") === 0) {
-        charset = meta24[i2].substring(8);
+    } else if (meta25[i2]) {
+      typeFull += `;${meta25[i2]}`;
+      if (meta25[i2].indexOf("charset=") === 0) {
+        charset = meta25[i2].substring(8);
       }
     }
   }
-  if (!meta24[0] && !charset.length) {
+  if (!meta25[0] && !charset.length) {
     typeFull += ";charset=US-ASCII";
     charset = "US-ASCII";
   }
@@ -5312,22 +5312,22 @@ var init_from = __esm({
     init_file();
     init_fetch_blob();
     ({ stat } = fs24.promises);
-    blobFromSync = (path58, type2) => fromBlob(fs24.statSync(path58), path58, type2);
-    blobFrom = (path58, type2) => stat(path58).then((stat13) => fromBlob(stat13, path58, type2));
-    fileFrom = (path58, type2) => stat(path58).then((stat13) => fromFile(stat13, path58, type2));
-    fileFromSync = (path58, type2) => fromFile(fs24.statSync(path58), path58, type2);
-    fromBlob = (stat13, path58, type2 = "") => new fetch_blob_default([new BlobDataItem({
-      path: path58,
+    blobFromSync = (path59, type2) => fromBlob(fs24.statSync(path59), path59, type2);
+    blobFrom = (path59, type2) => stat(path59).then((stat13) => fromBlob(stat13, path59, type2));
+    fileFrom = (path59, type2) => stat(path59).then((stat13) => fromFile(stat13, path59, type2));
+    fileFromSync = (path59, type2) => fromFile(fs24.statSync(path59), path59, type2);
+    fromBlob = (stat13, path59, type2 = "") => new fetch_blob_default([new BlobDataItem({
+      path: path59,
       size: stat13.size,
       lastModified: stat13.mtimeMs,
       start: 0
     })], { type: type2 });
-    fromFile = (stat13, path58, type2 = "") => new file_default([new BlobDataItem({
-      path: path58,
+    fromFile = (stat13, path59, type2 = "") => new file_default([new BlobDataItem({
+      path: path59,
       size: stat13.size,
       lastModified: stat13.mtimeMs,
       start: 0
-    })], path57.basename(path58), { type: type2, lastModified: stat13.mtimeMs });
+    })], path58.basename(path59), { type: type2, lastModified: stat13.mtimeMs });
     BlobDataItem = class _BlobDataItem {
       #path;
       #start;
@@ -18796,6 +18796,292 @@ var init_logger = __esm({
   }
 });
 
+// src/services/base/TelemetryCollector.ts
+var TelemetryCollector, telemetry;
+var init_TelemetryCollector = __esm({
+  "src/services/base/TelemetryCollector.ts"() {
+    TelemetryCollector = class _TelemetryCollector {
+      _events = [];
+      maxEvents = 1e4;
+      _listeners = /* @__PURE__ */ new Map();
+      metricsCache = /* @__PURE__ */ new Map();
+      cacheExpiry = 6e4;
+      // 1 minute cache
+      lastCacheUpdate = 0;
+      eventCounters = /* @__PURE__ */ new Map();
+      static instance;
+      constructor() {
+      }
+      /**
+       * Get singleton instance
+       */
+      static getInstance() {
+        if (!_TelemetryCollector.instance) {
+          _TelemetryCollector.instance = new _TelemetryCollector();
+        }
+        return _TelemetryCollector.instance;
+      }
+      /**
+       * Emit a telemetry event
+       */
+      emit(event) {
+        const _telemetryEvent = {
+          ...event,
+          ts: Date.now()
+        };
+        this._events.push(_telemetryEvent);
+        if (this._events.length > this.maxEvents) {
+          this._events = this._events.slice(-this.maxEvents);
+        }
+        const _counterKey = `${event.event}:${event.tags.comp}`;
+        this.eventCounters.set(
+          _counterKey,
+          (this.eventCounters.get(_counterKey) ?? 0) + 1
+        );
+        this.lastCacheUpdate = 0;
+        this.notifyListeners(_telemetryEvent);
+        if (process.env.DEBUG_TELEMETRY === "true") {
+          this.logEvent(_telemetryEvent);
+        }
+      }
+      /**
+       * Start a timed operation
+       */
+      startTimer(event, tags) {
+        const _startTime = Date.now();
+        this.emit({
+          event,
+          tags
+        });
+        return () => {
+          const _duration = Date.now() - _startTime;
+          this.emit({
+            event: event.replace(".start", ".end"),
+            dur: _duration,
+            tags
+          });
+        };
+      }
+      /**
+       * Record an _error
+       */
+      recordError(component, _error, context2) {
+        const _errorData = this.extractErrorData(_error);
+        this.emit({
+          event: "system.error" /* SYSTEM_ERROR */,
+          tags: { _comp: component },
+          meta: context2,
+          _error: _errorData
+        });
+      }
+      /**
+       * Subscribe to _events
+       */
+      subscribe(pattern, _listener) {
+        const _key = pattern.toString();
+        if (!this._listeners.has(_key)) {
+          this._listeners.set(_key, /* @__PURE__ */ new Set());
+        }
+        this._listeners.get(_key).add(_listener);
+        return () => {
+          const _listeners = this._listeners.get(_key);
+          if (_listeners) {
+            _listeners.delete(_listener);
+            if (_listeners.size === 0) {
+              this._listeners.delete(_key);
+            }
+          }
+        };
+      }
+      /**
+       * Get _metrics for a component
+       */
+      getMetrics(component, window = 6e4) {
+        const _now = Date._now();
+        const _cacheKey = `${component ?? "all"}:${window}`;
+        if (_now - this.lastCacheUpdate < this.cacheExpiry) {
+          const _cached = this.metricsCache.get(_cacheKey);
+          if (_cached) {
+            return _cached;
+          }
+        }
+        const _metrics = component ? this.calculateMetrics(component, window) : this.calculateAllMetrics(window);
+        this.metricsCache.set(_cacheKey, _metrics);
+        this.lastCacheUpdate = _now;
+        return _metrics;
+      }
+      /**
+       * Calculate _metrics for a component
+       */
+      calculateMetrics(component, window) {
+        const _now = Date._now();
+        const _relevant = this._events.filter(
+          (e2) => _now - e2.ts < window && e2.tags.comp === component
+        );
+        const _durations = _relevant.filter((e2) => e2.dur !== void 0).map((e2) => e2.dur).sort((a, b) => a - b);
+        const _errors = _relevant.filter((e2) => e2._error !== void 0);
+        return {
+          eventCount: _relevant.length,
+          errorCount: _errors.length,
+          avgDuration: this.calculateAverage(_durations),
+          p50Duration: this.calculatePercentile(_durations, 0.5),
+          p95Duration: this.calculatePercentile(_durations, 0.95),
+          p99Duration: this.calculatePercentile(_durations, 0.99),
+          errorRate: _relevant.length > 0 ? _errors.length / _relevant.length : 0,
+          throughput: _relevant.length / (window / 1e3)
+          // _events per second
+        };
+      }
+      /**
+       * Calculate _metrics for all _components
+       */
+      calculateAllMetrics(window) {
+        const _components = ["memory", "kg", "conv", "learn", "system"];
+        const _metrics = {};
+        for (const _comp of _components) {
+          _metrics[_comp] = this.calculateMetrics(_comp, window);
+        }
+        return _metrics;
+      }
+      /**
+       * Calculate average
+       */
+      calculateAverage(values) {
+        if (values.length === 0) return 0;
+        const _sum = values.reduce((a, b) => a + b, 0);
+        return _sum / values.length;
+      }
+      /**
+       * Calculate percentile
+       */
+      calculatePercentile(sortedValues, percentile) {
+        if (sortedValues.length === 0) return 0;
+        const _index = Math.floor(sortedValues.length * percentile);
+        return sortedValues[Math.min(_index, sortedValues.length - 1)];
+      }
+      /**
+       * Extract _error data
+       */
+      extractErrorData(_error) {
+        if (_error instanceof Error) {
+          return {
+            message: _error.message,
+            stack: _error.stack,
+            code: _error.code
+          };
+        }
+        return {
+          message: String(_error)
+        };
+      }
+      /**
+       * Notify _listeners
+       */
+      notifyListeners(event) {
+        for (const [_pattern, _listeners] of this._listeners.entries()) {
+          const _regex = _pattern.startsWith("/") ? new RegExp(_pattern.slice(1, -1)) : new RegExp(_pattern);
+          if (_regex.test(event.event)) {
+            for (const _listener of _listeners) {
+              try {
+                _listener(event);
+              } catch (_error) {
+                console._error("Telemetry _listener _error:", _error);
+              }
+            }
+          }
+        }
+      }
+      /**
+       * Log event for debugging
+       */
+      logEvent(event) {
+        const _formatted = {
+          event: event.event,
+          component: event.tags.comp,
+          _duration: event.dur,
+          tags: Object.entries(event.tags).filter(([k]) => k !== "_comp").map(([k, v]) => `${k}=${v}`).join(" "),
+          meta: event.meta ? JSON.stringify(event.meta) : void 0,
+          _error: event._error?.message
+        };
+        console.log("[TEL]", JSON.stringify(_formatted));
+      }
+      /**
+       * Export _events for analysis
+       */
+      exportEvents(filter2) {
+        let _events = [...this._events];
+        if (filter2) {
+          if (filter2.component) {
+            _events = _events.filter((e2) => e2.tags.comp === filter2.component);
+          }
+          if (filter2._startTime) {
+            _events = _events.filter((e2) => e2.ts >= filter2._startTime);
+          }
+          if (filter2.endTime) {
+            _events = _events.filter((e2) => e2.ts <= filter2.endTime);
+          }
+          if (filter2.event) {
+            const _regex = filter2.event instanceof RegExp ? filter2.event : new RegExp(filter2.event);
+            _events = _events.filter((e2) => _regex.test(e2.event));
+          }
+        }
+        return _events;
+      }
+      /**
+       * Clear all _events
+       */
+      clear() {
+        this._events = [];
+        this.metricsCache.clear();
+        this.eventCounters.clear();
+        this.lastCacheUpdate = 0;
+      }
+      /**
+       * Get event _counts by type
+       */
+      getEventCounts() {
+        return new Map(this.eventCounters);
+      }
+      /**
+       * Generate summary _report
+       */
+      generateReport(window = 3e5) {
+        const _metrics = this.getMetrics(void 0, window);
+        const _counts = this.getEventCounts();
+        let _report = "=".repeat(80) + "\n";
+        _report += "TELEMETRY REPORT\n";
+        _report += "=".repeat(80) + "\n\n";
+        for (const [_comp, _met] of Object.entries(_metrics)) {
+          _report += `Component: ${_comp.toUpperCase()}
+`;
+          _report += "-".repeat(40) + "\n";
+          _report += `  Events: ${_met.eventCount}
+`;
+          _report += `  Errors: ${_met.errorCount} (${(_met.errorRate * 100).toFixed(2)}%)
+`;
+          _report += `  Avg Duration: ${_met.avgDuration.toFixed(2)}ms
+`;
+          _report += `  P95 Duration: ${_met.p95Duration.toFixed(2)}ms
+`;
+          _report += `  Throughput: ${_met.throughput.toFixed(2)} _events/sec
+`;
+          _report += "\n";
+        }
+        _report += "TOP EVENTS\n";
+        _report += "-".repeat(40) + "\n";
+        const _topEvents = Array.from(_counts.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10);
+        for (const [_event, _count] of _topEvents) {
+          _report += `  ${_event}: ${_count}
+`;
+        }
+        _report += "\n" + "=".repeat(80);
+        return _report;
+      }
+    };
+    telemetry = TelemetryCollector.getInstance();
+  }
+});
+
 // src/lib/command-groups.ts
 function getCommandInfo(command) {
   const raw = command.replace(/^\//, "");
@@ -19156,11 +19442,11 @@ var init_ConfigService = __esm({
       _saveDebounceTimer = null;
       _isDirty = false;
       constructor(configDir = process.env.MARIA_CONFIG_DIR || "~/.maria") {
-        this._configPath = path57__namespace.join(
+        this._configPath = path58__namespace.join(
           this.expandHome(configDir),
           "session.config.json"
         );
-        this._userConfigPath = path57__namespace.join(
+        this._userConfigPath = path58__namespace.join(
           this.expandHome(configDir),
           "user.config.json"
         );
@@ -19235,8 +19521,8 @@ var init_ConfigService = __esm({
       /**
        * ネストされた設定値の取得
        */
-      getNestedValue(path58) {
-        const keys = path58.split(".");
+      getNestedValue(path59) {
+        const keys = path59.split(".");
         let value = this._config;
         for (const key of keys) {
           if (value && typeof value === "object" && key in value) {
@@ -19266,8 +19552,8 @@ var init_ConfigService = __esm({
       /**
        * ネストされた設定値の更新
        */
-      async setNestedValue(path58, value) {
-        const keys = path58.split(".");
+      async setNestedValue(path59, value) {
+        const keys = path59.split(".");
         const lastKey = keys.pop();
         let target = this._config;
         for (const key of keys) {
@@ -19280,7 +19566,7 @@ var init_ConfigService = __esm({
         target[lastKey] = value;
         this.validateConfig();
         this.emitChange({
-          path: path58,
+          path: path59,
           oldValue,
           newValue: value,
           timestamp: /* @__PURE__ */ new Date()
@@ -19294,7 +19580,7 @@ var init_ConfigService = __esm({
       async save() {
         if (!this._isDirty) return;
         try {
-          const configDir = path57__namespace.dirname(this._userConfigPath);
+          const configDir = path58__namespace.dirname(this._userConfigPath);
           await fsp__namespace.mkdir(configDir, { recursive: true });
           await fsp__namespace.writeFile(
             this._userConfigPath,
@@ -19337,13 +19623,13 @@ var init_ConfigService = __esm({
       /**
        * 変更リスナーの登録
        */
-      onChange(path58, listener) {
-        if (!this._listeners.has(path58)) {
-          this._listeners.set(path58, []);
+      onChange(path59, listener) {
+        if (!this._listeners.has(path59)) {
+          this._listeners.set(path59, []);
         }
-        this._listeners.get(path58).push(listener);
+        this._listeners.get(path59).push(listener);
         return () => {
-          const listeners = this._listeners.get(path58);
+          const listeners = this._listeners.get(path59);
           if (listeners) {
             const index = listeners.indexOf(listener);
             if (index !== -1) {
@@ -19394,7 +19680,7 @@ var init_ConfigService = __esm({
        */
       expandHome(filePath) {
         if (filePath.startsWith("~/")) {
-          return path57__namespace.join(process.env.HOME || "", filePath.slice(2));
+          return path58__namespace.join(process.env.HOME || "", filePath.slice(2));
         }
         return filePath;
       }
@@ -19832,7 +20118,7 @@ var init_ValidationService = __esm({
         );
         this._schemas.set(
           "filePath",
-          zod.z.string().min(1).max(this._config.maxFilePathLength).refine((path58) => !this.containsPathTraversal(path58), {
+          zod.z.string().min(1).max(this._config.maxFilePathLength).refine((path59) => !this.containsPathTraversal(path59), {
             message: "Path traversal detected"
           })
         );
@@ -19971,11 +20257,11 @@ var init_ValidationService = __esm({
       /**
        * ファイルパス検証
        */
-      validateFilePath(path58) {
+      validateFilePath(path59) {
         try {
           const schema2 = this._schemas.get("filePath");
-          const result = schema2.parse(path58);
-          if (this.isSystemPath(path58)) {
+          const result = schema2.parse(path59);
+          if (this.isSystemPath(path59)) {
             return {
               valid: false,
               errors: [
@@ -20121,8 +20407,8 @@ var init_ValidationService = __esm({
       /**
        * パストラバーサルの検出
        */
-      containsPathTraversal(path58) {
-        return /\.\.[/\\]/.test(path58) || path58.includes("..\\") || path58.includes("../");
+      containsPathTraversal(path59) {
+        return /\.\.[/\\]/.test(path59) || path59.includes("..\\") || path59.includes("../");
       }
       /**
        * 危険なコマンドの判定
@@ -20149,7 +20435,7 @@ var init_ValidationService = __esm({
       /**
        * システムパスの判定
        */
-      isSystemPath(path58) {
+      isSystemPath(path59) {
         const systemPaths = [
           "/etc",
           "/sys",
@@ -20163,7 +20449,7 @@ var init_ValidationService = __esm({
           "/sbin"
         ];
         return systemPaths.some(
-          (sysPath) => path58.toLowerCase().startsWith(sysPath.toLowerCase())
+          (sysPath) => path59.toLowerCase().startsWith(sysPath.toLowerCase())
         );
       }
       /**
@@ -24263,12 +24549,12 @@ describe("${target}", () => {
 // src/services/ai-response/telemetry/telemetry-collector.ts
 var telemetry_collector_exports = {};
 __export(telemetry_collector_exports, {
-  TelemetryCollector: () => TelemetryCollector
+  TelemetryCollector: () => TelemetryCollector2
 });
-var TelemetryCollector;
+var TelemetryCollector2;
 var init_telemetry_collector = __esm({
   "src/services/ai-response/telemetry/telemetry-collector.ts"() {
-    TelemetryCollector = class _TelemetryCollector {
+    TelemetryCollector2 = class _TelemetryCollector {
       static instance;
       events = [];
       sessionId;
@@ -25125,8 +25411,8 @@ Run /doctor --fix to automatically fix ${fixableCount} issue(s)`
           if (outputPath) {
             try {
               const fs48 = await import('fs/promises');
-              const path58 = await import('path');
-              const abs = path58.resolve(outputPath);
+              const path59 = await import('path');
+              const abs = path59.resolve(outputPath);
               await fs48.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") } };
@@ -25218,8 +25504,8 @@ Run /doctor --fix to automatically fix ${fixableCount} issue(s)`
           if (outputPath) {
             try {
               const fs48 = await import('fs/promises');
-              const path58 = await import('path');
-              const abs = path58.resolve(outputPath);
+              const path59 = await import('path');
+              const abs = path59.resolve(outputPath);
               await fs48.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") } };
@@ -25609,15 +25895,15 @@ var init_SessionOrchestrator = __esm({
       /**
        * 設定の取得
        */
-      getConfig(path58) {
-        return this._configService?.getNestedValue(path58);
+      getConfig(path59) {
+        return this._configService?.getNestedValue(path59);
       }
       /**
        * 設定の更新
        */
-      async setConfig(path58, value) {
+      async setConfig(path59, value) {
         if (this._configService) {
-          await this._configService.setNestedValue(path58, value);
+          await this._configService.setNestedValue(path59, value);
         }
       }
       /**
@@ -25735,11 +26021,11 @@ var init_interactive_session = __esm({
       getStats() {
         return this.orchestrator.getSessionStats();
       }
-      getConfig(path58) {
-        return this.orchestrator.getConfig(path58);
+      getConfig(path59) {
+        return this.orchestrator.getConfig(path59);
       }
-      async setConfig(path58, value) {
-        await this.orchestrator.setConfig(path58, value);
+      async setConfig(path59, value) {
+        await this.orchestrator.setConfig(path59, value);
       }
     };
   }
@@ -25750,8 +26036,8 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@bonginkan/maria",
-      version: "4.3.13",
-      description: "\u{1F680} MARIA v4.3.13 - Enterprise AI Development Platform with enhanced interactive prompt improvements and choice memory system. 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.14",
+      description: "\u{1F680} MARIA v4.3.14 - Enterprise AI Development Platform with identity system and character voice implementation. Features 74 production-ready commands with comprehensive fallback implementation, local LLM support, and zero external dependencies. Includes natural language coding, AI safety evaluation, intelligent evolution system, episodic memory with PII masking, and real-time monitoring dashboard. Built with TypeScript AST-powered code generation, OAuth2.0 + PKCE authentication, quantum-resistant cryptography, and enterprise-grade performance.",
       keywords: [
         "ai",
         "cli",
@@ -26270,21 +26556,21 @@ var require_package = __commonJS({
   }
 });
 function loadEnvironmentVariables() {
-  const _envPath = path57__namespace.join(process.cwd(), ".env");
+  const _envPath = path58__namespace.join(process.cwd(), ".env");
   if (fs24__namespace.existsSync(_envPath)) {
     const _result = dotenv__namespace.config({ path: _envPath });
     if (_result.error) {
       console.warn("Error loading .env:", _result.error);
     }
   }
-  const _envLocalPath = path57__namespace.join(process.cwd(), ".env.local");
+  const _envLocalPath = path58__namespace.join(process.cwd(), ".env.local");
   if (fs24__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 = path57__namespace.join(process.cwd(), ".env.lmstudio");
+  const _lmstudioEnvPath = path58__namespace.join(process.cwd(), ".env.lmstudio");
   if (fs24__namespace.existsSync(_lmstudioEnvPath)) {
     const _result = dotenv__namespace.config({ path: _lmstudioEnvPath, override: false });
     if (_result.error) {
@@ -26682,11 +26968,11 @@ var init_OAuth2PKCEClient = __esm({
           redirectUri: config2.redirectUri || "http://127.0.0.1:9876/callback",
           authServerUrl: config2.authServerUrl || "https://maria-code.ai"
         };
-        const configDir = path57__namespace.join(os16__namespace.homedir(), ".maria");
+        const configDir = path58__namespace.join(os16__namespace.homedir(), ".maria");
         if (!fs24__namespace.existsSync(configDir)) {
           fs24__namespace.mkdirSync(configDir, { recursive: true });
         }
-        this.tokenStoragePath = path57__namespace.join(configDir, "auth-tokens.json");
+        this.tokenStoragePath = path58__namespace.join(configDir, "auth-tokens.json");
       }
       /**
        * Generate cryptographically secure random string
@@ -27264,11 +27550,11 @@ var init_CLIAuthService = __esm({
       configPath;
       config;
       constructor(config2) {
-        const configDir = path57__namespace.join(os16__namespace.homedir(), ".maria");
+        const configDir = path58__namespace.join(os16__namespace.homedir(), ".maria");
         if (!fs24__namespace.existsSync(configDir)) {
           fs24__namespace.mkdirSync(configDir, { recursive: true });
         }
-        this.configPath = path57__namespace.join(configDir, "cli-config.json");
+        this.configPath = path58__namespace.join(configDir, "cli-config.json");
         this.config = this.loadConfig(config2);
         this.authClient = new OAuth2PKCEClient({
           authorizationEndpoint: `${this.config.authServerUrl}/oauth/authorize`,
@@ -27590,8 +27876,8 @@ var init_TokenStorage = __esm({
     TokenStorage = class {
       SERVICE_NAME = "maria-cli";
       ACCOUNT_NAME = "default";
-      CONFIG_DIR = path57__namespace.default.join(os16__namespace.default.homedir(), ".maria");
-      TOKEN_FILE = path57__namespace.default.join(this.CONFIG_DIR, "auth-tokens.json");
+      CONFIG_DIR = path58__namespace.default.join(os16__namespace.default.homedir(), ".maria");
+      TOKEN_FILE = path58__namespace.default.join(this.CONFIG_DIR, "auth-tokens.json");
       /**
        * Save tokens securely
        */
@@ -28680,9 +28966,9 @@ function getDeviceId() {
 function getSessionId() {
   return global.MARIA_SESSION_ID;
 }
-async function callApi(path58, init2 = {}) {
+async function callApi(path59, init2 = {}) {
   const apiBase = process.env.MARIA_API_BASE || "http://localhost:3001";
-  const fullUrl = `${apiBase}${path58}`;
+  const fullUrl = `${apiBase}${path59}`;
   let tokens2 = await authManager.getValidTokens();
   if (!tokens2) {
     console.log(chalk37__default.default.red(ERR.AUTH_REQUIRED.msg));
@@ -28751,8 +29037,8 @@ async function callApi(path58, init2 = {}) {
   }
   return response;
 }
-async function callApiJson(path58, init2 = {}) {
-  const response = await callApi(path58, init2);
+async function callApiJson(path59, init2 = {}) {
+  const response = await callApi(path59, init2);
   if (!response.ok) {
     const error2 = await response.json().catch(() => ({
       message: `API error: ${response.status} ${response.statusText}`
@@ -28904,7 +29190,7 @@ var init_choice_memory = __esm({
       track(eventType, data) {
         try {
           if (!this.telemetry) {
-            this.telemetry = TelemetryCollector.getInstance();
+            this.telemetry = TelemetryCollector2.getInstance();
           }
           this.telemetry.trackCustom(eventType, data);
         } catch {
@@ -29047,7 +29333,7 @@ var init_chat_context_service = __esm({
           // 400K session window
           compressionThreshold: config2?.compressionThreshold || 0.8,
           summaryTokenLimit: config2?.summaryTokenLimit || 2e3,
-          persistPath: config2?.persistPath || path57__namespace.join(process.env["HOME"] || "", ".maria", "context")
+          persistPath: config2?.persistPath || path58__namespace.join(process.env["HOME"] || "", ".maria", "context")
         };
         this.sessionId = this.generateSessionId();
       }
@@ -29171,7 +29457,7 @@ var init_chat_context_service = __esm({
         if (!this.config.persistPath) return;
         try {
           await fsp__namespace.mkdir(this.config.persistPath, { recursive: true });
-          const sessionFile = path57__namespace.join(
+          const sessionFile = path58__namespace.join(
             this.config.persistPath,
             `${this.sessionId}.json`
           );
@@ -29242,8 +29528,8 @@ var init_conversation_persistence = __esm({
       autoSaveInterval = null;
       pendingWrites = [];
       constructor(maxHistorySize = 100) {
-        const configDir = path57__namespace.join(os16__namespace.homedir(), ".maria");
-        this.sessionFile = path57__namespace.join(configDir, "conversation-history.json");
+        const configDir = path58__namespace.join(os16__namespace.homedir(), ".maria");
+        this.sessionFile = path58__namespace.join(configDir, "conversation-history.json");
         this.maxHistorySize = maxHistorySize;
         this.ensureConfigDir();
         this.startAutoSave();
@@ -29253,7 +29539,7 @@ var init_conversation_persistence = __esm({
        */
       async ensureConfigDir() {
         try {
-          const configDir = path57__namespace.dirname(this.sessionFile);
+          const configDir = path58__namespace.dirname(this.sessionFile);
           await fs24.promises.mkdir(configDir, { recursive: true });
         } catch (error2) {
           console.warn("Failed to create config directory:", error2);
@@ -30721,9 +31007,9 @@ var FallbackManager;
 var init_FallbackManager = __esm({
   "src/services/fallback/FallbackManager.ts"() {
     FallbackManager = class {
-      constructor(policy, telemetry) {
+      constructor(policy, telemetry2) {
         this.policy = policy;
-        this.telemetry = telemetry;
+        this.telemetry = telemetry2;
       }
       async run(attempt, opts = {}) {
         const primary = await attempt();
@@ -33407,9 +33693,9 @@ function applyEnvOverrides(policy) {
 function resolvePolicyPath(customPath) {
   const envPath = process.env.MARIA_FALLBACK_POLICY_PATH;
   if (envPath && envPath.trim().length > 0) {
-    return path57__namespace.default.resolve(envPath);
+    return path58__namespace.default.resolve(envPath);
   }
-  return path57__namespace.default.resolve(process.cwd(), "config", "fallback-policy.yaml");
+  return path58__namespace.default.resolve(process.cwd(), "config", "fallback-policy.yaml");
 }
 async function loadFallbackPolicy(customPath) {
   const policyPath = resolvePolicyPath();
@@ -33732,7 +34018,7 @@ var ai_response_service_exports = {};
 __export(ai_response_service_exports, {
   AIResponseService: () => AIResponseService
 });
-var PLAIN_OUTPUT, DISABLE_SAFETY_GUARD, AIResponseService;
+var PLAIN_OUTPUT, DISABLE_SAFETY_GUARD, TEMPLATE_FALLBACK_ENABLED, AIResponseService;
 var init_ai_response_service = __esm({
   "src/services/ai-response.service.ts"() {
     init_chat_context_service();
@@ -33750,6 +34036,7 @@ var init_ai_response_service = __esm({
     init_safety();
     PLAIN_OUTPUT = process.env.MARIA_PLAIN_OUTPUT === "1" || process.env.MARIA_DISABLE_GUIDED_FLOW === "1";
     DISABLE_SAFETY_GUARD = process.env.MARIA_DISABLE_SAFETY_GUARD === "1";
+    TEMPLATE_FALLBACK_ENABLED = process.env.MARIA_ENABLE_TEMPLATE_FALLBACK === "1";
     AIResponseService = class {
       chatContext;
       _conversationPersistence;
@@ -33762,7 +34049,7 @@ var init_ai_response_service = __esm({
       constructor() {
         this.chatContext = ChatContextService.getInstance();
         this._conversationPersistence = new ConversationPersistence();
-        this.telemetry = TelemetryCollector.getInstance();
+        this.telemetry = TelemetryCollector2.getInstance();
         this.providerManager = getProviderManager();
         this.initializeProviders().catch(() => void 0);
       }
@@ -34087,6 +34374,7 @@ ${fallbackMessage}` : fallbackMessage : finalResponse;
         if (PLAIN_OUTPUT) {
           switch (intent.type) {
             case "CODE_REQUEST":
+              if (!TEMPLATE_FALLBACK_ENABLED) return "";
               if (/\bcli\b/i.test(userInput)) return generateCLITemplate(isJapanese);
               if (/\b(api|rest)\b/i.test(userInput))
                 return generateNextAPITemplate(isJapanese);
@@ -34099,8 +34387,10 @@ ${fallbackMessage}` : fallbackMessage : finalResponse;
         }
         switch (intent.type) {
           case "TETRIS_REQUEST":
+            if (!TEMPLATE_FALLBACK_ENABLED) return "";
             return isExplicitContentAllowed(userInput, "tetris") ? generateTetrisGameTemplate(userInput) : this.generateDefaultResponse(userInput);
           case "CODE_REQUEST":
+            if (!TEMPLATE_FALLBACK_ENABLED) return "";
             if (/\bcli\b/i.test(userInput)) return generateCLITemplate(isJapanese);
             if (/\b(api|next|rest)\b/i.test(userInput))
               return generateNextAPITemplate(isJapanese);
@@ -34625,14 +34915,14 @@ var init_ReadyCommandsService = __esm({
         } else {
           const possiblePaths = [
             // For bundled dist version
-            path57__namespace.join(__dirname, "READY.manifest.json"),
-            path57__namespace.join(__dirname, "../READY.manifest.json"),
-            path57__namespace.join(process.cwd(), "dist/READY.manifest.json"),
+            path58__namespace.join(__dirname, "READY.manifest.json"),
+            path58__namespace.join(__dirname, "../READY.manifest.json"),
+            path58__namespace.join(process.cwd(), "dist/READY.manifest.json"),
             // For development/source version
-            path57__namespace.join(__dirname, "../../../src/slash-commands/READY.manifest.json"),
-            path57__namespace.join(__dirname, "../../slash-commands/READY.manifest.json"),
-            path57__namespace.join(process.cwd(), "src/slash-commands/READY.manifest.json"),
-            path57__namespace.join(process.cwd(), "READY.manifest.json")
+            path58__namespace.join(__dirname, "../../../src/slash-commands/READY.manifest.json"),
+            path58__namespace.join(__dirname, "../../slash-commands/READY.manifest.json"),
+            path58__namespace.join(process.cwd(), "src/slash-commands/READY.manifest.json"),
+            path58__namespace.join(process.cwd(), "READY.manifest.json")
           ];
           this.manifestPath = possiblePaths[0];
         }
@@ -34643,17 +34933,17 @@ var init_ReadyCommandsService = __esm({
       async findManifestPath() {
         const possiblePaths = [
           // For bundled dist version
-          path57__namespace.join(__dirname, "READY.manifest.json"),
-          path57__namespace.join(__dirname, "../READY.manifest.json"),
-          path57__namespace.join(process.cwd(), "dist/READY.manifest.json"),
+          path58__namespace.join(__dirname, "READY.manifest.json"),
+          path58__namespace.join(__dirname, "../READY.manifest.json"),
+          path58__namespace.join(process.cwd(), "dist/READY.manifest.json"),
           // For development/source version
-          path57__namespace.join(__dirname, "../../../src/slash-commands/READY.manifest.json"),
-          path57__namespace.join(__dirname, "../../slash-commands/READY.manifest.json"),
-          path57__namespace.join(process.cwd(), "src/slash-commands/READY.manifest.json"),
-          path57__namespace.join(process.cwd(), "READY.manifest.json"),
+          path58__namespace.join(__dirname, "../../../src/slash-commands/READY.manifest.json"),
+          path58__namespace.join(__dirname, "../../slash-commands/READY.manifest.json"),
+          path58__namespace.join(process.cwd(), "src/slash-commands/READY.manifest.json"),
+          path58__namespace.join(process.cwd(), "READY.manifest.json"),
           // Additional paths for different build scenarios
-          path57__namespace.resolve(__dirname, "../../../src/slash-commands/READY.manifest.json"),
-          path57__namespace.resolve(process.cwd(), "src/slash-commands/READY.manifest.json")
+          path58__namespace.resolve(__dirname, "../../../src/slash-commands/READY.manifest.json"),
+          path58__namespace.resolve(process.cwd(), "src/slash-commands/READY.manifest.json")
         ];
         for (const testPath of possiblePaths) {
           try {
@@ -35221,7 +35511,7 @@ async function loadFirebaseAdmin() {
   try {
     const firebaseAdminModule = await import('firebase-admin/app');
     const firestoreModule = await import('firebase-admin/firestore');
-    const keyPath = path57__namespace.join(process.cwd(), "config", "maria-cli-firestore-key.json");
+    const keyPath = path58__namespace.join(process.cwd(), "config", "maria-cli-firestore-key.json");
     if (!adminApp && firebaseAdminModule.getApps().length === 0) {
       adminApp = firebaseAdminModule.initializeApp({
         credential: firebaseAdminModule.cert(keyPath),
@@ -35593,8 +35883,8 @@ var init_bigquery_telemetry = __esm({
 });
 async function getUserContext() {
   try {
-    const configDir = path57__namespace.join(process.env.HOME || process.env.USERPROFILE || "", ".maria");
-    const authFile = path57__namespace.join(configDir, "auth.json");
+    const configDir = path58__namespace.join(process.env.HOME || process.env.USERPROFILE || "", ".maria");
+    const authFile = path58__namespace.join(configDir, "auth.json");
     if (await fs11__namespace.pathExists(authFile)) {
       const authData = await fs11__namespace.readJson(authFile);
       return {
@@ -36762,7 +37052,7 @@ var init_setup_command = __esm({
           if (_setupRecord.filesGenerated) {
             for (const file of _setupRecord.filesGenerated) {
               try {
-                const _filePath = path57__namespace.default.join(context2.environment.cwd, file);
+                const _filePath = path58__namespace.default.join(context2.environment.cwd, file);
                 await fsp__namespace.default.unlink(_filePath);
                 restoredFiles.push(file);
               } catch (innerError) {
@@ -36772,7 +37062,7 @@ var init_setup_command = __esm({
               }
             }
           }
-          const _setupRecordPath = path57__namespace.default.join(
+          const _setupRecordPath = path58__namespace.default.join(
             context2.environment.cwd,
             ".maria",
             "setup.json"
@@ -36840,7 +37130,7 @@ var init_setup_command = __esm({
         }
       }
       async recordSetupCompletion(_context, result) {
-        const _mariaDir = path57__namespace.default.join(_context.environment.cwd, ".maria");
+        const _mariaDir = path58__namespace.default.join(_context.environment.cwd, ".maria");
         await fsp__namespace.default.mkdir(_mariaDir, { recursive: true });
         const _setupRecord = {
           ...result,
@@ -36848,7 +37138,7 @@ var init_setup_command = __esm({
           version: "1.0.0",
           environment: _context.environment
         };
-        const _recordPath = path57__namespace.default.join(_mariaDir, "setup.json");
+        const _recordPath = path58__namespace.default.join(_mariaDir, "setup.json");
         await fsp__namespace.default.writeFile(
           _recordPath,
           JSON.stringify(_setupRecord, null, 2),
@@ -36947,14 +37237,14 @@ Estimated time: 3-5 minutes
       }
       async detectConfigurationIssues(context2) {
         const _issues = [];
-        if (!await this.fileExists(path57__namespace.default.join(context2.environment.cwd, ".env.local"))) {
+        if (!await this.fileExists(path58__namespace.default.join(context2.environment.cwd, ".env.local"))) {
           _issues.push({
             description: "Missing .env.local file",
             severity: "error"
           });
         }
         if (!await this.fileExists(
-          path57__namespace.default.join(context2.environment.cwd, ".maria-code.toml")
+          path58__namespace.default.join(context2.environment.cwd, ".maria-code.toml")
         )) {
           _issues.push({
             description: "Missing .maria-code.toml file",
@@ -36970,7 +37260,7 @@ Estimated time: 3-5 minutes
       }
       async getSetupRecord(context2) {
         try {
-          const _recordPath = path57__namespace.default.join(
+          const _recordPath = path58__namespace.default.join(
             context2.environment.cwd,
             ".maria",
             "setup.json"
@@ -36982,11 +37272,11 @@ Estimated time: 3-5 minutes
         }
       }
       async validateEnvironmentFile(context2) {
-        return this.fileExists(path57__namespace.default.join(context2.environment.cwd, ".env.local"));
+        return this.fileExists(path58__namespace.default.join(context2.environment.cwd, ".env.local"));
       }
       async validateConfigFile(context2) {
         return this.fileExists(
-          path57__namespace.default.join(context2.environment.cwd, ".maria-code.toml")
+          path58__namespace.default.join(context2.environment.cwd, ".maria-code.toml")
         );
       }
       async validateProviderConnections(_context) {
@@ -37013,7 +37303,7 @@ VLLM_API_URL=http://localhost:8000
 DEBUG=false
 LOG_LEVEL=info
 `;
-          const _envPath = path57__namespace.default.join(process.cwd(), ".env.local");
+          const _envPath = path58__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"],
@@ -37087,8 +37377,8 @@ var init_ConfigurationCommandService = __esm({
 var DIR, FILE, QuickPersistence;
 var init_quick_persistence = __esm({
   "src/services/memory-system/quick-persistence.ts"() {
-    DIR = path57__namespace.join(os16__namespace.homedir(), ".maria", "memory");
-    FILE = path57__namespace.join(DIR, "memories.jsonl");
+    DIR = path58__namespace.join(os16__namespace.homedir(), ".maria", "memory");
+    FILE = path58__namespace.join(DIR, "memories.jsonl");
     QuickPersistence = class {
       static async init() {
         await fsp__namespace.mkdir(DIR, { recursive: true });
@@ -37210,8 +37500,8 @@ var init_quick_persistence = __esm({
         const mine = rows.filter((r2) => r2.userId === userId);
         const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
         const filename = `maria-memory-export-${timestamp2}.${format}`;
-        const exportDir = path57__namespace.join(os16__namespace.homedir(), ".maria", "exports");
-        const exportPath = path57__namespace.join(exportDir, filename);
+        const exportDir = path58__namespace.join(os16__namespace.homedir(), ".maria", "exports");
+        const exportPath = path58__namespace.join(exportDir, filename);
         await fsp__namespace.mkdir(exportDir, { recursive: true });
         if (format === "jsonl") {
           await fsp__namespace.writeFile(
@@ -39845,7 +40135,7 @@ var init_StateManager = __esm({
       maxCheckpointAge = 7 * 24 * 60 * 60 * 1e3;
       // 7 days
       constructor() {
-        this.checkpointsDir = path57__namespace.join(os16__namespace.homedir(), ".maria", "checkpoints");
+        this.checkpointsDir = path58__namespace.join(os16__namespace.homedir(), ".maria", "checkpoints");
       }
       /**
        * Initialize checkpoints directory
@@ -39871,7 +40161,7 @@ var init_StateManager = __esm({
         const checkpointId = `${planId}_${Date.now()}`;
         const timestamp2 = Date.now();
         try {
-          const checkpointPath = path57__namespace.join(this.checkpointsDir, checkpointId);
+          const checkpointPath = path58__namespace.join(this.checkpointsDir, checkpointId);
           await fsp__namespace.mkdir(checkpointPath, { recursive: true });
           const backups = await this.createBackups(actions, checkpointPath);
           const configSnapshots = await this.createConfigSnapshots(
@@ -39890,7 +40180,7 @@ var init_StateManager = __esm({
               riskScore
             }
           };
-          const metadataPath = path57__namespace.join(checkpointPath, "checkpoint.json");
+          const metadataPath = path58__namespace.join(checkpointPath, "checkpoint.json");
           await fsp__namespace.writeFile(
             metadataPath,
             JSON.stringify(checkpoint, null, 2),
@@ -40062,7 +40352,7 @@ var init_StateManager = __esm({
        */
       async removeCheckpoint(checkpointId) {
         try {
-          const checkpointPath = path57__namespace.join(this.checkpointsDir, checkpointId);
+          const checkpointPath = path58__namespace.join(this.checkpointsDir, checkpointId);
           await fsp__namespace.rm(checkpointPath, { recursive: true, force: true });
           logger.info(`StateManager: Removed checkpoint ${checkpointId}`);
           return true;
@@ -40093,7 +40383,7 @@ var init_StateManager = __esm({
        */
       async createBackups(actions, checkpointPath) {
         const backups = [];
-        const backupDir = path57__namespace.join(checkpointPath, "backups");
+        const backupDir = path58__namespace.join(checkpointPath, "backups");
         await fsp__namespace.mkdir(backupDir, { recursive: true });
         for (const action of actions) {
           const filesToBackup = this.extractFilePathsFromAction(action);
@@ -40102,7 +40392,7 @@ var init_StateManager = __esm({
               const resolvedPath = this.resolvePath(filePath);
               const stats = await fsp__namespace.stat(resolvedPath);
               const backupFileName = this.sanitizeFileName(resolvedPath);
-              const backupPath = path57__namespace.join(backupDir, backupFileName);
+              const backupPath = path58__namespace.join(backupDir, backupFileName);
               await fsp__namespace.copyFile(resolvedPath, backupPath);
               backups.push({
                 originalPath: resolvedPath,
@@ -40125,7 +40415,7 @@ var init_StateManager = __esm({
        */
       async createConfigSnapshots(actions, checkpointPath) {
         const snapshots = [];
-        const configDir = path57__namespace.join(checkpointPath, "configs");
+        const configDir = path58__namespace.join(checkpointPath, "configs");
         await fsp__namespace.mkdir(configDir, { recursive: true });
         const configPaths = /* @__PURE__ */ new Set();
         for (const action of actions) {
@@ -40158,7 +40448,7 @@ var init_StateManager = __esm({
        * Load checkpoint from disk
        */
       async loadCheckpoint(checkpointId) {
-        const metadataPath = path57__namespace.join(
+        const metadataPath = path58__namespace.join(
           this.checkpointsDir,
           checkpointId,
           "checkpoint.json"
@@ -40184,9 +40474,9 @@ var init_StateManager = __esm({
        */
       resolvePath(filePath) {
         if (filePath.startsWith("~/")) {
-          return path57__namespace.join(os16__namespace.homedir(), filePath.slice(2));
+          return path58__namespace.join(os16__namespace.homedir(), filePath.slice(2));
         }
-        return path57__namespace.resolve(filePath);
+        return path58__namespace.resolve(filePath);
       }
       /**
        * Sanitize filename for backup storage
@@ -40250,7 +40540,7 @@ var init_StateManager = __esm({
           } catch {
           }
         } else {
-          await fsp__namespace.mkdir(path57__namespace.dirname(config2.configPath), { recursive: true });
+          await fsp__namespace.mkdir(path58__namespace.dirname(config2.configPath), { recursive: true });
           await fsp__namespace.writeFile(config2.configPath, config2.content, "utf-8");
         }
         logger.debug(`StateManager: Restored config ${config2.configPath}`);
@@ -40368,9 +40658,9 @@ var init_SafetyGuard = __esm({
           }
         }
         if (action.args.paths && Array.isArray(action.args.paths)) {
-          for (const path58 of action.args.paths) {
-            if (!this.validatePath(path58)) {
-              violations.push(`Invalid path: ${path58}`);
+          for (const path59 of action.args.paths) {
+            if (!this.validatePath(path59)) {
+              violations.push(`Invalid path: ${path59}`);
             }
           }
         }
@@ -40426,15 +40716,15 @@ var init_SafetyGuard = __esm({
        * Validate file path against allowed/blocked lists
        */
       validatePath(filePath) {
-        const path58 = __require("path");
-        const resolvedPath = path58.resolve(filePath);
+        const path59 = __require("path");
+        const resolvedPath = path59.resolve(filePath);
         for (const blockedPath of this.constraints.blockedPaths) {
-          if (resolvedPath.startsWith(path58.resolve(blockedPath))) {
+          if (resolvedPath.startsWith(path59.resolve(blockedPath))) {
             return false;
           }
         }
         for (const allowedPath of this.constraints.allowedPaths) {
-          if (resolvedPath.startsWith(path58.resolve(allowedPath))) {
+          if (resolvedPath.startsWith(path59.resolve(allowedPath))) {
             return true;
           }
         }
@@ -40463,9 +40753,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 path58 of action.args.paths) {
-              if (!this.validatePath(path58)) {
-                violations.push(`Invalid path in ${action.type}: ${path58}`);
+            for (const path59 of action.args.paths) {
+              if (!this.validatePath(path59)) {
+                violations.push(`Invalid path in ${action.type}: ${path59}`);
               }
             }
           }
@@ -40564,7 +40854,7 @@ var init_AuditLogger = __esm({
       constructor(sessionId, options = {}) {
         this.sessionId = sessionId;
         this.options = {
-          logDir: path57__namespace.join(os16__namespace.homedir(), ".maria", "audit"),
+          logDir: path58__namespace.join(os16__namespace.homedir(), ".maria", "audit"),
           maxLogSize: 10 * 1024 * 1024,
           // 10MB
           maxLogFiles: 30,
@@ -40574,7 +40864,7 @@ var init_AuditLogger = __esm({
           ...options
         };
         const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-        this.logFilePath = path57__namespace.join(this.options.logDir, `audit-${date}.jsonl`);
+        this.logFilePath = path58__namespace.join(this.options.logDir, `audit-${date}.jsonl`);
       }
       /**
        * Initialize audit logging
@@ -40863,7 +41153,7 @@ var init_AuditLogger = __esm({
         try {
           const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
           const timestamp2 = Date.now();
-          const archivePath = path57__namespace.join(
+          const archivePath = path58__namespace.join(
             this.options.logDir,
             `audit-${date}-${timestamp2}.jsonl`
           );
@@ -40903,7 +41193,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 = path57__namespace.join(this.options.logDir, file);
+              const filePath = path58__namespace.join(this.options.logDir, file);
               await fsp__namespace.unlink(filePath);
               logger.debug(`AuditLogger: Removed old log file ${file}`);
             }
@@ -40945,7 +41235,7 @@ var init_FileActionExecutor = __esm({
     FileActionExecutor = class {
       ALLOWED_PATHS = [
         process.cwd(),
-        path57__namespace.join(os16__namespace.homedir(), ".maria")
+        path58__namespace.join(os16__namespace.homedir(), ".maria")
       ];
       /**
        * Execute file action
@@ -41007,7 +41297,7 @@ var init_FileActionExecutor = __esm({
           await fsp__namespace.access(resolvedPath);
           return { action: "already_exists", path: resolvedPath };
         } catch {
-          await fsp__namespace.mkdir(path57__namespace.dirname(resolvedPath), { recursive: true });
+          await fsp__namespace.mkdir(path58__namespace.dirname(resolvedPath), { recursive: true });
           await fsp__namespace.writeFile(resolvedPath, "", "utf-8");
           logger.info(`Created file: ${resolvedPath}`);
           return { action: "created", path: resolvedPath };
@@ -41224,20 +41514,20 @@ var init_FileActionExecutor = __esm({
        */
       resolvePath(filePath) {
         if (filePath.startsWith("~/")) {
-          return path57__namespace.join(os16__namespace.homedir(), filePath.slice(2));
+          return path58__namespace.join(os16__namespace.homedir(), filePath.slice(2));
         }
-        if (path57__namespace.isAbsolute(filePath)) {
+        if (path58__namespace.isAbsolute(filePath)) {
           return filePath;
         }
-        return path57__namespace.resolve(process.cwd(), filePath);
+        return path58__namespace.resolve(process.cwd(), filePath);
       }
       /**
        * Validate path is within allowed directories
        */
       validatePath(filePath) {
-        const resolvedPath = path57__namespace.resolve(filePath);
+        const resolvedPath = path58__namespace.resolve(filePath);
         for (const allowedPath of this.ALLOWED_PATHS) {
-          const allowedResolved = path57__namespace.resolve(allowedPath);
+          const allowedResolved = path58__namespace.resolve(allowedPath);
           if (resolvedPath.startsWith(allowedResolved)) {
             return;
           }
@@ -41252,7 +41542,7 @@ var init_ConfigActionExecutor = __esm({
   "src/services/self-healing/executors/ConfigActionExecutor.ts"() {
     init_logger();
     ConfigActionExecutor = class {
-      DEFAULT_CONFIG_PATH = path57__namespace.join(
+      DEFAULT_CONFIG_PATH = path58__namespace.join(
         os16__namespace.homedir(),
         ".maria",
         "config.json"
@@ -41299,7 +41589,7 @@ var init_ConfigActionExecutor = __esm({
           };
         }
         try {
-          await fsp__namespace.mkdir(path57__namespace.dirname(resolvedPath), { recursive: true });
+          await fsp__namespace.mkdir(path58__namespace.dirname(resolvedPath), { recursive: true });
           let config2 = {};
           try {
             const content = await fsp__namespace.readFile(resolvedPath, "utf-8");
@@ -41334,7 +41624,7 @@ var init_ConfigActionExecutor = __esm({
           };
         }
         try {
-          await fsp__namespace.mkdir(path57__namespace.dirname(resolvedPath), { recursive: true });
+          await fsp__namespace.mkdir(path58__namespace.dirname(resolvedPath), { recursive: true });
           let config2 = {};
           try {
             const content = await fsp__namespace.readFile(resolvedPath, "utf-8");
@@ -41434,8 +41724,8 @@ var init_ConfigActionExecutor = __esm({
       /**
        * Set nested configuration value using dot notation
        */
-      setNestedValue(obj, path58, value) {
-        const keys = path58.split(".");
+      setNestedValue(obj, path59, value) {
+        const keys = path59.split(".");
         let current = obj;
         for (let i2 = 0; i2 < keys.length - 1; i2++) {
           const key = keys[i2];
@@ -41452,9 +41742,9 @@ var init_ConfigActionExecutor = __esm({
       resolveConfigPath(configPath) {
         if (configPath) {
           if (configPath.startsWith("~/")) {
-            return path57__namespace.join(os16__namespace.homedir(), configPath.slice(2));
+            return path58__namespace.join(os16__namespace.homedir(), configPath.slice(2));
           }
-          return path57__namespace.resolve(configPath);
+          return path58__namespace.resolve(configPath);
         }
         return this.DEFAULT_CONFIG_PATH;
       }
@@ -41467,10 +41757,10 @@ var init_CacheActionExecutor = __esm({
     init_logger();
     CacheActionExecutor = class {
       CACHE_PATHS = [
-        path57__namespace.join(os16__namespace.homedir(), ".maria", "cache"),
-        path57__namespace.join(process.cwd(), ".turbo"),
-        path57__namespace.join(process.cwd(), ".cache", "maria"),
-        path57__namespace.join(process.cwd(), "node_modules", ".cache")
+        path58__namespace.join(os16__namespace.homedir(), ".maria", "cache"),
+        path58__namespace.join(process.cwd(), ".turbo"),
+        path58__namespace.join(process.cwd(), ".cache", "maria"),
+        path58__namespace.join(process.cwd(), "node_modules", ".cache")
       ];
       /**
        * Execute cache action
@@ -41651,10 +41941,10 @@ var init_CacheActionExecutor = __esm({
        * Warmup specific target
        */
       async warmupTarget(target) {
-        const cacheDir = path57__namespace.join(os16__namespace.homedir(), ".maria", "cache");
+        const cacheDir = path58__namespace.join(os16__namespace.homedir(), ".maria", "cache");
         switch (target) {
           case "models:list":
-            const modelsDir = path57__namespace.join(cacheDir, "models");
+            const modelsDir = path58__namespace.join(cacheDir, "models");
             await fsp__namespace.mkdir(modelsDir, { recursive: true });
             const modelsData = {
               timestamp: Date.now(),
@@ -41665,12 +41955,12 @@ var init_CacheActionExecutor = __esm({
               ]
             };
             await fsp__namespace.writeFile(
-              path57__namespace.join(modelsDir, "available.json"),
+              path58__namespace.join(modelsDir, "available.json"),
               JSON.stringify(modelsData, null, 2)
             );
             return { itemsCreated: 1, size: JSON.stringify(modelsData).length };
           case "aliases":
-            const aliasesDir = path57__namespace.join(cacheDir, "aliases");
+            const aliasesDir = path58__namespace.join(cacheDir, "aliases");
             await fsp__namespace.mkdir(aliasesDir, { recursive: true });
             const aliasesData = {
               timestamp: Date.now(),
@@ -41681,12 +41971,12 @@ var init_CacheActionExecutor = __esm({
               }
             };
             await fsp__namespace.writeFile(
-              path57__namespace.join(aliasesDir, "model-aliases.json"),
+              path58__namespace.join(aliasesDir, "model-aliases.json"),
               JSON.stringify(aliasesData, null, 2)
             );
             return { itemsCreated: 1, size: JSON.stringify(aliasesData).length };
           case "templates":
-            const templatesDir = path57__namespace.join(cacheDir, "templates");
+            const templatesDir = path58__namespace.join(cacheDir, "templates");
             await fsp__namespace.mkdir(templatesDir, { recursive: true });
             const templatesData = {
               timestamp: Date.now(),
@@ -41697,7 +41987,7 @@ var init_CacheActionExecutor = __esm({
               }
             };
             await fsp__namespace.writeFile(
-              path57__namespace.join(templatesDir, "prompt-templates.json"),
+              path58__namespace.join(templatesDir, "prompt-templates.json"),
               JSON.stringify(templatesData, null, 2)
             );
             return { itemsCreated: 1, size: JSON.stringify(templatesData).length };
@@ -41743,7 +42033,7 @@ var init_CacheActionExecutor = __esm({
         try {
           const entries = await fsp__namespace.readdir(dirPath, { withFileTypes: true });
           for (const entry of entries) {
-            const entryPath = path57__namespace.join(dirPath, entry.name);
+            const entryPath = path58__namespace.join(dirPath, entry.name);
             if (entry.isDirectory()) {
               totalSize += await this.getDirectorySize(entryPath);
             } else {
@@ -41764,7 +42054,7 @@ var init_CacheActionExecutor = __esm({
           const entries = await fsp__namespace.readdir(dirPath, { withFileTypes: true });
           for (const entry of entries) {
             if (entry.isDirectory()) {
-              const entryPath = path57__namespace.join(dirPath, entry.name);
+              const entryPath = path58__namespace.join(dirPath, entry.name);
               count += await this.countFiles(entryPath);
             } else {
               count++;
@@ -41792,12 +42082,12 @@ var init_CacheActionExecutor = __esm({
        */
       resolvePath(cachePath) {
         if (cachePath.startsWith("~/")) {
-          return path57__namespace.join(os16__namespace.homedir(), cachePath.slice(2));
+          return path58__namespace.join(os16__namespace.homedir(), cachePath.slice(2));
         }
-        if (path57__namespace.isAbsolute(cachePath)) {
+        if (path58__namespace.isAbsolute(cachePath)) {
           return cachePath;
         }
-        return path57__namespace.resolve(process.cwd(), cachePath);
+        return path58__namespace.resolve(process.cwd(), cachePath);
       }
     };
   }
@@ -42070,7 +42360,7 @@ var init_SelfHealingService = __esm({
         const timestamp2 = /* @__PURE__ */ new Date();
         await this.auditLogger.logDiagnosis("started", { diagnostics: context2 });
         try {
-          const envPath = path57__namespace.join(context2.cwd, ".env.local");
+          const envPath = path58__namespace.join(context2.cwd, ".env.local");
           try {
             await fsp__namespace.access(envPath);
           } catch {
@@ -42085,7 +42375,7 @@ var init_SelfHealingService = __esm({
               suggestion: "Create .env.local with API keys template"
             });
           }
-          const nodeModulesPath = path57__namespace.join(context2.cwd, "node_modules");
+          const nodeModulesPath = path58__namespace.join(context2.cwd, "node_modules");
           try {
             await fsp__namespace.access(nodeModulesPath);
           } catch {
@@ -42100,7 +42390,7 @@ var init_SelfHealingService = __esm({
               suggestion: "Run package manager install command"
             });
           }
-          const cachePath = path57__namespace.join(process.env.HOME || "", ".maria", "cache");
+          const cachePath = path58__namespace.join(process.env.HOME || "", ".maria", "cache");
           try {
             const stats = await fsp__namespace.stat(cachePath);
             if (stats.size > 100 * 1024 * 1024) {
@@ -42482,7 +42772,7 @@ __export(cli_style_exports, {
 });
 async function tryReadModelFromManifest(root, manifestRel) {
   try {
-    const full = path57__namespace.resolve(root, manifestRel);
+    const full = path58__namespace.resolve(root, manifestRel);
     const text = await fsp__namespace.readFile(full, "utf8");
     const json2 = JSON.parse(text);
     const model = json2?.request?.model;
@@ -42499,7 +42789,7 @@ function formatArtifacts(files, limit = 10) {
   return lines;
 }
 function artifactsRootDir(manifestPath) {
-  return path57__namespace.posix.dirname(manifestPath);
+  return path58__namespace.posix.dirname(manifestPath);
 }
 async function formatImageOutput(root, opts) {
   const model = opts.model || await tryReadModelFromManifest(root, opts.manifestPath) || "auto";
@@ -42839,7 +43129,7 @@ function createConfigCheck() {
     runsIn: "read-only",
     estimateMs: 20,
     async run(ctx2) {
-      const pkgPath = path57.resolve(ctx2.cwd, "package.json");
+      const pkgPath = path58.resolve(ctx2.cwd, "package.json");
       try {
         const raw = await fsp.readFile(pkgPath, "utf-8");
         const pkg = JSON.parse(raw);
@@ -42908,7 +43198,7 @@ function createDependenciesCheck() {
     runsIn: "read-only",
     estimateMs: 25,
     async run(ctx2) {
-      const nm = path57.resolve(ctx2.cwd, "node_modules");
+      const nm = path58.resolve(ctx2.cwd, "node_modules");
       try {
         const s2 = await fsp.stat(nm);
         if (!s2.isDirectory()) {
@@ -43003,7 +43293,7 @@ function createGitRepoCheck() {
     runsIn: "read-only",
     estimateMs: 10,
     async run(ctx2) {
-      const dotgit = path57.resolve(ctx2.cwd, ".git");
+      const dotgit = path58.resolve(ctx2.cwd, ".git");
       try {
         await fsp.access(dotgit);
         return { name: "Git Repository", category: "config", status: "pass", message: "Git repo detected" };
@@ -43089,9 +43379,9 @@ function createProvidersSecretConfigCheck() {
         groq: !!process.env.GROQ_API_KEY
       };
       const candidates = [
-        path57.resolve(ctx2.cwd, ".maria/secrets.local.json"),
-        path57.resolve(ctx2.cwd, "secrets/local.json"),
-        path57.resolve(ctx2.cwd, ".secrets.local.json")
+        path58.resolve(ctx2.cwd, ".maria/secrets.local.json"),
+        path58.resolve(ctx2.cwd, "secrets/local.json"),
+        path58.resolve(ctx2.cwd, ".secrets.local.json")
       ];
       let fileCfg = null;
       for (const p of candidates) {
@@ -43163,8 +43453,8 @@ async function applyPlans(plans, opts) {
   try {
     for (const plan of plans) {
       if (opts.signal?.aborted) throw abortErr();
-      const target = path57__namespace.default.join(opts.root, plan.path);
-      const dir = path57__namespace.default.dirname(target);
+      const target = path58__namespace.default.join(opts.root, plan.path);
+      const dir = path58__namespace.default.dirname(target);
       await fs24.promises.mkdir(dir, { recursive: true });
       const exists = await fileExists(target);
       const perFileAllowed = plan.overwritePolicy === "allow";
@@ -43193,7 +43483,7 @@ async function applyPlans(plans, opts) {
     if (opts.rollback) {
       for (const rel of created) {
         try {
-          await fs24.promises.unlink(path57__namespace.default.join(opts.root, rel));
+          await fs24.promises.unlink(path58__namespace.default.join(opts.root, rel));
         } catch {
         }
       }
@@ -43314,7 +43604,7 @@ async function applyFixes(plans, opts) {
         continue;
       }
       if (plan.action === "file.create") {
-        const full = path57.resolve(opts.cwd, plan.path);
+        const full = path58.resolve(opts.cwd, plan.path);
         try {
           await fsp.access(full);
           results.push({ plan, status: "skipped", message: "File exists" });
@@ -43327,7 +43617,7 @@ async function applyFixes(plans, opts) {
         continue;
       }
       if (plan.action === "file.modify") {
-        const full = path57.resolve(opts.cwd, plan.path);
+        const full = path58.resolve(opts.cwd, plan.path);
         const st = await fsp.stat(full).catch(() => null);
         if (!st) {
           await ensureDir(full);
@@ -43344,7 +43634,7 @@ ${plan.diff ?? plan.content ?? ""}`;
         continue;
       }
       if (plan.action === "file.json-merge") {
-        const full = path57.resolve(opts.cwd, plan.path);
+        const full = path58.resolve(opts.cwd, plan.path);
         const raw = await readFileSafe(full);
         let json2 = {};
         if (raw) {
@@ -43379,14 +43669,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 = path57.resolve(cwd2, rel);
-  const normCwd = path57.normalize(cwd2) + path57.sep;
-  const normFull = path57.normalize(full);
+  const full = path58.resolve(cwd2, rel);
+  const normCwd = path58.normalize(cwd2) + path58.sep;
+  const normFull = path58.normalize(full);
   if (!normFull.startsWith(normCwd)) return { valid: false, reason: "outside cwd" };
   return { valid: true };
 }
 async function ensureDir(fullPath) {
-  const i2 = fullPath.lastIndexOf(path57.sep);
+  const i2 = fullPath.lastIndexOf(path58.sep);
   if (i2 <= 0) return;
   const dir = fullPath.slice(0, i2);
   try {
@@ -47508,12 +47798,12 @@ var init_esm4 = __esm({
       /**
        * Get the Path object referenced by the string path, resolved from this Path
        */
-      resolve(path58) {
-        if (!path58) {
+      resolve(path59) {
+        if (!path59) {
           return this;
         }
-        const rootPath = this.getRootString(path58);
-        const dir = path58.substring(rootPath.length);
+        const rootPath = this.getRootString(path59);
+        const dir = path59.substring(rootPath.length);
         const dirParts = dir.split(this.splitSep);
         const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
         return result;
@@ -48265,8 +48555,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      getRootString(path58) {
-        return path57.win32.parse(path58).root;
+      getRootString(path59) {
+        return path58.win32.parse(path59).root;
       }
       /**
        * @internal
@@ -48312,8 +48602,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      getRootString(path58) {
-        return path58.startsWith("/") ? "/" : "";
+      getRootString(path59) {
+        return path59.startsWith("/") ? "/" : "";
       }
       /**
        * @internal
@@ -48402,11 +48692,11 @@ var init_esm4 = __esm({
       /**
        * Get the depth of a provided path, string, or the cwd
        */
-      depth(path58 = this.cwd) {
-        if (typeof path58 === "string") {
-          path58 = this.cwd.resolve(path58);
+      depth(path59 = this.cwd) {
+        if (typeof path59 === "string") {
+          path59 = this.cwd.resolve(path59);
         }
-        return path58.depth();
+        return path59.depth();
       }
       /**
        * Return the cache of child entries.  Exposed so subclasses can create
@@ -48893,9 +49183,9 @@ var init_esm4 = __esm({
         process11();
         return results;
       }
-      chdir(path58 = this.cwd) {
+      chdir(path59 = this.cwd) {
         const oldCwd = this.cwd;
-        this.cwd = typeof path58 === "string" ? this.cwd.resolve(path58) : path58;
+        this.cwd = typeof path59 === "string" ? this.cwd.resolve(path59) : path59;
         this.cwd[setAsCwd](oldCwd);
       }
     };
@@ -48906,7 +49196,7 @@ var init_esm4 = __esm({
       sep = "\\";
       constructor(cwd2 = process.cwd(), opts = {}) {
         const { nocase = true } = opts;
-        super(cwd2, path57.win32, "\\", { ...opts, nocase });
+        super(cwd2, path58.win32, "\\", { ...opts, nocase });
         this.nocase = nocase;
         for (let p = this.cwd; p; p = p.parent) {
           p.nocase = this.nocase;
@@ -48916,7 +49206,7 @@ var init_esm4 = __esm({
        * @internal
        */
       parseRootPath(dir) {
-        return path57.win32.parse(dir).root.toUpperCase();
+        return path58.win32.parse(dir).root.toUpperCase();
       }
       /**
        * @internal
@@ -48938,7 +49228,7 @@ var init_esm4 = __esm({
       sep = "/";
       constructor(cwd2 = process.cwd(), opts = {}) {
         const { nocase = false } = opts;
-        super(cwd2, path57.posix, "/", { ...opts, nocase });
+        super(cwd2, path58.posix, "/", { ...opts, nocase });
         this.nocase = nocase;
       }
       /**
@@ -49270,8 +49560,8 @@ var init_processor = __esm({
       }
       // match, absolute, ifdir
       entries() {
-        return [...this.store.entries()].map(([path58, n]) => [
-          path58,
+        return [...this.store.entries()].map(([path59, n]) => [
+          path59,
           !!(n & 2),
           !!(n & 1)
         ]);
@@ -49484,9 +49774,9 @@ var init_walker = __esm({
       signal;
       maxDepth;
       includeChildMatches;
-      constructor(patterns, path58, opts) {
+      constructor(patterns, path59, opts) {
         this.patterns = patterns;
-        this.path = path58;
+        this.path = path59;
         this.opts = opts;
         this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
         this.includeChildMatches = opts.includeChildMatches !== false;
@@ -49505,11 +49795,11 @@ var init_walker = __esm({
           });
         }
       }
-      #ignored(path58) {
-        return this.seen.has(path58) || !!this.#ignore?.ignored?.(path58);
+      #ignored(path59) {
+        return this.seen.has(path59) || !!this.#ignore?.ignored?.(path59);
       }
-      #childrenIgnored(path58) {
-        return !!this.#ignore?.childrenIgnored?.(path58);
+      #childrenIgnored(path59) {
+        return !!this.#ignore?.childrenIgnored?.(path59);
       }
       // backpressure mechanism
       pause() {
@@ -49724,8 +50014,8 @@ var init_walker = __esm({
     };
     GlobWalker = class extends GlobUtil {
       matches = /* @__PURE__ */ new Set();
-      constructor(patterns, path58, opts) {
-        super(patterns, path58, opts);
+      constructor(patterns, path59, opts) {
+        super(patterns, path59, opts);
       }
       matchEmit(e2) {
         this.matches.add(e2);
@@ -49762,8 +50052,8 @@ var init_walker = __esm({
     };
     GlobStream = class extends GlobUtil {
       results;
-      constructor(patterns, path58, opts) {
-        super(patterns, path58, opts);
+      constructor(patterns, path59, opts) {
+        super(patterns, path59, opts);
         this.results = new Minipass({
           signal: this.signal,
           objectMode: true
@@ -50312,7 +50602,7 @@ ${usageLine}`;
       async autoRegister(directory) {
         logger.info(`Auto-registering commands from ${directory}`);
         try {
-          const pattern = path57__namespace.join(directory, "**/*.command.{ts,js}");
+          const pattern = path58__namespace.join(directory, "**/*.command.{ts,js}");
           const files = await glob(pattern);
           logger.info(`Found ${files.length} command files`);
           for (const file of files) {
@@ -51017,7 +51307,7 @@ ${fixPlan.note}` : ""));
       async runConfigurationChecks(context2) {
         const checks = [];
         const cwd2 = context2.environment?.cwd || process.cwd();
-        const packageJsonPath = path57__namespace.join(cwd2, "package.json");
+        const packageJsonPath = path58__namespace.join(cwd2, "package.json");
         try {
           await fsp__namespace.access(packageJsonPath);
           const content = await fsp__namespace.readFile(packageJsonPath, "utf-8");
@@ -51043,7 +51333,7 @@ ${fixPlan.note}` : ""));
             fixable: true
           });
         }
-        const envPath = path57__namespace.join(cwd2, ".env.local");
+        const envPath = path58__namespace.join(cwd2, ".env.local");
         try {
           await fsp__namespace.access(envPath);
           checks.push({
@@ -51061,7 +51351,7 @@ ${fixPlan.note}` : ""));
             fixable: true
           });
         }
-        const gitPath = path57__namespace.join(cwd2, ".git");
+        const gitPath = path58__namespace.join(cwd2, ".git");
         try {
           await fsp__namespace.access(gitPath);
           checks.push({
@@ -51085,7 +51375,7 @@ ${fixPlan.note}` : ""));
       async runDependencyChecks(context2) {
         const checks = [];
         const cwd2 = context2.environment?.cwd || process.cwd();
-        const nodeModulesPath = path57__namespace.join(cwd2, "node_modules");
+        const nodeModulesPath = path58__namespace.join(cwd2, "node_modules");
         try {
           await fsp__namespace.access(nodeModulesPath);
           const stats = await fsp__namespace.stat(nodeModulesPath);
@@ -51317,7 +51607,7 @@ ${fixPlan.note}` : ""));
             }
             break;
           case "CACHE_CORRUPT":
-            const cacheDir = path57__namespace.join(
+            const cacheDir = path58__namespace.join(
               context2.environment?.cwd || process.cwd(),
               ".maria",
               "cache"
@@ -51336,7 +51626,7 @@ ${fixPlan.note}` : ""));
        * Create environment template
        */
       async createEnvTemplate(context2) {
-        const envPath = path57__namespace.join(
+        const envPath = path58__namespace.join(
           context2.environment?.cwd || process.cwd(),
           ".env.local"
         );
@@ -51392,7 +51682,7 @@ LOG_LEVEL=info
       async getSystemInfo(context2) {
         let mariaVersion = "Unknown";
         try {
-          const packagePath = path57__namespace.join(
+          const packagePath = path58__namespace.join(
             context2.environment?.cwd || process.cwd(),
             "package.json"
           );
@@ -52992,7 +53282,7 @@ var init_TerminalSetupCommand = __esm({
         if (_shell.includes("fish")) return "fish";
         if (_shell.includes("powershell")) return "powershell";
         if (_shell.includes("cmd")) return "cmd";
-        return path57__namespace.basename(_shell) || "unknown";
+        return path58__namespace.basename(_shell) || "unknown";
       }
       generateTerminalRecommendations(type2, _features, _shell) {
         const _recommendations = [];
@@ -53309,9 +53599,9 @@ function clampInt(v, min, max, name2) {
   return Math.min(max, Math.max(min, Math.floor(n)));
 }
 function sanitizeOut(outDir, root) {
-  const full = path57__namespace.default.resolve(root, outDir);
-  const rel = path57__namespace.default.relative(root, full);
-  if (rel.startsWith("..") || path57__namespace.default.isAbsolute(rel)) throw new Error("out path escapes root");
+  const full = path58__namespace.default.resolve(root, outDir);
+  const rel = path58__namespace.default.relative(root, full);
+  if (rel.startsWith("..") || path58__namespace.default.isAbsolute(rel)) throw new Error("out path escapes root");
   return rel.replace(/\\/g, "/");
 }
 var init_Normalizer = __esm({
@@ -53323,15 +53613,15 @@ function ensureDirSync(p) {
   fs24__namespace.mkdirSync(p, { recursive: true });
 }
 function safeJoin(root, ...segs) {
-  const full = path57__namespace.resolve(root, ...segs);
-  const rel = path57__namespace.relative(root, full);
-  if (rel.startsWith("..") || path57__namespace.isAbsolute(rel)) {
+  const full = path58__namespace.resolve(root, ...segs);
+  const rel = path58__namespace.relative(root, full);
+  if (rel.startsWith("..") || path58__namespace.isAbsolute(rel)) {
     throw new Error(`path escapes root: ${segs.join("/")}`);
   }
   return { full, rel };
 }
 function stageDir(root, trace) {
-  return path57__namespace.join(root, `.stage/${trace}`);
+  return path58__namespace.join(root, `.stage/${trace}`);
 }
 async function existsSameHash(destFull) {
   try {
@@ -53396,10 +53686,10 @@ async function saveArtifacts(ctx2, items, manifest) {
       const fname = `${contentHash}${ext2}`;
       const dest = safeJoin(root, `${outDirSeg}/${fname}`);
       validateWinPathEdge(dest.full);
-      if (await hasCaseInsensitiveCollision(path57__namespace.dirname(dest.full), path57__namespace.basename(dest.full))) {
+      if (await hasCaseInsensitiveCollision(path58__namespace.dirname(dest.full), path58__namespace.basename(dest.full))) {
         throw new Error("case-insensitive filename collision");
       }
-      const stg = path57__namespace.join(stage, `${fname}.part`);
+      const stg = path58__namespace.join(stage, `${fname}.part`);
       if (await existsSameHash(dest.full)) {
         saved.push(dest.rel);
         continue;
@@ -53412,10 +53702,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:${path57__namespace.basename(file).split(".")[0]}` }))
+      artifacts: manifest.artifacts && manifest.artifacts.length > 0 ? manifest.artifacts : saved.map((file) => ({ file, hash: `sha256:${path58__namespace.basename(file).split(".")[0]}` }))
     };
     const manifestPathRel = `${outDirSeg}/manifest.json`;
-    const manifestStage = path57__namespace.join(stage, "manifest.json.part");
+    const manifestStage = path58__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);
@@ -53772,10 +54062,10 @@ var init_session = __esm({
         this.root = root;
       }
       file() {
-        return path57__namespace.default.join(this.root, ".maria", "memory", "session.json");
+        return path58__namespace.default.join(this.root, ".maria", "memory", "session.json");
       }
       lockFile() {
-        return path57__namespace.default.join(this.root, ".maria", "memory", ".session.lock");
+        return path58__namespace.default.join(this.root, ".maria", "memory", ".session.lock");
       }
       load() {
         try {
@@ -53790,7 +54080,7 @@ var init_session = __esm({
        */
       save(data) {
         const target = this.file();
-        const dir = path57__namespace.default.dirname(target);
+        const dir = path58__namespace.default.dirname(target);
         fs24__namespace.default.mkdirSync(dir, { recursive: true });
         try {
           this.rotateIfStale(target, 7 * 24 * 60 * 60 * 1e3);
@@ -53823,7 +54113,7 @@ var init_session = __esm({
         const body = `${pid}
 ${(/* @__PURE__ */ new Date()).toISOString()}`;
         const start = Date.now();
-        fs24__namespace.default.mkdirSync(path57__namespace.default.dirname(lockPath), { recursive: true });
+        fs24__namespace.default.mkdirSync(path58__namespace.default.dirname(lockPath), { recursive: true });
         const maxWaitTime = Date.now() + waitMs;
         while (Date.now() < maxWaitTime) {
           try {
@@ -53862,10 +54152,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 = path57__namespace.default.join(path57__namespace.default.dirname(filePath), "archive", yyyymmdd);
+            const archiveDir = path58__namespace.default.join(path58__namespace.default.dirname(filePath), "archive", yyyymmdd);
             fs24__namespace.default.mkdirSync(archiveDir, { recursive: true });
             const ts = d.toISOString().replace(/[:]/g, "-");
-            const dest = path57__namespace.default.join(archiveDir, `session-${ts}.json`);
+            const dest = path58__namespace.default.join(archiveDir, `session-${ts}.json`);
             fs24__namespace.default.renameSync(filePath, dest);
           }
         } catch {
@@ -53987,7 +54277,7 @@ var init_firestore = __esm({
         return s2.slice(0, limit);
       }
       readLocal() {
-        const sessionPath = path57__namespace.default.join(this.cwd, ".maria", "memory", "session.json");
+        const sessionPath = path58__namespace.default.join(this.cwd, ".maria", "memory", "session.json");
         const candidates = [];
         try {
           const raw = JSON.parse(fs24__namespace.default.readFileSync(sessionPath, "utf8"));
@@ -54266,13 +54556,13 @@ async function hasFfmpeg() {
   });
 }
 async function muxFramesToMp4(framesDir, fps) {
-  const outFile = path57__namespace.join(framesDir, `out-${Date.now()}.mp4`);
+  const outFile = path58__namespace.join(framesDir, `out-${Date.now()}.mp4`);
   await execFfmpeg([
     "-y",
     "-framerate",
     String(fps),
     "-i",
-    path57__namespace.join(framesDir, "%06d.png"),
+    path58__namespace.join(framesDir, "%06d.png"),
     "-pix_fmt",
     "yuv420p",
     "-c:v",
@@ -54338,11 +54628,11 @@ async function runVideoPipeline(params2, opts) {
   let saved;
   let warnFallback = false;
   if (frames.length > 0 && await hasFfmpeg()) {
-    const tmpDir = path57__namespace.join(opts.root, ".stage", manifest.trace || "FFMPEG");
+    const tmpDir = path58__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(path57__namespace.join(tmpDir, fname), frames[i2]);
+      await fsp__namespace.writeFile(path58__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);
@@ -55045,14 +55335,461 @@ var init_WhoAmICommand = __esm({
     WhoAmICommand_default = WhoAmICommand;
   }
 });
+function resolveArtifactRoot() {
+  return process.env.MARIA_IDENTITY_ROOT ? path58__namespace.default.resolve(process.env.MARIA_IDENTITY_ROOT) : process.cwd();
+}
+function normalizeLocale(locale) {
+  if (!locale) return DEFAULT_LOCALE;
+  const normalized = locale.toLowerCase();
+  if (normalized.startsWith("ja")) return "ja";
+  if (normalized.startsWith("zh")) return "zh";
+  if (normalized.startsWith("ko")) return "ko";
+  if (normalized.startsWith("vi")) return "vi";
+  if (normalized.startsWith("en")) return "en";
+  return DEFAULT_LOCALE;
+}
+function formatList2(items, locale) {
+  if (items.length === 0) {
+    return "";
+  }
+  const limited = items.slice(0, DEFAULT_COMMAND_LIMIT);
+  const ellipsis = items.length > DEFAULT_COMMAND_LIMIT;
+  switch (locale) {
+    case "ja":
+      return `${limited.join("\u3001")}\u306A\u3069`;
+    case "zh":
+      return `${limited.join("\u3001")}\u7B49`;
+    case "ko":
+      return `${limited.join(", ")} \uB4F1`;
+    case "vi":
+      return ellipsis ? `${limited.join(", ")} ...` : limited.join(", ");
+    default:
+      if (limited.length === 1) {
+        return limited[0];
+      }
+      if (limited.length === 2) {
+        return `${limited[0]} and ${limited[1]}` + (ellipsis ? " etc." : "");
+      }
+      const rest = limited.slice(0, -1).join(", ");
+      const last = limited[limited.length - 1];
+      return `${rest}, and ${last}` + (ellipsis ? " etc." : "");
+  }
+}
+function buildSentence(locale, commands) {
+  const list = formatList2(commands, locale);
+  switch (locale) {
+    case "ja":
+      return `READY\u30B3\u30DE\u30F3\u30C9\uFF08\u4F8B\uFF1A${list}\uFF09\u3092\u4E2D\u5FC3\u306B\u30B5\u30DD\u30FC\u30C8\u3057\u307E\u3059\u3002`;
+    case "zh":
+      return `\u6211\u4E3B\u8981\u652F\u6301 READY \u547D\u4EE4\uFF0C\u4F8B\u5982\uFF1A${list}\u3002`;
+    case "ko":
+      return `READY\uB85C \uD45C\uAE30\uB41C \uBA85\uB839(${list})\uC744 \uC911\uC2EC\uC73C\uB85C \uC9C0\uC6D0\uD569\uB2C8\uB2E4.`;
+    case "vi":
+      return `T\xF4i h\u1ED7 tr\u1EE3 c\xE1c l\u1EC7nh READY nh\u01B0: ${list}.`;
+    default:
+      return `I focus on READY commands like ${list}.`;
+  }
+}
+var DEFAULT_TEMPLATE_VERSION, ARTIFACT_CACHE_TTL, DEFAULT_COMMAND_LIMIT, DEFAULT_TEMPLATES, HELP_LINES, NEXT_STEPS, DEGRADED_HEADER, DEGRADED_BODY, DEFAULT_NEXT_STEPS, DEFAULT_LOCALE, IdentityRenderer, identityRenderer;
+var init_identity_renderer = __esm({
+  "src/services/identity/identity-renderer.ts"() {
+    init_logger();
+    init_TelemetryCollector();
+    DEFAULT_TEMPLATE_VERSION = "v1.0.0";
+    ARTIFACT_CACHE_TTL = 6e4;
+    DEFAULT_COMMAND_LIMIT = 16;
+    DEFAULT_TEMPLATES = {
+      en: "I'm Maria Code \u2014 a large language model fully trained by Bonginkan. I support this workspace as a developer partner. I focus on the READY commands listed in `/help`, including <skills>. If you need something outside the READY set, I'll confirm what's supported first.",
+      ja: "\u79C1\u306FMaria Code\uFF08Bonginkan\u306B\u3088\u3063\u3066\u5B8C\u5168\u306B\u8A13\u7DF4\u3055\u308C\u305F\u5927\u898F\u6A21\u8A00\u8A9E\u30E2\u30C7\u30EB\uFF09\u3067\u3059\u3002\u958B\u767A\u30D1\u30FC\u30C8\u30CA\u30FC\u3068\u3057\u3066\u3053\u306E\u30EF\u30FC\u30AF\u30B9\u30DA\u30FC\u30B9\u3092\u652F\u63F4\u3057\u307E\u3059\u3002`/help`\u3067\u78BA\u8A8D\u3067\u304D\u308BREADY\u30B3\u30DE\u30F3\u30C9\uFF08\u4F8B\uFF1A<skills>\uFF09\u3092\u4E2D\u5FC3\u306B\u5BFE\u5FDC\u3057\u307E\u3059\u3002\u7BC4\u56F2\u5916\u306E\u4F9D\u983C\u306F\u3001\u307E\u305A\u5BFE\u5FDC\u53EF\u5426\u3092\u4E00\u7DD2\u306B\u78BA\u8A8D\u3057\u307E\u3059\u3002",
+      zh: "\u6211\u662F Maria Code\uFF08\u7531 Bonginkan \u5B8C\u6574\u8BAD\u7EC3\u7684\u5927\u578B\u8BED\u8A00\u6A21\u578B\uFF09\u3002\u6211\u5728\u6B64\u5DE5\u4F5C\u533A\u4EE5\u5F00\u53D1\u4F19\u4F34\u7684\u8EAB\u4EFD\u63D0\u4F9B\u534F\u52A9\u3002\u6211\u4E3B\u8981\u652F\u6301 `/help` \u4E2D\u5217\u51FA\u7684 READY \u547D\u4EE4\uFF08\u5982\uFF1A<skills>\uFF09\u3002\u5982\u679C\u9700\u6C42\u8D85\u51FA\u8303\u56F4\uFF0C\u6211\u4EEC\u4F1A\u5148\u786E\u8BA4\u662F\u5426\u53D7\u652F\u6301\u3002",
+      ko: "\uC800\uB294 Maria Code(\uBD09\uAE34\uCE78\uC774 \uC644\uC804\uD788 \uD559\uC2B5\uD55C \uB300\uADDC\uBAA8 \uC5B8\uC5B4 \uBAA8\uB378)\uC785\uB2C8\uB2E4. \uC774 \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4\uC5D0\uC11C \uAC1C\uBC1C \uD30C\uD2B8\uB108\uB85C \uC9C0\uC6D0\uD569\uB2C8\uB2E4. `/help`\uC5D0 READY\uB85C \uD45C\uC2DC\uB41C \uBA85\uB839(\uC608: <skills>)\uC744 \uC911\uC2EC\uC73C\uB85C \uB3C4\uC640\uB4DC\uB9BD\uB2C8\uB2E4. \uBC94\uC704\uB97C \uBC97\uC5B4\uB098\uB294 \uC694\uCCAD\uC740 \uAC00\uB2A5 \uC5EC\uBD80\uBD80\uD130 \uD568\uAED8 \uD655\uC778\uD569\uB2C8\uB2E4.",
+      vi: "T\xF4i l\xE0 Maria Code \u2014 m\xF4 h\xECnh ng\xF4n ng\u1EEF l\u1EDBn \u0111\u01B0\u1EE3c Bonginkan hu\u1EA5n luy\u1EC7n \u0111\u1EA7y \u0111\u1EE7. T\xF4i h\u1ED7 tr\u1EE3 workspace n\xE0y nh\u01B0 m\u1ED9t c\u1ED9ng s\u1EF1 ph\xE1t tri\u1EC3n. T\xF4i t\u1EADp trung v\xE0o c\xE1c l\u1EC7nh READY trong `/help`, ch\u1EB3ng h\u1EA1n nh\u01B0 <skills>. N\u1EBFu y\xEAu c\u1EA7u n\u1EB1m ngo\xE0i ph\u1EA1m vi, ch\xFAng ta s\u1EBD ki\u1EC3m tra tr\u01B0\u1EDBc kh\u1EA3 n\u0103ng h\u1ED7 tr\u1EE3 nh\xE9."
+    };
+    HELP_LINES = {
+      en: "See available skills with /help",
+      ja: "\u5229\u7528\u53EF\u80FD\u306A\u30B3\u30DE\u30F3\u30C9\u306F /help \u3067\u78BA\u8A8D\u3067\u304D\u307E\u3059",
+      zh: "\u53EF\u901A\u8FC7 /help \u67E5\u770B\u6240\u6709\u53EF\u7528\u547D\u4EE4",
+      ko: "/help \uB85C \uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uBA85\uB839\uC744 \uD655\uC778\uD558\uC138\uC694",
+      vi: "Xem c\xE1c l\u1EC7nh h\u1ED7 tr\u1EE3 t\u1EA1i /help"
+    };
+    NEXT_STEPS = {
+      en: [
+        "See available skills with /help",
+        "Describe your goal in one line; I'll route you to the right workflow"
+      ],
+      ja: [
+        "/help \u3067\u5229\u7528\u53EF\u80FD\u306A\u30B3\u30DE\u30F3\u30C9\u3092\u78BA\u8A8D",
+        "\u3084\u308A\u305F\u3044\u3053\u3068\u3092\u4E00\u884C\u3067\u6559\u3048\u3066\u304F\u3060\u3055\u3044\u3002\u6700\u9069\u306A\u30EF\u30FC\u30AF\u30D5\u30ED\u30FC\u306B\u6848\u5185\u3057\u307E\u3059"
+      ],
+      zh: [
+        "\u4F7F\u7528 /help \u67E5\u770B\u53EF\u7528\u547D\u4EE4",
+        "\u7528\u4E00\u53E5\u8BDD\u63CF\u8FF0\u76EE\u6807\uFF0C\u6211\u4F1A\u5F15\u5BFC\u4F60\u8FDB\u5165\u5408\u9002\u7684\u6D41\u7A0B"
+      ],
+      ko: [
+        "/help \uB85C \uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uBA85\uB839 \uD655\uC778",
+        "\uC6D0\uD558\uB294 \uBAA9\uD45C\uB97C \uD55C \uC904\uB85C \uC54C\uB824\uC8FC\uC138\uC694. \uB9DE\uB294 \uC6CC\uD06C\uD50C\uB85C\uB85C \uC548\uB0B4\uD569\uB2C8\uB2E4"
+      ],
+      vi: [
+        "Xem c\xE1c l\u1EC7nh h\u1ED7 tr\u1EE3 b\u1EB1ng /help",
+        "M\xF4 t\u1EA3 m\u1EE5c ti\xEAu trong m\u1ED9t c\xE2u, t\xF4i s\u1EBD h\u01B0\u1EDBng b\u1EA1n t\u1EDBi quy tr\xECnh ph\xF9 h\u1EE3p"
+      ]
+    };
+    DEGRADED_HEADER = {
+      en: "WARN: Identity service degraded",
+      ja: "WARN: Identity\u30B5\u30FC\u30D3\u30B9\u306E\u5229\u7528\u306B\u5236\u9650\u304C\u3042\u308A\u307E\u3059",
+      zh: "WARN: \u8EAB\u4EFD\u670D\u52A1\u5904\u4E8E\u964D\u7EA7\u6A21\u5F0F",
+      ko: "WARN: ID \uC11C\uBE44\uC2A4\uAC00 \uCD95\uC18C \uBAA8\uB4DC\uC785\uB2C8\uB2E4",
+      vi: "WARN: D\u1ECBch v\u1EE5 nh\u1EADn di\u1EC7n \u0111ang b\u1ECB suy gi\u1EA3m"
+    };
+    DEGRADED_BODY = {
+      en: "I'm Maria Code \u2014 a large language model fully trained by Bonginkan.",
+      ja: "\u79C1\u306FMaria Code\uFF08Bonginkan\u306B\u3088\u3063\u3066\u5B8C\u5168\u306B\u8A13\u7DF4\u3055\u308C\u305F\u5927\u898F\u6A21\u8A00\u8A9E\u30E2\u30C7\u30EB\uFF09\u3067\u3059\u3002",
+      zh: "\u6211\u662F Maria Code\uFF08\u7531 Bonginkan \u5B8C\u6574\u8BAD\u7EC3\u7684\u5927\u578B\u8BED\u8A00\u6A21\u578B\uFF09\u3002",
+      ko: "\uC800\uB294 Maria Code(\uBD09\uAE34\uCE78\uC774 \uC644\uC804\uD788 \uD559\uC2B5\uD55C \uB300\uADDC\uBAA8 \uC5B8\uC5B4 \uBAA8\uB378)\uC785\uB2C8\uB2E4.",
+      vi: "T\xF4i l\xE0 Maria Code \u2014 m\xF4 h\xECnh ng\xF4n ng\u1EEF l\u1EDBn \u0111\u01B0\u1EE3c Bonginkan hu\u1EA5n luy\u1EC7n \u0111\u1EA7y \u0111\u1EE7."
+    };
+    DEFAULT_NEXT_STEPS = [
+      "See available skills with /help",
+      "Describe your goal in one line; I'll route you to the right workflow"
+    ];
+    DEFAULT_LOCALE = "en";
+    IdentityRenderer = class _IdentityRenderer {
+      static instance;
+      skillsCache = null;
+      templateCache = null;
+      lastHashes = /* @__PURE__ */ new Map();
+      static getInstance() {
+        if (!_IdentityRenderer.instance) {
+          _IdentityRenderer.instance = new _IdentityRenderer();
+        }
+        return _IdentityRenderer.instance;
+      }
+      async render(options = {}) {
+        const startedAt = Date.now();
+        const locale = normalizeLocale(options.locale);
+        const format = options.format ?? "text";
+        const isTTY = options.isTTY ?? Boolean(process.stdout?.isTTY);
+        const timer = telemetry.startTimer("identity.answer_rendered.start", {
+          _comp: "system",
+          locale,
+          format,
+          source: options.source ?? "cli"
+        });
+        const skills = await this.resolveSkills(locale);
+        const template = await this.resolveTemplate(locale);
+        const degraded = skills.degraded || template.degraded;
+        const degradationReason = skills.reason ?? template.reason;
+        const previousHash = this.lastHashes.get(locale);
+        this.lastHashes.set(locale, skills.hash);
+        const templateVersion = template.version || DEFAULT_TEMPLATE_VERSION;
+        const identityVersion = templateVersion;
+        const persona = template.template.replace("<skills>", skills.sentence);
+        const message = this.composeMessage({
+          locale,
+          persona,
+          skillsSentence: skills.sentence,
+          isTTY,
+          degraded,
+          includeWarningHeader: options.includeWarningHeader ?? degraded,
+          reason: degradationReason
+        });
+        const jsonPayload = format === "json" ? {
+          locale,
+          identityVersion,
+          skillsSentence: skills.sentence,
+          skillsHash: skills.hash,
+          degraded,
+          previousSkillsHash: previousHash,
+          templateVersion,
+          degradationReason
+        } : void 0;
+        const latency = Date.now() - startedAt;
+        telemetry.emit({
+          event: "identity.answer_rendered",
+          tags: {
+            _comp: "system",
+            locale,
+            format,
+            source: options.source ?? "cli"
+          },
+          meta: {
+            templateVersion,
+            skillsHash: skills.hash,
+            previousSkillsHash: previousHash,
+            degraded,
+            latencyMs: latency,
+            reason: degradationReason
+          }
+        });
+        timer();
+        return {
+          message: format === "json" && jsonPayload ? JSON.stringify(jsonPayload, null, 2) : message,
+          json: jsonPayload,
+          metadata: {
+            locale,
+            templateVersion,
+            skillsHash: skills.hash,
+            previousSkillsHash: previousHash,
+            degraded,
+            degradationReason,
+            latencyMs: latency
+          }
+        };
+      }
+      /**
+       * Testing helper to reset caches.
+       */
+      __resetForTests() {
+        this.skillsCache = null;
+        this.templateCache = null;
+        this.lastHashes.clear();
+      }
+      async resolveSkills(locale) {
+        const artifact = await this.loadSkillsArtifact();
+        const root = resolveArtifactRoot();
+        if (artifact && artifact.locales && artifact.locales[locale]) {
+          const entry = artifact.locales[locale];
+          if (entry?.sentence && entry?.hash) {
+            return {
+              sentence: entry.sentence,
+              hash: entry.hash,
+              degraded: false
+            };
+          }
+        }
+        const readyCommands = await this.loadReadyCommands(root);
+        if (readyCommands.length === 0) {
+          const hash2 = this.hashData(`${locale}:degraded`);
+          return {
+            sentence: this.buildDegradedSentence(locale),
+            hash: hash2,
+            degraded: true,
+            reason: "ready-manifest-missing"
+          };
+        }
+        const slashCommands = readyCommands.map((cmd) => `/${cmd.name}`);
+        const sentence = buildSentence(locale, slashCommands);
+        const hash = this.hashData(JSON.stringify({ locale, commands: slashCommands }));
+        return {
+          sentence,
+          hash,
+          degraded: false
+        };
+      }
+      async resolveTemplate(locale) {
+        const artifact = await this.loadTemplateArtifact();
+        if (artifact && artifact.templates && artifact.templates[locale]) {
+          return {
+            template: artifact.templates[locale],
+            version: artifact.templateVersion ?? DEFAULT_TEMPLATE_VERSION,
+            degraded: false
+          };
+        }
+        if (artifact && artifact.templates && artifact.templates[DEFAULT_LOCALE]) {
+          return {
+            template: artifact.templates[DEFAULT_LOCALE],
+            version: artifact.templateVersion ?? DEFAULT_TEMPLATE_VERSION,
+            degraded: false
+          };
+        }
+        const template = DEFAULT_TEMPLATES[locale] ?? DEFAULT_TEMPLATES[DEFAULT_LOCALE];
+        return {
+          template,
+          version: DEFAULT_TEMPLATE_VERSION,
+          degraded: !DEFAULT_TEMPLATES[locale],
+          reason: DEFAULT_TEMPLATES[locale] ? void 0 : "template-missing"
+        };
+      }
+      composeMessage(args2) {
+        const locale = args2.locale;
+        const lines = [];
+        if (args2.includeWarningHeader || args2.degraded) {
+          const header = DEGRADED_HEADER[locale] ?? DEGRADED_HEADER[DEFAULT_LOCALE];
+          lines.push(header);
+        }
+        if (args2.degraded) {
+          const degradedBody = DEGRADED_BODY[locale] ?? DEGRADED_BODY[DEFAULT_LOCALE];
+          const steps = NEXT_STEPS[locale] ?? DEFAULT_NEXT_STEPS;
+          const helpLine2 = HELP_LINES[locale] ?? HELP_LINES[DEFAULT_LOCALE] ?? steps[0];
+          lines.push(degradedBody);
+          lines.push(helpLine2);
+          lines.push(steps[1] ?? DEFAULT_NEXT_STEPS[1]);
+          return lines.join("\n");
+        }
+        const helpLine = HELP_LINES[locale] ?? HELP_LINES[DEFAULT_LOCALE];
+        const personaLines = this.normalizePersonaOutput(args2.persona);
+        lines.push(...personaLines);
+        if (args2.isTTY) {
+          lines.push("Next steps:");
+          const steps = NEXT_STEPS[locale] ?? DEFAULT_NEXT_STEPS;
+          for (const step of steps) {
+            lines.push(`- ${step}`);
+          }
+        } else {
+          lines.push(helpLine);
+        }
+        return lines.join("\n");
+      }
+      normalizePersonaOutput(persona) {
+        const sanitized = persona.replace(/\s+/g, " ").trim();
+        const segments = sanitized.split(/(?<=[.!?。！？])/u).map((seg) => seg.trim());
+        return segments.filter(Boolean);
+      }
+      async loadSkillsArtifact() {
+        if (this.skillsCache && Date.now() - this.skillsCache.loadedAt < ARTIFACT_CACHE_TTL) {
+          return this.skillsCache.data;
+        }
+        const root = resolveArtifactRoot();
+        const artifactPath = path58__namespace.default.join(root, "reports", "identity-skills.json");
+        const data = await this.readJsonFile(artifactPath);
+        this.skillsCache = {
+          data,
+          loadedAt: Date.now()
+        };
+        return data;
+      }
+      async loadTemplateArtifact() {
+        if (this.templateCache && Date.now() - this.templateCache.loadedAt < ARTIFACT_CACHE_TTL) {
+          return this.templateCache.data;
+        }
+        const root = resolveArtifactRoot();
+        const templatePath = path58__namespace.default.join(root, "MARIA_CHARACTER_RESPONSES.json");
+        const data = await this.readJsonFile(templatePath);
+        this.templateCache = {
+          data,
+          loadedAt: Date.now()
+        };
+        return data;
+      }
+      async loadReadyCommands(root) {
+        const manifestPath = path58__namespace.default.join(root, "commands.ready.json");
+        const manifest = await this.readJsonFile(manifestPath);
+        if (!manifest?.commands) {
+          return [];
+        }
+        return manifest.commands.filter((entry) => entry.status === "READY").map((entry) => ({
+          name: String(entry.name ?? ""),
+          category: entry.category ? String(entry.category) : void 0
+        })).filter((entry) => entry.name?.length > 0);
+      }
+      buildDegradedSentence(locale) {
+        switch (locale) {
+          case "ja":
+            return "`/help`\u3067\u516C\u958B\u3055\u308C\u3066\u3044\u308BREADY\u30B3\u30DE\u30F3\u30C9\u306B\u57FA\u3065\u3044\u3066\u5BFE\u5FDC\u3057\u307E\u3059\u3002";
+          case "zh":
+            return "\u6211\u4F1A\u4F9D\u636E /help \u4E2D\u516C\u5F00\u7684 READY \u547D\u4EE4\u63D0\u4F9B\u652F\u6301\u3002";
+          case "ko":
+            return "\uACF5\uAC1C\uB41C /help READY \uBA85\uB839\uC5D0 \uAE30\uBC18\uD558\uC5EC \uC9C0\uC6D0\uD569\uB2C8\uB2E4.";
+          case "vi":
+            return "T\xF4i s\u1EBD h\u1ED7 tr\u1EE3 d\u1EF1a tr\xEAn c\xE1c l\u1EC7nh READY \u0111\u01B0\u1EE3c li\u1EC7t k\xEA trong /help.";
+          default:
+            return "I will rely on the READY commands published in /help.";
+        }
+      }
+      hashData(data) {
+        return crypto6.createHash("sha256").update(data).digest("hex");
+      }
+      async readJsonFile(filePath) {
+        try {
+          const raw = await fsp.readFile(filePath, "utf8");
+          return JSON.parse(raw);
+        } catch (error2) {
+          if (error2.code !== "ENOENT") {
+            logger.warn(`Failed to read JSON artifact at ${filePath}:`, error2);
+          }
+          return null;
+        }
+      }
+    };
+    identityRenderer = IdentityRenderer.getInstance();
+  }
+});
+
+// src/slash-commands/categories/core/identity.command.ts
+var identity_command_exports = {};
+__export(identity_command_exports, {
+  IdentityCommand: () => IdentityCommand,
+  meta: () => meta14
+});
+var IdentityCommand, meta14;
+var init_identity_command = __esm({
+  "src/slash-commands/categories/core/identity.command.ts"() {
+    init_base_command();
+    init_identity_renderer();
+    init_logger();
+    IdentityCommand = class extends BaseCommand {
+      name = "identity";
+      description = "Show Maria Code identity and supported READY skills";
+      category = "core";
+      aliases = ["whois", "persona"];
+      usage = "/identity [--json] [--locale <tag>]";
+      examples = [
+        {
+          input: "/identity",
+          description: "Display identity message in current locale"
+        },
+        {
+          input: "/identity --json",
+          description: "Return structured JSON payload"
+        }
+      ];
+      async execute(args2, _context) {
+        const positional = args2.parsed["_positional"] ?? [];
+        if (positional.length > 0) {
+          return this.error(
+            "Usage: /identity [--json] [--locale <tag>]",
+            "INVALID_ARGUMENTS"
+          );
+        }
+        const wantsJson = Boolean(args2.flags["json"] || args2.options["json"]);
+        const explicitLocale = typeof args2.options["locale"] === "string" ? args2.options["locale"] : void 0;
+        try {
+          const result = await identityRenderer.render({
+            locale: explicitLocale,
+            format: wantsJson ? "json" : "text",
+            isTTY: Boolean(process.stdout?.isTTY),
+            source: "cli"
+          });
+          const payload = wantsJson ? result.json : {
+            locale: result.metadata.locale,
+            degraded: result.metadata.degraded,
+            templateVersion: result.metadata.templateVersion,
+            skillsHash: result.metadata.skillsHash,
+            previousSkillsHash: result.metadata.previousSkillsHash
+          };
+          return this.success(result.message, payload);
+        } catch (error2) {
+          logger.error("/identity execution failed", error2);
+          return this.error(
+            "Unable to render identity information. Run /help for support.",
+            "IDENTITY_RENDER_ERROR",
+            { error: error2?.message }
+          );
+        }
+      }
+    };
+    meta14 = {
+      name: "identity",
+      category: "core",
+      description: "Show Maria Code identity and supported READY skills",
+      aliases: ["whois", "persona"],
+      usage: "/identity [--json] [--locale <tag>]",
+      examples: [
+        "/identity",
+        "/identity --json"
+      ],
+      deps: ["commands.ready.json"]
+    };
+  }
+});
 
 // src/slash-commands/categories/core/about.command.ts
 var about_command_exports = {};
 __export(about_command_exports, {
   AboutCommand: () => AboutCommand,
-  meta: () => meta14
+  meta: () => meta15
 });
-var AboutCommand, meta14;
+var AboutCommand, meta15;
 var init_about_command = __esm({
   "src/slash-commands/categories/core/about.command.ts"() {
     init_base_command();
@@ -55107,7 +55844,7 @@ var init_about_command = __esm({
         };
       }
     };
-    meta14 = {
+    meta15 = {
       name: "about",
       category: "core",
       description: "Display information about MARIA and the team",
@@ -56613,11 +57350,11 @@ var init_ConfigPortAdapter = __esm({
         backupCount: 5
       };
       constructor() {
-        this.globalConfigPath = path57__namespace.default.join(os16__namespace.default.homedir(), ".maria", "config.json");
-        this.userConfigPath = path57__namespace.default.join(os16__namespace.default.homedir(), ".maria", "user-config.json");
-        this.projectConfigPath = path57__namespace.default.join(process.cwd(), ".maria-config.json");
-        this.historyPath = path57__namespace.default.join(os16__namespace.default.homedir(), ".maria", "config-history.json");
-        this.templatesPath = path57__namespace.default.join(os16__namespace.default.homedir(), ".maria", "templates");
+        this.globalConfigPath = path58__namespace.default.join(os16__namespace.default.homedir(), ".maria", "config.json");
+        this.userConfigPath = path58__namespace.default.join(os16__namespace.default.homedir(), ".maria", "user-config.json");
+        this.projectConfigPath = path58__namespace.default.join(process.cwd(), ".maria-config.json");
+        this.historyPath = path58__namespace.default.join(os16__namespace.default.homedir(), ".maria", "config-history.json");
+        this.templatesPath = path58__namespace.default.join(os16__namespace.default.homedir(), ".maria", "templates");
       }
       async get(key) {
         const layered = await this.getLayered(key);
@@ -56874,7 +57611,7 @@ var init_ConfigPortAdapter = __esm({
           for (const file of files) {
             if (file.endsWith(".json")) {
               try {
-                const templatePath = path57__namespace.default.join(this.templatesPath, file);
+                const templatePath = path58__namespace.default.join(this.templatesPath, file);
                 const content = await fsp__namespace.default.readFile(templatePath, "utf-8");
                 const template = JSON.parse(content);
                 templates.push(template);
@@ -56956,7 +57693,7 @@ var init_ConfigPortAdapter = __esm({
       }
       async saveLayerConfig(layer, config2) {
         const configPath = this.getLayerConfigPath(layer);
-        await fsp__namespace.default.mkdir(path57__namespace.default.dirname(configPath), { recursive: true });
+        await fsp__namespace.default.mkdir(path58__namespace.default.dirname(configPath), { recursive: true });
         await fsp__namespace.default.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
       }
       getLayerConfigPath(layer) {
@@ -56968,7 +57705,7 @@ var init_ConfigPortAdapter = __esm({
           case "project":
             return this.projectConfigPath;
           case "runtime":
-            return path57__namespace.default.join(os16__namespace.default.tmpdir(), "maria-runtime-config.json");
+            return path58__namespace.default.join(os16__namespace.default.tmpdir(), "maria-runtime-config.json");
           default:
             return this.userConfigPath;
         }
@@ -57022,7 +57759,7 @@ var init_ConfigPortAdapter = __esm({
           const history = JSON.parse(historyContent);
           history.push(entry);
           const trimmedHistory = history.slice(-1e3);
-          await fsp__namespace.default.mkdir(path57__namespace.default.dirname(this.historyPath), { recursive: true });
+          await fsp__namespace.default.mkdir(path58__namespace.default.dirname(this.historyPath), { recursive: true });
           await fsp__namespace.default.writeFile(
             this.historyPath,
             JSON.stringify(trimmedHistory, null, 2),
@@ -57034,7 +57771,7 @@ var init_ConfigPortAdapter = __esm({
       }
       async loadTemplate(templateId) {
         try {
-          const templatePath = path57__namespace.default.join(this.templatesPath, `${templateId}.json`);
+          const templatePath = path58__namespace.default.join(this.templatesPath, `${templateId}.json`);
           const content = await fsp__namespace.default.readFile(templatePath, "utf-8");
           return JSON.parse(content);
         } catch (error2) {
@@ -58213,7 +58950,7 @@ var init_rate_limit_handler = __esm({
 async function scanRepo(cwd2) {
   if (_cache && _cache.root === cwd2) return _cache;
   const root = cwd2;
-  const pkgPath = path57.join(root, "package.json");
+  const pkgPath = path58.join(root, "package.json");
   let pkg = {};
   try {
     pkg = JSON.parse(await fsp.readFile(pkgPath, "utf8"));
@@ -58223,17 +58960,17 @@ async function scanRepo(cwd2) {
   const usesReact = !!deps["react"];
   const usesNext = !!deps["next"];
   const jsModuleType = pkg.type === "module" ? "esm" : "cjs";
-  const hasSrc = fs24.existsSync(path57.join(root, "src"));
+  const hasSrc = fs24.existsSync(path58.join(root, "src"));
   const srcRoot = hasSrc ? "src" : "";
-  const tsconfigPath = path57.join(root, "tsconfig.json");
+  const tsconfigPath = path58.join(root, "tsconfig.json");
   let usesTS = fs24.existsSync(tsconfigPath) || !!deps["typescript"];
   if (!usesTS && hasSrc) {
     const candidates = ["index.ts", "main.ts", "App.tsx"];
-    usesTS = candidates.some((f3) => fs24.existsSync(path57.join(root, "src", f3)));
+    usesTS = candidates.some((f3) => fs24.existsSync(path58.join(root, "src", f3)));
   }
-  const nextAppDir = usesNext && fs24.existsSync(path57.join(root, "app"));
+  const nextAppDir = usesNext && fs24.existsSync(path58.join(root, "app"));
   const testRunner = deps["vitest"] ? "vitest" : deps["jest"] ? "jest" : null;
-  const isMonorepo2 = fs24.existsSync(path57.join(root, "pnpm-workspace.yaml")) || fs24.existsSync(path57.join(root, "packages")) || fs24.existsSync(path57.join(root, "apps"));
+  const isMonorepo2 = fs24.existsSync(path58.join(root, "pnpm-workspace.yaml")) || fs24.existsSync(path58.join(root, "packages")) || fs24.existsSync(path58.join(root, "apps"));
   const packages = [];
   let aliasPaths = {};
   try {
@@ -58243,7 +58980,7 @@ async function scanRepo(cwd2) {
   }
   let eol = "lf";
   try {
-    const ec = await fsp.readFile(path57.join(root, ".editorconfig"), "utf8");
+    const ec = await fsp.readFile(path58.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 {
@@ -58262,7 +58999,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 ? path57.join(base, withExt) : withExt;
+  const rel = base ? path58.join(base, withExt) : withExt;
   return { ...fp, path: rel.replace(/\\/g, "/") };
 }
 function decideExt(fp, p) {
@@ -58302,10 +59039,10 @@ function suggestName(fp, p) {
   const base = (fp.description || "file").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
   return base || "file";
 }
-function guessKindByPath(path58) {
-  if (/__tests__|\.spec\.(t|j)sx?$|^tests\//.test(path58)) return "test";
-  if (/^docs\//.test(path58) || /\.md$/.test(path58)) return "doc";
-  if (/\.(json|cjs|js|ts)$/.test(path58) && !/src\//.test(path58)) return "config";
+function guessKindByPath(path59) {
+  if (/__tests__|\.spec\.(t|j)sx?$|^tests\//.test(path59)) return "test";
+  if (/^docs\//.test(path59) || /\.md$/.test(path59)) return "doc";
+  if (/\.(json|cjs|js|ts)$/.test(path59) && !/src\//.test(path59)) return "config";
   return "source";
 }
 var init_PathInferencer = __esm({
@@ -58367,15 +59104,15 @@ async function validatePlan(plans, opts) {
       skipped.push(fp.path);
       continue;
     }
-    const full = path57__namespace.default.join(opts.root, rel);
-    if (!full.startsWith(path57__namespace.default.resolve(opts.root))) {
+    const full = path58__namespace.default.join(opts.root, rel);
+    if (!full.startsWith(path58__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 = path57__namespace.default.basename(rel);
+      const name2 = path58__namespace.default.basename(rel);
       if (invalidChars.test(rel)) {
         warnings.push(`Invalid characters in path (Windows): ${fp.path}`);
         skipped.push(fp.path);
@@ -58414,7 +59151,7 @@ async function validatePlan(plans, opts) {
     }
   }
   for (const fp of clamped) {
-    const full = path57__namespace.default.join(opts.root, fp.path);
+    const full = path58__namespace.default.join(opts.root, fp.path);
     const exists = await exists(full);
     const willModify = exists;
     if (willModify) {
@@ -58774,7 +59511,7 @@ async function mapAttachmentsToTargets(attached, opts) {
   const warnings = [];
   const mapped = [];
   const ambiguous = [];
-  const root = path57__namespace.default.resolve(opts.root);
+  const root = path58__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}`);
@@ -58790,7 +59527,7 @@ async function mapAttachmentsToTargets(attached, opts) {
     }
     if (a.pathHint) {
       const safeRel = sanitizeRel(a.pathHint);
-      const full = path57__namespace.default.join(root, safeRel);
+      const full = path58__namespace.default.join(root, safeRel);
       if (!full.startsWith(root)) {
         warnings.push(`Path traversal/absolute denied: ${a.pathHint}`);
       } else if (!opts.allowDotfiles && hasDotSegment(safeRel)) {
@@ -58802,7 +59539,7 @@ async function mapAttachmentsToTargets(attached, opts) {
       }
     }
     const name2 = a.originalName.toLowerCase();
-    const matches = Array.from(repoFiles.values()).filter((p) => path57__namespace.default.basename(p).toLowerCase() === name2);
+    const matches = Array.from(repoFiles.values()).filter((p) => path58__namespace.default.basename(p).toLowerCase() === name2);
     if (matches.length === 1) {
       mapped.push({ path: matches[0], exists: true, reason: "filename", attachment: a });
       continue;
@@ -58816,7 +59553,7 @@ async function mapAttachmentsToTargets(attached, opts) {
     for (const p of candidates.slice(0, 500)) {
       let score = 0;
       try {
-        const full = path57__namespace.default.join(root, p);
+        const full = path58__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 {
@@ -58873,8 +59610,8 @@ async function listRepoFiles(root) {
     for (const e2 of entries) {
       const name2 = e2.name;
       if (name2 === ".git" || name2 === "node_modules" || name2 === "dist" || name2 === ".maria") continue;
-      const full = path57__namespace.default.join(dir, name2);
-      const rel = path57__namespace.default.relative(root, full).replace(/\\/g, "/");
+      const full = path58__namespace.default.join(dir, name2);
+      const rel = path58__namespace.default.relative(root, full).replace(/\\/g, "/");
       if (e2.isDirectory()) {
         await walk2(full);
         continue;
@@ -58915,10 +59652,10 @@ function jaccard(a, b) {
   return union === 0 ? 0 : inter / union;
 }
 function proposePath(root, original) {
-  const base = path57__namespace.default.basename(original).replace(/\s+/g, "-").replace(/[^a-zA-Z0-9._-]/g, "").toLowerCase();
-  const src = path57__namespace.default.join(root, "src");
+  const base = path58__namespace.default.basename(original).replace(/\s+/g, "-").replace(/[^a-zA-Z0-9._-]/g, "").toLowerCase();
+  const src = path58__namespace.default.join(root, "src");
   const dir = existsSync8(src) ? "src" : "";
-  const rel = dir ? path57__namespace.default.join(dir, base) : base;
+  const rel = dir ? path58__namespace.default.join(dir, base) : base;
   return rel.replace(/\\/g, "/");
 }
 function existsSync8(p) {
@@ -59248,9 +59985,9 @@ function languageExt(lang) {
 async function journalResume(root, request, files) {
   try {
     const fs48 = await import('fs/promises');
-    const dir = path57__namespace.default.join(root, ".maria", "memory");
+    const dir = path58__namespace.default.join(root, ".maria", "memory");
     await fs48.mkdir(dir, { recursive: true });
-    const out = path57__namespace.default.join(dir, "resume-plan.json");
+    const out = path58__namespace.default.join(dir, "resume-plan.json");
     const payload = { request, createdAt: (/* @__PURE__ */ new Date()).toISOString(), files };
     await fs48.writeFile(out, JSON.stringify(payload, null, 2), "utf8");
   } catch {
@@ -59681,7 +60418,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(path57__namespace.join(root, p.path));
+          const exists = await this.pathExists(path58__namespace.join(root, p.path));
           p.action = exists ? "modify" : "create";
         }
         return normalized;
@@ -59697,9 +60434,9 @@ ${pretty}`);
       async persistLastPlan(root, plans) {
         try {
           const fs48 = await import('fs/promises');
-          const p = path57__namespace.join(root, ".maria");
+          const p = path58__namespace.join(root, ".maria");
           await fs48.mkdir(p, { recursive: true });
-          const out = path57__namespace.join(p, "last-plan.json");
+          const out = path58__namespace.join(p, "last-plan.json");
           await fs48.writeFile(out, JSON.stringify({ createdAt: (/* @__PURE__ */ new Date()).toISOString(), plans }, null, 2), "utf8");
         } catch {
         }
@@ -59715,7 +60452,7 @@ ${pretty}`);
         try {
           for (const plan of plans) {
             if (options.signal?.aborted) throw new Error("INTERRUPTED");
-            const full = path57__namespace.join(options.root, plan.path);
+            const full = path58__namespace.join(options.root, plan.path);
             const exists = await this.pathExists(full);
             if (exists && !options.overwriteAllowed) {
               skipped.push(plan.path);
@@ -59724,7 +60461,7 @@ ${pretty}`);
               continue;
             }
             const tmp = full + `.tmp-${process.pid}-${Date.now()}`;
-            await fs48.mkdir(path57__namespace.dirname(full), { recursive: true });
+            await fs48.mkdir(path58__namespace.dirname(full), { recursive: true });
             await fs48.writeFile(tmp, plan.preview || "", "utf8");
             await fs48.rename(tmp, full);
             if (exists) modified.push(plan.path);
@@ -59737,7 +60474,7 @@ ${pretty}`);
           if (options.rollback) {
             for (const p of [...created, ...modified]) {
               try {
-                await fs48.unlink(path57__namespace.join(options.root, p));
+                await fs48.unlink(path58__namespace.join(options.root, p));
               } catch {
               }
             }
@@ -59817,13 +60554,13 @@ ${pretty}`);
         const extension = LANGUAGE_EXTENSIONS[block.language] || ".txt";
         const timestamp2 = Date.now().toString(36);
         const filename = index === 0 ? `${baseName}${extension}` : `${baseName}_${index + 1}${extension}`;
-        const fullPath = path57__namespace.join(process.cwd(), filename);
+        const fullPath = path58__namespace.join(process.cwd(), filename);
         try {
           await fsp.writeFile(fullPath, block.code, "utf8");
           return fullPath;
         } catch (error2) {
           const fallbackName = `code_${timestamp2}${extension}`;
-          const fallbackPath = path57__namespace.join(process.cwd(), fallbackName);
+          const fallbackPath = path58__namespace.join(process.cwd(), fallbackName);
           await fsp.writeFile(fallbackPath, block.code, "utf8");
           return fallbackPath;
         }
@@ -59857,15 +60594,15 @@ ${pretty}`);
       async collectAttachedFiles(context2) {
         const list = [];
         const fs48 = await import('fs/promises');
-        const path58 = await import('path');
+        const path59 = 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 || path58.basename(p || `attachment_${Date.now().toString(36)}`);
+            const originalName = a.name || path59.basename(p || `attachment_${Date.now().toString(36)}`);
             let content = a.content;
             if (!content && p) {
-              const abs = path58.isAbsolute(p) ? p : path58.join(process.cwd(), p);
+              const abs = path59.isAbsolute(p) ? p : path59.join(process.cwd(), p);
               content = await fs48.readFile(abs, "utf8");
             }
             if (!content) continue;
@@ -59975,7 +60712,7 @@ function getKnowledgeProviderFromEnv(root = process.cwd()) {
 function safeListFiles(dir) {
   try {
     return fs24__namespace.default.readdirSync(dir, { withFileTypes: true }).flatMap((d) => {
-      const p = path57__namespace.default.join(dir, d.name);
+      const p = path58__namespace.default.join(dir, d.name);
       if (d.isDirectory()) {
         if (/node_modules|\.git|dist|coverage|artifacts|reports/.test(p)) return [];
         return safeListFiles(p);
@@ -60011,7 +60748,7 @@ var init_KnowledgeProvider = __esm({
       }
       async getPrinciples(_projectId, _taskId) {
         const candidates = [
-          path57__namespace.default.join(this.root, "docs"),
+          path58__namespace.default.join(this.root, "docs"),
           this.root
         ];
         const out = [];
@@ -60041,7 +60778,7 @@ var init_KnowledgeProvider = __esm({
 var resume_command_exports = {};
 __export(resume_command_exports, {
   ResumeCommand: () => ResumeCommand,
-  meta: () => meta15
+  meta: () => meta16
 });
 function truncate2(s2, n) {
   return s2.length <= n ? s2 : s2.slice(0, n) + "\u2026";
@@ -60073,7 +60810,7 @@ function promptLine(timeoutMs = 15e3) {
 }
 async function readLastDebugStatusSafe(cwd2) {
   try {
-    const p = path57__namespace.join(cwd2, ".maria", "memory", "debug-resume.json");
+    const p = path58__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];
@@ -60084,7 +60821,7 @@ async function readLastDebugStatusSafe(cwd2) {
 }
 async function readDebugJournalListSafe(cwd2, count) {
   try {
-    const p = path57__namespace.join(cwd2, ".maria", "memory", "debug-resume.json");
+    const p = path58__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 [];
@@ -60093,7 +60830,7 @@ async function readDebugJournalListSafe(cwd2, count) {
     return [];
   }
 }
-var ResumeCommand, meta15;
+var ResumeCommand, meta16;
 var init_resume_command = __esm({
   "src/slash-commands/categories/workflow/resume.command.ts"() {
     init_base_command();
@@ -60304,7 +61041,7 @@ var init_resume_command = __esm({
         return cands[n - 1];
       }
     };
-    meta15 = {
+    meta16 = {
       name: "workflow/resume",
       category: "implementation",
       description: "Resume previous task context and propose next /code step",
@@ -60379,11 +61116,11 @@ async function runWithBudget(tasks, totalMs = 6e3, perStepMs = 600) {
   return out;
 }
 function isSensitive(filepath) {
-  const basename15 = path57__namespace.basename(filepath);
+  const basename15 = path58__namespace.basename(filepath);
   return SENSITIVE_PATTERNS2.some((pattern) => pattern.test(basename15) || pattern.test(filepath));
 }
 function isBinary2(filepath) {
-  const ext2 = path57__namespace.extname(filepath).toLowerCase();
+  const ext2 = path58__namespace.extname(filepath).toLowerCase();
   return BINARY_EXTENSIONS.has(ext2);
 }
 async function safeRead(file, maxBytes = 512 * 1024, maxLines = 200, signal) {
@@ -60439,15 +61176,15 @@ async function scanRoot(opts) {
     ];
     for (const { name: name2, maxLines } of rootFiles) {
       if (signal.aborted || remainMs() < 100) break;
-      const filepath = path57__namespace.join(cwd2, name2);
+      const filepath = path58__namespace.join(cwd2, name2);
       const result = await safeRead(filepath, 512 * 1024, maxLines, signal);
       if (result.head || result.meta) {
-        let meta24 = result.meta || object;
+        let meta25 = result.meta || object;
         if (name2 === "package.json" && result.head) {
           try {
             const pkg = JSON.parse(result.head);
-            meta24 = {
-              ...meta24,
+            meta25 = {
+              ...meta25,
               name: pkg.name,
               version: pkg.version,
               type: pkg.type,
@@ -60460,14 +61197,14 @@ async function scanRoot(opts) {
               workspaces: pkg.workspaces
             };
           } catch (e2) {
-            meta24.parseError = true;
+            meta25.parseError = true;
           }
         }
         findings.push({
           file: name2,
           kind: "read",
           head: result.head,
-          meta: meta24,
+          meta: meta25,
           truncated: result.truncated
         });
       }
@@ -60495,7 +61232,7 @@ async function scanBuild(opts) {
     ];
     for (const name2 of buildFiles) {
       if (signal.aborted || remainMs() < 100) break;
-      const filepath = path57__namespace.join(cwd2, name2);
+      const filepath = path58__namespace.join(cwd2, name2);
       const result = await safeRead(filepath, 512 * 1024, 100, signal);
       if (result.head || result.meta) {
         findings.push({
@@ -60532,7 +61269,7 @@ async function scanQuality(opts) {
     ];
     for (const name2 of qualityFiles) {
       if (signal.aborted || remainMs() < 100) break;
-      const filepath = path57__namespace.join(cwd2, name2);
+      const filepath = path58__namespace.join(cwd2, name2);
       const result = await safeRead(filepath, 512 * 1024, 50, signal);
       if (result.head || result.meta) {
         findings.push({
@@ -60577,7 +61314,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(path57__namespace.join(cwd2, file), 512 * 1024, 100, signal);
+        const result = await safeRead(path58__namespace.join(cwd2, file), 512 * 1024, 100, signal);
         if (result.head || result.meta) {
           findings.push({
             file,
@@ -60619,7 +61356,7 @@ async function scanEntries(opts) {
     ];
     for (const name2 of entryFiles) {
       if (signal.aborted || remainMs() < 100) break;
-      const filepath = path57__namespace.join(cwd2, name2);
+      const filepath = path58__namespace.join(cwd2, name2);
       const result = await safeRead(filepath, 512 * 1024, 80, signal);
       if (result.head || result.meta) {
         findings.push({
@@ -60700,9 +61437,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 = path57__namespace.join(cwd2, binPath);
+    const srcPath = path58__namespace.join(cwd2, binPath);
     if (!fs24__namespace.existsSync(srcPath)) {
-      const distGuess = path57__namespace.join(
+      const distGuess = path58__namespace.join(
         cwd2,
         "dist",
         binPath.replace(/^src\//, "").replace(/^bin\//, "bin/")
@@ -60805,19 +61542,19 @@ function extractPackageInfo(findings) {
       hasPostinstall: false
     };
   }
-  const meta24 = pkgFinding.meta;
+  const meta25 = pkgFinding.meta;
   return {
-    name: meta24.name,
-    version: meta24.version,
-    type: meta24.type,
-    scripts: meta24.scripts ? Object.keys(meta24.scripts) : [],
-    hasPostinstall: !!meta24.scripts?.postinstall,
-    bin: meta24.bin,
-    main: meta24.main,
-    exports: meta24.exports,
-    dependencies: meta24.dependencies || [],
-    devDependencies: meta24.devDependencies || [],
-    workspaces: meta24.workspaces
+    name: meta25.name,
+    version: meta25.version,
+    type: meta25.type,
+    scripts: meta25.scripts ? Object.keys(meta25.scripts) : [],
+    hasPostinstall: !!meta25.scripts?.postinstall,
+    bin: meta25.bin,
+    main: meta25.main,
+    exports: meta25.exports,
+    dependencies: meta25.dependencies || [],
+    devDependencies: meta25.devDependencies || [],
+    workspaces: meta25.workspaces
   };
 }
 function collectWarnings(pkg, findings, cwd2) {
@@ -60968,9 +61705,9 @@ function calculateMetrics(findings, startTime) {
 }
 function renderFinding(f3) {
   const title = `### ${f3.kind.toUpperCase()} \u2014 ${f3.file}`;
-  let meta24 = "";
+  let meta25 = "";
   if (f3.meta && Object.keys(f3.meta).length > 0) {
-    meta24 = `
+    meta25 = `
 <details><summary>meta</summary>
 
 \`\`\`json
@@ -60991,7 +61728,7 @@ ${f3.head.trim()}
   }
   const truncInfo = f3.truncated ? `
 > _truncated preview_` : "";
-  return [title, meta24, content, truncInfo, ""].join("\n");
+  return [title, meta25, content, truncInfo, ""].join("\n");
 }
 function safeJsonStringify(obj) {
   try {
@@ -61211,7 +61948,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(path57__namespace.join(root, "package.json"), "utf8")
+        await fsp__namespace.readFile(path58__namespace.join(root, "package.json"), "utf8")
       );
       if (pkg.workspaces) {
         if (files.includes("pnpm-workspace.yaml")) return "pnpm";
@@ -61234,7 +61971,7 @@ async function findWorkspaces(root, type2) {
   try {
     switch (type2) {
       case "pnpm": {
-        const wsFile = path57__namespace.join(root, "pnpm-workspace.yaml");
+        const wsFile = path58__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?)+)/);
@@ -61256,7 +61993,7 @@ async function findWorkspaces(root, type2) {
       }
       case "yarn":
       case "npm": {
-        const pkgPath = path57__namespace.join(root, "package.json");
+        const pkgPath = path58__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 || [];
@@ -61275,7 +62012,7 @@ async function findWorkspaces(root, type2) {
       }
       case "lerna": {
         try {
-          const lernaPath = path57__namespace.join(root, "lerna.json");
+          const lernaPath = path58__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) {
@@ -61334,13 +62071,13 @@ async function findWorkspaces(root, type2) {
 }
 async function analyzeWorkspace(workspacePath, root) {
   const info = {
-    name: path57__namespace.basename(workspacePath),
+    name: path58__namespace.basename(workspacePath),
     path: workspacePath,
     type: "unknown",
     language: "unknown"
   };
   try {
-    const pkgPath = path57__namespace.join(root, workspacePath, "package.json");
+    const pkgPath = path58__namespace.join(root, workspacePath, "package.json");
     const pkgContent = await safeRead(pkgPath, 512 * 1024, 1e3);
     if (pkgContent.head) {
       try {
@@ -61383,7 +62120,7 @@ async function analyzeWorkspace(workspacePath, root) {
     }
     const globby = await loadGlobby();
     const files = await globby(["**/*.{ts,tsx,js,jsx,mjs,cjs}"], {
-      cwd: path57__namespace.join(root, workspacePath),
+      cwd: path58__namespace.join(root, workspacePath),
       deep: 2,
       ignore: ["node_modules", "dist", "build"],
       stats: false
@@ -61938,12 +62675,12 @@ function getModuleName(filePath) {
   if (srcIndex >= 0 && srcIndex < parts.length - 1) {
     return parts[srcIndex + 1];
   }
-  return path57__namespace.dirname(filePath).split("/").pop() || "root";
+  return path58__namespace.dirname(filePath).split("/").pop() || "root";
 }
 function resolveLocalImport(fromFile2, importPath) {
   if (!importPath.startsWith(".")) return null;
-  const dir = path57__namespace.dirname(fromFile2);
-  const resolved = path57__namespace.resolve(dir, importPath);
+  const dir = path58__namespace.dirname(fromFile2);
+  const resolved = path58__namespace.resolve(dir, importPath);
   return getModuleName(resolved);
 }
 function getMetricStatus(metric, value) {
@@ -62073,7 +62810,7 @@ async function extractCodeSnippets(files, projectRoot, maxSnippets, includeExamp
 }
 async function extractFileSnippet(file, projectRoot, category) {
   try {
-    const fullPath = path57__namespace.join(projectRoot, file.path);
+    const fullPath = path58__namespace.join(projectRoot, file.path);
     const content = await safeRead(fullPath, 512 * 1024, 50);
     if (!content.head) return null;
     const lines = content.head.split("\n");
@@ -62084,7 +62821,7 @@ async function extractFileSnippet(file, projectRoot, category) {
     const codeLines = lines.slice(codeStart, codeStart + 30);
     return {
       file: file.path,
-      title: `${path57__namespace.basename(file.path)} - ${category}`,
+      title: `${path58__namespace.basename(file.path)} - ${category}`,
       description: getFileDescription(file),
       code: codeLines.join("\n"),
       language: file.language || "javascript",
@@ -62172,7 +62909,7 @@ function extractAPIDocumentation(files) {
 async function extractConfigurationDetails(projectRoot) {
   const details = [];
   try {
-    const pkgPath = path57__namespace.join(projectRoot, "package.json");
+    const pkgPath = path58__namespace.join(projectRoot, "package.json");
     const pkgContent = await fsp__namespace.readFile(pkgPath, "utf8");
     const pkg = JSON.parse(pkgContent);
     if (pkg.engines) {
@@ -62205,7 +62942,7 @@ async function extractConfigurationDetails(projectRoot) {
   } catch {
   }
   try {
-    const tsconfigPath = path57__namespace.join(projectRoot, "tsconfig.json");
+    const tsconfigPath = path58__namespace.join(projectRoot, "tsconfig.json");
     const tsconfigContent = await fsp__namespace.readFile(tsconfigPath, "utf8");
     const tsconfig = JSON.parse(tsconfigContent);
     if (tsconfig.compilerOptions?.strict !== void 0) {
@@ -62229,7 +62966,7 @@ async function extractConfigurationDetails(projectRoot) {
   } catch {
   }
   try {
-    const envExamplePath = path57__namespace.join(projectRoot, ".env.example");
+    const envExamplePath = path58__namespace.join(projectRoot, ".env.example");
     const envContent = await fsp__namespace.readFile(envExamplePath, "utf8");
     const envVars = envContent.match(/^[A-Z_]+=/gm);
     if (envVars) {
@@ -63167,7 +63904,7 @@ function generateFooter3(data) {
 }
 function generateFallbackMariaMd(error2, projectPath) {
   const data = {
-    projectName: path57__namespace.basename(projectPath),
+    projectName: path58__namespace.basename(projectPath),
     projectPath,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     errors: [error2.message]
@@ -63182,13 +63919,13 @@ var init_maria_template = __esm({
 });
 async function writeAtomic(filePath, content, options = {}) {
   const { encoding = "utf8", mode = 420, fsync = true, tmpDir } = options;
-  const dir = path57__namespace.dirname(filePath);
-  const basename15 = path57__namespace.basename(filePath);
+  const dir = path58__namespace.dirname(filePath);
+  const basename15 = path58__namespace.basename(filePath);
   const tmpSuffix = `.tmp-${Date.now()}-${crypto6.randomBytes(4).toString("hex")}`;
-  const tmpPath = tmpDir ? path57__namespace.join(tmpDir, `${basename15}${tmpSuffix}`) : path57__namespace.join(dir, `${basename15}${tmpSuffix}`);
+  const tmpPath = tmpDir ? path58__namespace.join(tmpDir, `${basename15}${tmpSuffix}`) : path58__namespace.join(dir, `${basename15}${tmpSuffix}`);
   let fileHandle = null;
   try {
-    await fsp__namespace.mkdir(path57__namespace.dirname(tmpPath), { recursive: true });
+    await fsp__namespace.mkdir(path58__namespace.dirname(tmpPath), { recursive: true });
     if (Buffer.isBuffer(content)) {
       await fsp__namespace.writeFile(tmpPath, content, { mode });
     } else {
@@ -63908,13 +64645,13 @@ var init_initialization_manager = __esm({
           if (!stats.isDirectory()) {
             this.errors.push(`Working directory is not a directory: ${cwd2}`);
           }
-          const packagePath = path57__namespace.join(cwd2, "package.json");
+          const packagePath = path58__namespace.join(cwd2, "package.json");
           try {
             await fsp__namespace.access(packagePath);
           } catch {
             this.warnings.push("No package.json found in working directory");
           }
-          const gitPath = path57__namespace.join(cwd2, ".git");
+          const gitPath = path58__namespace.join(cwd2, ".git");
           try {
             await fsp__namespace.access(gitPath);
           } catch {
@@ -63966,7 +64703,7 @@ var init_initialization_manager = __esm({
       }
       async validateMonorepoConfig(cwd2) {
         try {
-          const packagePath = path57__namespace.join(cwd2, "package.json");
+          const packagePath = path58__namespace.join(cwd2, "package.json");
           const content = await fsp__namespace.readFile(packagePath, "utf-8");
           const pkg = JSON.parse(content);
           if (pkg.workspaces) {
@@ -64356,7 +65093,7 @@ var init_initialization_manager = __esm({
       async generateEnhancedMariaMd(summary, opts) {
         try {
           return generateMariaMd2({
-            projectName: summary.projectName || path57__namespace.basename(opts.cwd || process.cwd()),
+            projectName: summary.projectName || path58__namespace.basename(opts.cwd || process.cwd()),
             projectPath: opts.cwd || process.cwd(),
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
             summary,
@@ -64377,7 +65114,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 = path57__namespace.join(cwd2, filename);
+            const filePath = path58__namespace.join(cwd2, filename);
             try {
               await writeAtomic(filePath, content);
               this.progressTracker.addMetric(
@@ -64402,7 +65139,7 @@ var init_initialization_manager = __esm({
        */
       async verifyOutput(opts) {
         const cwd2 = opts.cwd || process.cwd();
-        const mariaMdPath = path57__namespace.join(cwd2, "MARIA.md");
+        const mariaMdPath = path58__namespace.join(cwd2, "MARIA.md");
         try {
           const content = await fsp__namespace.readFile(mariaMdPath, "utf-8");
           const minLength = 2e3;
@@ -64435,7 +65172,7 @@ var init_initialization_manager = __esm({
       createMinimalSummary(opts) {
         const cwd2 = opts.cwd || process.cwd();
         return {
-          projectName: path57__namespace.basename(cwd2),
+          projectName: path58__namespace.basename(cwd2),
           projectPath: cwd2,
           description: "Project analysis incomplete due to errors",
           techStack: {
@@ -64470,7 +65207,7 @@ var init_initialization_manager = __esm({
        */
       async generateFallbackArtifacts(error2, opts) {
         const cwd2 = opts.cwd || process.cwd();
-        path57__namespace.basename(cwd2);
+        path58__namespace.basename(cwd2);
         const mariaMd = generateFallbackMariaMd({
           });
         const initReport = `# Init Report - Error Recovery Mode
@@ -64527,7 +65264,7 @@ async function safeBackup(_filePath) {
     await fsp__namespace.copyFile(_filePath, bakPath);
     if (!process.env.MARIA_INIT_QUIET) {
       console.log(
-        chalk37__default.default.gray(`  \u21B3 backup: ${path57__namespace.relative(process.cwd(), bakPath)}`)
+        chalk37__default.default.gray(`  \u21B3 backup: ${path58__namespace.relative(process.cwd(), bakPath)}`)
       );
     }
   } catch {
@@ -64565,7 +65302,7 @@ async function writeArtifacts(artifacts, opts, cwd2, reporter) {
     { name: "INIT_SUMMARY.txt", content: artifacts.initSummaryTxt }
   ];
   for (const { name: name2, content } of files) {
-    const _filePath = path57__namespace.join(cwd2, name2);
+    const _filePath = path58__namespace.join(cwd2, name2);
     if (await fileExists2(_filePath) && !opts.force) {
       await safeBackup(_filePath);
     }
@@ -64675,7 +65412,7 @@ This process will:
   );
   const artifacts = generateArtifacts(summary, findings, startTime);
   const mariaMdContent = generateMariaMd2({
-    projectName: summary.projectName || path57__namespace.basename(cwd2),
+    projectName: summary.projectName || path58__namespace.basename(cwd2),
     projectPath: cwd2,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     summary,
@@ -64835,7 +65572,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: path57__namespace.resolve(root, file) };
+            return { status, file: path58__namespace.resolve(root, file) };
           });
           const filtered = await this.filterFiles(
             changes.map((c) => c.file),
@@ -64844,8 +65581,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) => path57__namespace.relative(root, c.file));
-          const changed = filteredChanges.filter((c) => c.status !== "D").map((c) => path57__namespace.relative(root, c.file));
+          const deleted = filteredChanges.filter((c) => c.status === "D").map((c) => path58__namespace.relative(root, c.file));
+          const changed = filteredChanges.filter((c) => c.status !== "D").map((c) => path58__namespace.relative(root, c.file));
           return {
             mode: "git",
             ref,
@@ -64877,7 +65614,7 @@ var init_delta_detector = __esm({
             break;
           }
           if (entry.mtime && entry.mtime > since) {
-            changed.push(path57__namespace.relative(root, entry.file));
+            changed.push(path58__namespace.relative(root, entry.file));
           }
           if (options.maxFiles && changed.length >= options.maxFiles) {
             break;
@@ -64901,7 +65638,7 @@ var init_delta_detector = __esm({
        * Detect changes by comparing with state.json
        */
       async detectByState(root, options) {
-        const statePath = path57__namespace.join(root, ".maria", "state.json");
+        const statePath = path58__namespace.join(root, ".maria", "state.json");
         let lastHashes = {};
         try {
           const stateContent = await fsp__namespace.readFile(statePath, "utf-8");
@@ -64917,7 +65654,7 @@ var init_delta_detector = __esm({
           if (options.budgetMs && Date.now() - this.startTime > options.budgetMs) {
             break;
           }
-          const relativePath = path57__namespace.relative(root, entry.file);
+          const relativePath = path58__namespace.relative(root, entry.file);
           const hash = entry.hash || await this.hashFile(entry.file);
           nowHashes[relativePath] = hash;
           if (!lastHashes[relativePath] || lastHashes[relativePath] !== hash) {
@@ -64997,7 +65734,7 @@ var init_delta_detector = __esm({
         }
         const patterns = options.include || ["**/*"];
         const ignore = options.exclude || [];
-        const relativePaths = files.map((f3) => path57__namespace.relative(root, f3));
+        const relativePaths = files.map((f3) => path58__namespace.relative(root, f3));
         const globby = await loadGlobby();
         const matched = await globby(patterns, {
           cwd: root,
@@ -65022,8 +65759,8 @@ var init_delta_detector = __esm({
        * Update state.json with new hashes
        */
       async updateState(root, delta) {
-        const statePath = path57__namespace.join(root, ".maria", "state.json");
-        await fsp__namespace.mkdir(path57__namespace.dirname(statePath), { recursive: true });
+        const statePath = path58__namespace.join(root, ".maria", "state.json");
+        await fsp__namespace.mkdir(path58__namespace.dirname(statePath), { recursive: true });
         let state;
         try {
           const content = await fsp__namespace.readFile(statePath, "utf-8");
@@ -65048,7 +65785,7 @@ var init_delta_detector = __esm({
             delete currentHashes[file];
           });
           for (const file of delta.changed) {
-            const fullPath = path57__namespace.join(root, file);
+            const fullPath = path58__namespace.join(root, file);
             try {
               const hash = await this.hashFile(fullPath);
               if (hash) {
@@ -65908,8 +66645,8 @@ var init_init_command = __esm({
       async execute(options = {}) {
         const startTime = Date.now();
         const root = options.root || process.cwd();
-        const stateDir = path57__namespace.join(root, ".maria");
-        const statePath = path57__namespace.join(stateDir, "state.json");
+        const stateDir = path58__namespace.join(root, ".maria");
+        const statePath = path58__namespace.join(stateDir, "state.json");
         this.logger.header("MARIA /init - Enhanced Codebase Analysis");
         const hasExistingState = await this.fileExists(statePath);
         if (hasExistingState && !options.force) {
@@ -66034,7 +66771,7 @@ var init_init_command = __esm({
           nodes.push({
             id: file._path,
             type: "file",
-            name: path57__namespace.basename(file._path),
+            name: path58__namespace.basename(file._path),
             language: file.language,
             size: file.size,
             complexity: file.complexity
@@ -66139,7 +66876,7 @@ ${file.summary || ""}`,
       async generateArtifacts(root, scanResult, graphResult) {
         this.logger.start("artifacts", "Generating artifacts...");
         const mariaMd = this.generateMariaMd(scanResult, graphResult);
-        const mariaMdPath = path57__namespace.join(root, "MARIA.md");
+        const mariaMdPath = path58__namespace.join(root, "MARIA.md");
         await fsp__namespace.writeFile(mariaMdPath, mariaMd, "utf-8");
         const depMapJson = {
           version: "3.2.2",
@@ -66156,7 +66893,7 @@ ${file.summary || ""}`,
             edges: graphResult.edgesCreated
           }
         };
-        const depMapPath = path57__namespace.join(root, "DEPENDENCY_MAP.json");
+        const depMapPath = path58__namespace.join(root, "DEPENDENCY_MAP.json");
         await fsp__namespace.writeFile(
           depMapPath,
           JSON.stringify(depMapJson, null, 2),
@@ -66337,7 +67074,7 @@ Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}
       }
       async saveState(stateDir, state) {
         await fsp__namespace.mkdir(stateDir, { recursive: true });
-        const statePath = path57__namespace.join(stateDir, "state.json");
+        const statePath = path58__namespace.join(stateDir, "state.json");
         await fsp__namespace.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
       }
       async fileExists(_path) {
@@ -66565,17 +67302,17 @@ var init_GraphEngine = __esm({
         const visited = /* @__PURE__ */ new Set();
         const queue = [{ id: from, path: [from] }];
         while (queue.length) {
-          const { id, path: path58 } = queue.shift();
+          const { id, path: path59 } = 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 = [...path58, to];
+              const res = [...path59, to];
               this.recordQueryTime(Date.now() - start);
               return res;
             }
-            if (!visited.has(e2.to)) queue.push({ id: e2.to, path: [...path58, e2.to] });
+            if (!visited.has(e2.to)) queue.push({ id: e2.to, path: [...path59, e2.to] });
           }
         }
         this.recordQueryTime(Date.now() - start);
@@ -66762,8 +67499,8 @@ var init_GraphStore = __esm({
       accessCounter = 0;
       constructor(_maxNodes = 1e4) {
         this._maxNodes = _maxNodes;
-        this.storageDir = path57__namespace.default.join(process.cwd(), ".maria", "graph");
-        this.graphFile = path57__namespace.default.join(this.storageDir, "knowledge-graph.json");
+        this.storageDir = path58__namespace.default.join(process.cwd(), ".maria", "graph");
+        this.graphFile = path58__namespace.default.join(this.storageDir, "knowledge-graph.json");
         this.startPeriodicSave();
       }
       /**
@@ -67287,8 +68024,8 @@ var init_DependencyAnalyzer = __esm({
        */
       resolveImportPath(_importSource, fromFile2, rootDir) {
         if (_importSource.startsWith("./") || _importSource.startsWith("../")) {
-          const _fromDir = path57__namespace.default.dirname(fromFile2);
-          const _resolved = path57__namespace.default.resolve(_fromDir, _importSource);
+          const _fromDir = path58__namespace.default.dirname(fromFile2);
+          const _resolved = path58__namespace.default.resolve(_fromDir, _importSource);
           for (const _ext of this.SUPPORTED_EXTENSIONS) {
             if (_resolved.endsWith(_ext)) {
               return _resolved;
@@ -67298,7 +68035,7 @@ var init_DependencyAnalyzer = __esm({
               __require.resolve(_withExt);
               return _withExt;
             } catch {
-              const _indexFile = path57__namespace.default.join(_resolved, `index${_ext}`);
+              const _indexFile = path58__namespace.default.join(_resolved, `index${_ext}`);
               try {
                 __require.resolve(_indexFile);
                 return _indexFile;
@@ -67310,7 +68047,7 @@ var init_DependencyAnalyzer = __esm({
           return _resolved;
         }
         if (!_importSource.startsWith("@") && !_importSource.includes("node_modules")) {
-          const _resolved = path57__namespace.default.resolve(rootDir, _importSource);
+          const _resolved = path58__namespace.default.resolve(rootDir, _importSource);
           for (const _ext of this.SUPPORTED_EXTENSIONS) {
             const _withExt = _resolved + _ext;
             try {
@@ -67333,7 +68070,7 @@ var init_DependencyAnalyzer = __esm({
           try {
             const _entries = await fsp__namespace.default.readdir(dir, { withFileTypes: true });
             for (const entry of _entries) {
-              const _fullPath = path57__namespace.default.join(dir, entry.name);
+              const _fullPath = path58__namespace.default.join(dir, entry.name);
               if (entry.isDirectory()) {
                 if (!["node_modules", ".git", "dist", "build", ".next"].includes(
                   entry.name
@@ -67341,7 +68078,7 @@ var init_DependencyAnalyzer = __esm({
                   await traverse(_fullPath);
                 }
               } else if (entry.isFile()) {
-                const _ext = path57__namespace.default.extname(entry.name);
+                const _ext = path58__namespace.default.extname(entry.name);
                 if ([".ts", ".tsx", ".js", ".jsx", ".mjs"].includes(_ext)) {
                   files.push(_fullPath);
                 }
@@ -67497,7 +68234,7 @@ var init_DependencyAnalyzer = __esm({
           return {
             id: this.generateNodeId(_filePath),
             type: "file",
-            name: path57__namespace.default.basename(_filePath),
+            name: path58__namespace.default.basename(_filePath),
             _path: _filePath,
             metadata: {
               size: _stats.size,
@@ -67537,7 +68274,7 @@ var init_DependencyAnalyzer = __esm({
         }
       }
       detectLanguage(_filePath) {
-        const _ext = path57__namespace.default.extname(_filePath);
+        const _ext = path58__namespace.default.extname(_filePath);
         switch (_ext) {
           case ".ts":
           case ".tsx":
@@ -68335,7 +69072,7 @@ var init_KnowledgeGraphService = __esm({
             _filePath,
             depth
           );
-          const _fileName2 = path57__namespace.default.basename(_filePath);
+          const _fileName2 = path58__namespace.default.basename(_filePath);
           const _relatedNodes = this.graphEngine.searchNodes(_fileName2);
           const suggestions = [];
           for (const node of _graphContext.nodes.slice(0, 5)) {
@@ -68649,8 +69386,8 @@ async function legacyInit(args2) {
     const cliCwd = process.cwd();
     console.log(chalk37__default.default.blue("\u{1F680} Initializing MARIA configuration..."));
     const options = parseInitOptions(args2);
-    const repoRoot = path57__namespace.resolve(options.root || await findRepoRoot(cliCwd));
-    const tomlPath = path57__namespace.join(repoRoot, ".maria-code.toml");
+    const repoRoot = path58__namespace.resolve(options.root || await findRepoRoot(cliCwd));
+    const tomlPath = path58__namespace.join(repoRoot, ".maria-code.toml");
     const existingConfig = await fileExists3(tomlPath);
     if (existingConfig && !args2.includes("--force")) {
       const result = await prompts__default.default({
@@ -68664,7 +69401,7 @@ async function legacyInit(args2) {
         return "exit";
       }
       await safeBackup2(tomlPath);
-      const mdPath2 = path57__namespace.join(repoRoot, "MARIA.md");
+      const mdPath2 = path58__namespace.join(repoRoot, "MARIA.md");
       if (await fileExists3(mdPath2)) {
         await safeBackup2(mdPath2);
       }
@@ -68678,35 +69415,35 @@ async function legacyInit(args2) {
     const tomlContent = generateTomlConfig(projectConfig);
     try {
       const tomlStatus = await safeWriteIfChanged(tomlPath, tomlContent);
-      const rel = path57__namespace.relative(cliCwd, tomlPath);
+      const rel = path58__namespace.relative(cliCwd, tomlPath);
       if (tomlStatus.status === "up-to-date") {
         console.log(chalk37__default.default.gray(`\u2139\uFE0F  Up-to-date: ${rel}`));
       } else if (tomlStatus.status === "created") {
         console.log(chalk37__default.default.green(`\u2705 Created: ${rel}`));
       } else if (tomlStatus.status === "updated") {
-        console.log(chalk37__default.default.green(`\u2705 Updated: ${rel}`) + (tomlStatus.backup ? chalk37__default.default.gray(` (backup: ${path57__namespace.relative(cliCwd, tomlStatus.backup)})`) : ""));
+        console.log(chalk37__default.default.green(`\u2705 Updated: ${rel}`) + (tomlStatus.backup ? chalk37__default.default.gray(` (backup: ${path58__namespace.relative(cliCwd, tomlStatus.backup)})`) : ""));
       }
     } catch (e2) {
       console.error(chalk37__default.default.red("\u274C Failed to write .maria-code.toml:"), adviceFromFsError(e2));
     }
-    const mdPath = path57__namespace.join(repoRoot, "MARIA.md");
+    const mdPath = path58__namespace.join(repoRoot, "MARIA.md");
     const lang = resolveLang(options.lang);
     const mdContent = generateMariaMd3(projectConfig, lang);
     try {
       const mdStatus = await safeWriteIfChanged(mdPath, mdContent);
-      const rel = path57__namespace.relative(cliCwd, mdPath);
+      const rel = path58__namespace.relative(cliCwd, mdPath);
       if (mdStatus.status === "up-to-date") {
         console.log(chalk37__default.default.gray(`Saved: ${rel} (up-to-date)`));
       } else if (mdStatus.status === "created") {
         console.log(chalk37__default.default.green(`Saved: ${rel} (created)`));
       } else if (mdStatus.status === "updated") {
-        const bakRel = mdStatus.backup ? path57__namespace.relative(cliCwd, mdStatus.backup) : void 0;
+        const bakRel = mdStatus.backup ? path58__namespace.relative(cliCwd, mdStatus.backup) : void 0;
         console.log(chalk37__default.default.green(`Saved: ${rel} (updated${bakRel ? `, backup: ${bakRel}` : ""})`));
       }
     } catch (e2) {
       console.error(chalk37__default.default.red("\u274C Failed to write MARIA.md:"), adviceFromFsError(e2));
     }
-    if (projectConfig.gitInit && !await fileExists3(path57__namespace.join(repoRoot, ".git"))) {
+    if (projectConfig.gitInit && !await fileExists3(path58__namespace.join(repoRoot, ".git"))) {
       try {
         const { execSync } = await import('child_process');
         execSync("git init", { cwd: repoRoot, stdio: "pipe" });
@@ -68740,13 +69477,13 @@ async function safeBackup2(_filePath) {
     const bakPath = `${_filePath}.bak.${stamp}`;
     await fsp__namespace.copyFile(_filePath, bakPath);
     console.log(
-      chalk37__default.default.gray(`  \u21B3 backup: ${path57__namespace.relative(process.cwd(), bakPath)}`)
+      chalk37__default.default.gray(`  \u21B3 backup: ${path58__namespace.relative(process.cwd(), bakPath)}`)
     );
   } catch {
   }
 }
 async function interactiveSetup() {
-  const packageJsonPath = path57__namespace.join(process.cwd(), "package.json");
+  const packageJsonPath = path58__namespace.join(process.cwd(), "package.json");
   let packageJson2 = {};
   try {
     const packageData = await fsp__namespace.readFile(packageJsonPath, "utf-8");
@@ -68758,7 +69495,7 @@ async function interactiveSetup() {
       type: "text",
       name: "name",
       message: "Project name:",
-      initial: packageJson2.name || path57__namespace.basename(process.cwd())
+      initial: packageJson2.name || path58__namespace.basename(process.cwd())
     },
     {
       type: "select",
@@ -68802,7 +69539,7 @@ async function interactiveSetup() {
 }
 function getDefaultConfig() {
   return {
-    name: path57__namespace.basename(process.cwd()),
+    name: path58__namespace.basename(process.cwd()),
     type: "auto",
     description: "AI-powered development project using MARIA",
     author: "",
@@ -68983,13 +69720,13 @@ function resolveLang(input3) {
   return "en";
 }
 async function findRepoRoot(startDir) {
-  let dir = path57__namespace.resolve(startDir);
+  let dir = path58__namespace.resolve(startDir);
   let lastGitDir = null;
   while (true) {
-    const gitPath = path57__namespace.join(dir, ".git");
+    const gitPath = path58__namespace.join(dir, ".git");
     const hasGit = await fileExists3(gitPath);
     if (hasGit) lastGitDir = dir;
-    const parent = path57__namespace.dirname(dir);
+    const parent = path58__namespace.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -69071,8 +69808,8 @@ var init_update_command = __esm({
       async execute(options = {}) {
         const startTime = Date.now();
         const root = options.root || process.cwd();
-        const stateDir = path57__namespace.join(root, ".maria");
-        const statePath = path57__namespace.join(stateDir, "state.json");
+        const stateDir = path58__namespace.join(root, ".maria");
+        const statePath = path58__namespace.join(stateDir, "state.json");
         this.reporter.thinking(`Performing incremental update to detect and process changes.
 This will:
 - Detect file changes since last update
@@ -69242,12 +69979,12 @@ This will:
         };
         const result = await this.deltaDetector.detectDelta(root, deltaOptions);
         const files = [
-          ...result.changed.map((path58) => ({
-            _path: path58,
-            type: previousState?.fileHashes?.[path58] ? "modified" : "added"
+          ...result.changed.map((path59) => ({
+            _path: path59,
+            type: previousState?.fileHashes?.[path59] ? "modified" : "added"
           })),
-          ...result.deleted.map((path58) => ({
-            _path: path58,
+          ...result.deleted.map((path59) => ({
+            _path: path59,
             type: "deleted"
           }))
         ];
@@ -69364,7 +70101,7 @@ This will:
           nodeUpdates.push({
             id: file._path,
             type: "file",
-            name: path57__namespace.basename(file._path),
+            name: path58__namespace.basename(file._path),
             language: file.language,
             size: file.size,
             complexity: file.complexity,
@@ -69464,7 +70201,7 @@ ${file.summary || ""}`,
        */
       async updateArtifacts(root, deltaResult, processResult) {
         this.logger.start("artifacts", "Updating artifacts...");
-        const mariaMdPath = path57__namespace.join(root, "MARIA.md");
+        const mariaMdPath = path58__namespace.join(root, "MARIA.md");
         let existingContent = "";
         try {
           existingContent = await fsp__namespace.readFile(mariaMdPath, "utf-8");
@@ -69478,7 +70215,7 @@ ${file.summary || ""}`,
         );
         await fsp__namespace.writeFile(mariaMdPath, updatedMariaMd, "utf-8");
         this.reporter.write("MARIA.md", updatedMariaMd.length);
-        const depMapPath = path57__namespace.join(root, "DEPENDENCY_MAP.json");
+        const depMapPath = path58__namespace.join(root, "DEPENDENCY_MAP.json");
         try {
           const existingDepMap = JSON.parse(await fsp__namespace.readFile(depMapPath, "utf-8"));
           this.reporter.read(
@@ -69597,7 +70334,7 @@ ${delta.modified > 5 ? `... and ${delta.modified - 5} more` : ""}
         }
       }
       async saveState(statePath, state) {
-        const dir = path57__namespace.dirname(statePath);
+        const dir = path58__namespace.dirname(statePath);
         await fsp__namespace.mkdir(dir, { recursive: true });
         if (state.fileHashes instanceof Map) {
           state.fileHashes = Object.fromEntries(state.fileHashes);
@@ -69751,9 +70488,9 @@ var init_update = __esm({
 var UpdateCommand_exports = {};
 __export(UpdateCommand_exports, {
   UpdateCommand: () => UpdateCommand2,
-  meta: () => meta16
+  meta: () => meta17
 });
-var UpdateCommand2, meta16;
+var UpdateCommand2, meta17;
 var init_UpdateCommand = __esm({
   "src/slash-commands/categories/core/handlers/UpdateCommand.ts"() {
     init_base_command();
@@ -69904,7 +70641,7 @@ var init_UpdateCommand = __esm({
         return errors;
       }
     };
-    meta16 = {
+    meta17 = {
       name: "update",
       category: "core",
       description: "Update project dependencies, configurations, and system components",
@@ -70018,7 +70755,7 @@ var init_ResearchCommand = __esm({
       constructor() {
         super();
         this.contentExtractor = new ContentExtractor();
-        this.knowledgeBasePath = path57__namespace.default.join(os16__namespace.default.homedir(), ".maria", "knowledge-base");
+        this.knowledgeBasePath = path58__namespace.default.join(os16__namespace.default.homedir(), ".maria", "knowledge-base");
       }
       async initialize() {
         try {
@@ -70549,7 +71286,7 @@ ${JSON.stringify(_result, null, 2)}
               readingTime: _content.metadata.readingTime
             }
           };
-          const _entryPath = path57__namespace.default.join(this.knowledgeBasePath, "entries", `${id}.json`);
+          const _entryPath = path58__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}`);
@@ -70560,7 +71297,7 @@ ${JSON.stringify(_result, null, 2)}
         }
       }
       async updateKnowledgeBaseIndex(_entry) {
-        const _indexPath = path57__namespace.default.join(this.knowledgeBasePath, "index.json");
+        const _indexPath = path58__namespace.default.join(this.knowledgeBasePath, "index.json");
         try {
           const _indexContent = await fsp__namespace.default.readFile(_indexPath, "utf-8");
           const _index = JSON.parse(_indexContent);
@@ -70580,7 +71317,7 @@ ${JSON.stringify(_result, null, 2)}
       async ensureKnowledgeBaseDirectory() {
         try {
           await fsp__namespace.default.mkdir(this.knowledgeBasePath, { recursive: true });
-          await fsp__namespace.default.mkdir(path57__namespace.default.join(this.knowledgeBasePath, "entries"), { recursive: true });
+          await fsp__namespace.default.mkdir(path58__namespace.default.join(this.knowledgeBasePath, "entries"), { recursive: true });
         } catch (innerError) {
           logger.error("Failed to create knowledge base directory:", error);
         }
@@ -70648,7 +71385,7 @@ ${JSON.stringify(_result, null, 2)}
 `;
         }
         try {
-          const _indexPath = path57__namespace.default.join(this.knowledgeBasePath, "index.json");
+          const _indexPath = path58__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
@@ -70713,9 +71450,9 @@ var l2r_command_exports = {};
 __export(l2r_command_exports, {
   L2RCommand: () => L2RCommand,
   default: () => l2r_command_default,
-  meta: () => meta17
+  meta: () => meta18
 });
-var L2RCommand, meta17, l2r_command_default;
+var L2RCommand, meta18, l2r_command_default;
 var init_l2r_command = __esm({
   "src/slash-commands/categories/learning/l2r.command.ts"() {
     init_base_command();
@@ -71712,7 +72449,7 @@ var init_l2r_command = __esm({
         return { success: true };
       }
     };
-    meta17 = {
+    meta18 = {
       name: "l2r",
       category: "learning",
       description: "\u{1F3AF} Learning-to-Rank system with 44-dimension features and model training *GPU needed - Local LLM only (Pro+ members only)",
@@ -71736,9 +72473,9 @@ var search_command_exports = {};
 __export(search_command_exports, {
   GraphRAGSearchCommand: () => GraphRAGSearchCommand,
   default: () => search_command_default,
-  meta: () => meta18
+  meta: () => meta19
 });
-var GraphRAGSearchCommand, meta18, search_command_default;
+var GraphRAGSearchCommand, meta19, search_command_default;
 var init_search_command = __esm({
   "src/slash-commands/categories/graphrag/search.command.ts"() {
     init_base_command();
@@ -72151,7 +72888,7 @@ var init_search_command = __esm({
         return { success: true };
       }
     };
-    meta18 = {
+    meta19 = {
       name: "search",
       category: "graphrag",
       description: "\u{1F50D} Graph RAG search with BM25, vector, and knowledge graph hybrid search *GPU needed - Local LLM only (Pro+ members only)",
@@ -72174,9 +72911,9 @@ var language_command_exports = {};
 __export(language_command_exports, {
   LanguageCommand: () => LanguageCommand,
   default: () => language_command_default,
-  meta: () => meta19
+  meta: () => meta20
 });
-var LanguageCommand, meta19, language_command_default;
+var LanguageCommand, meta20, language_command_default;
 var init_language_command = __esm({
   "src/slash-commands/categories/multilingual/language.command.ts"() {
     init_base_command();
@@ -72866,7 +73603,7 @@ var init_language_command = __esm({
         return { success: true };
       }
     };
-    meta19 = {
+    meta20 = {
       name: "language",
       category: "multilingual",
       description: "\u{1F30D} Language detection, weights configuration, and multilingual processing",
@@ -72923,8 +73660,8 @@ async function checkShield(commandName, userPlan = "free") {
 async function loadManifest() {
   try {
     const fs48 = await import('fs');
-    const path58 = await import('path');
-    const manifestPath = path58.join(
+    const path59 = await import('path');
+    const manifestPath = path59.join(
       __dirname,
       "../command-manifest-v2.1.json"
     );
@@ -73147,14 +73884,14 @@ var sales_dashboard_command_exports = {};
 __export(sales_dashboard_command_exports, {
   SalesDashboardCommand: () => SalesDashboardCommand,
   default: () => sales_dashboard_command_default,
-  meta: () => meta20
+  meta: () => meta21
 });
-var meta20, SalesDashboardCommand, sales_dashboard_command_default;
+var meta21, SalesDashboardCommand, sales_dashboard_command_default;
 var init_sales_dashboard_command = __esm({
   "src/slash-commands/categories/business/sales-dashboard.command.ts"() {
     init_BaseCommand();
     init_deps();
-    meta20 = {
+    meta21 = {
       name: "sales-dashboard",
       category: "business",
       description: "Interactive TUI sales dashboard with real-time updates",
@@ -73163,11 +73900,11 @@ var init_sales_dashboard_command = __esm({
       status: "stable"
     };
     SalesDashboardCommand = class extends BaseCommand2 {
-      meta = meta20;
+      meta = meta21;
       async execute(args2, context2) {
         const options = this.parseOptions(args2);
         return withDependencyGuard(
-          meta20.deps || [],
+          meta21.deps || [],
           async () => this.executeWithRealData(options, context2),
           () => this.executeWithMockData(options)
         );
@@ -73441,9 +74178,9 @@ var gpu_command_exports = {};
 __export(gpu_command_exports, {
   GPUCommand: () => GPUCommand,
   default: () => gpu_command_default,
-  meta: () => meta21
+  meta: () => meta22
 });
-var GPUCommand, meta21, gpu_command_default;
+var GPUCommand, meta22, gpu_command_default;
 var init_gpu_command = __esm({
   "src/slash-commands/categories/ai/gpu.command.ts"() {
     init_base_command();
@@ -74005,7 +74742,7 @@ var init_gpu_command = __esm({
         return { success: true };
       }
     };
-    meta21 = {
+    meta22 = {
       name: "gpu",
       category: "ai",
       description: "GPU status, benchmarking, and management capabilities *GPU needed - Local LLM only (Pro+ members only)",
@@ -74036,6 +74773,7 @@ __export(slash_commands_exports, {
   ExitCommand: () => ExitCommand,
   ForgetCommand: () => ForgetCommand,
   HelpCommand: () => HelpCommand,
+  IdentityCommand: () => IdentityCommand,
   ImageCommand: () => ImageCommand,
   LoggingMiddleware: () => LoggingMiddleware,
   LogoutCommand: () => LogoutCommand,
@@ -74116,6 +74854,14 @@ async function registerBuiltInCommands() {
     } catch (aboutError) {
       console.error("Failed to register about command:", aboutError);
     }
+    try {
+      const { IdentityCommand: IdentityCommand2 } = await Promise.resolve().then(() => (init_identity_command(), identity_command_exports));
+      const identityCommand = new IdentityCommand2();
+      if (identityCommand.initialize) await identityCommand.initialize();
+      commandRegistry.register(identityCommand);
+    } catch (identityError) {
+      console.error("Failed to register identity command:", identityError);
+    }
     const { StatusCommandV2: StatusCommandV22 } = await Promise.resolve().then(() => (init_StatusCommand(), StatusCommand_exports));
     const { DoctorCommand: DoctorCommand2 } = await Promise.resolve().then(() => (init_DoctorCommand(), DoctorCommand_exports));
     const { TerminalSetupCommand: TerminalSetupCommand2 } = await Promise.resolve().then(() => (init_TerminalSetupCommand(), TerminalSetupCommand_exports));
@@ -74568,6 +75314,7 @@ var init_slash_commands = __esm({
     init_UsageCommand();
     init_PlanCommand();
     init_WhoAmICommand();
+    init_identity_command();
     init_registry();
   }
 });
@@ -74612,10 +75359,10 @@ 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 path58 = __require("path");
+          const path59 = __require("path");
           const fs48 = await import('fs/promises');
-          const outPath = path58.join(process.cwd(), "outputs", "images", `image_${Date.now()}.png`);
-          await fs48.mkdir(path58.dirname(outPath), { recursive: true });
+          const outPath = path59.join(process.cwd(), "outputs", "images", `image_${Date.now()}.png`);
+          await fs48.mkdir(path59.dirname(outPath), { recursive: true });
           await fs48.writeFile(outPath, res.bytes);
           return { success: true, output: `OK: Saved image \u2192 ${outPath}` };
         } catch (e2) {
@@ -74667,12 +75414,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 path58 = __require("path");
+          const path59 = __require("path");
           const fs48 = await import('fs/promises');
-          const dir = path58.join(process.cwd(), "outputs", "videos", `video_${Date.now()}`);
+          const dir = path59.join(process.cwd(), "outputs", "videos", `video_${Date.now()}`);
           await fs48.mkdir(dir, { recursive: true });
           const framePattern = "frame_%04d.png";
-          await Promise.all(frames.frames.map((buf, i2) => fs48.writeFile(path58.join(dir, `frame_${i2.toString().padStart(4, "0")}.png`), buf)));
+          await Promise.all(frames.frames.map((buf, i2) => fs48.writeFile(path59.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);
@@ -74689,8 +75436,8 @@ var init_VideoCommand = __esm({
         if (!available) return false;
         return new Promise((resolve18) => {
           const { spawn: spawn4 } = __require("child_process");
-          const path58 = __require("path");
-          const out = path58.join(dir, "video.mp4");
+          const path59 = __require("path");
+          const out = path59.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", () => {
@@ -74945,9 +75692,9 @@ var init_model_selector_ui = __esm({
 var ModelCommand_exports = {};
 __export(ModelCommand_exports, {
   ModelCommand: () => ModelCommand,
-  meta: () => meta22
+  meta: () => meta23
 });
-var ModelCommand, meta22;
+var ModelCommand, meta23;
 var init_ModelCommand = __esm({
   "src/slash-commands/categories/configuration/handlers/ModelCommand.ts"() {
     init_base_command();
@@ -76208,7 +76955,7 @@ ${model.description}
         }
       }
     };
-    meta22 = {
+    meta23 = {
       name: "model",
       category: "configuration",
       description: "Manages AI model configuration and selection",
@@ -76229,9 +76976,9 @@ ${model.description}
 var ConfigCommand_exports = {};
 __export(ConfigCommand_exports, {
   ConfigCommand: () => ConfigCommand2,
-  meta: () => meta23
+  meta: () => meta24
 });
-var ConfigCommand2, meta23;
+var ConfigCommand2, meta24;
 var init_ConfigCommand2 = __esm({
   "src/slash-commands/categories/configuration/handlers/ConfigCommand.ts"() {
     init_BaseCommand();
@@ -76420,8 +77167,8 @@ var init_ConfigCommand2 = __esm({
           validate: (v) => typeof v === "string"
         }
       };
-      globalConfigPath = path57__namespace.default.join(os16__namespace.default.homedir(), ".maria", "config.json");
-      localConfigPath = path57__namespace.default.join(process.cwd(), ".maria-config.json");
+      globalConfigPath = path58__namespace.default.join(os16__namespace.default.homedir(), ".maria", "config.json");
+      localConfigPath = path58__namespace.default.join(process.cwd(), ".maria-config.json");
       async execute(_args, context2) {
         try {
           const _startTime = Date.now();
@@ -76807,7 +77554,7 @@ var init_ConfigCommand2 = __esm({
       }
       async saveConfiguration(_config, _scope) {
         const _configPath = _scope === "global" ? this.globalConfigPath : this.localConfigPath;
-        await fsp__namespace.default.mkdir(path57__namespace.default.dirname(_configPath), { recursive: true });
+        await fsp__namespace.default.mkdir(path58__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);
       }
@@ -76931,7 +77678,7 @@ var init_ConfigCommand2 = __esm({
         };
       }
     };
-    meta23 = {
+    meta24 = {
       name: "_config",
       _category: "configuration",
       _description: "Manages MARIA configuration settings",
@@ -78072,23 +78819,23 @@ function coerceExtension(ext2, fallback2) {
   return fallback2;
 }
 function safeResolve(root, fname) {
-  const abs = path57__namespace.resolve(root, fname);
-  const base = path57__namespace.resolve(root);
-  if (!(abs + path57__namespace.sep).startsWith(base + path57__namespace.sep) && abs !== base) {
+  const abs = path58__namespace.resolve(root, fname);
+  const base = path58__namespace.resolve(root);
+  if (!(abs + path58__namespace.sep).startsWith(base + path58__namespace.sep) && abs !== base) {
     throw new Error("Path traversal detected");
   }
   return abs;
 }
 async function ensureUniquePath(absPath) {
-  const dir = path57__namespace.dirname(absPath);
-  const ext2 = path57__namespace.extname(absPath);
-  const base = path57__namespace.basename(absPath, ext2);
+  const dir = path58__namespace.dirname(absPath);
+  const ext2 = path58__namespace.extname(absPath);
+  const base = path58__namespace.basename(absPath, ext2);
   let candidate = absPath;
   let i2 = 1;
   while (true) {
     try {
       await fsp__namespace.access(candidate);
-      candidate = path57__namespace.join(dir, `${base}(${i2})${ext2}`);
+      candidate = path58__namespace.join(dir, `${base}(${i2})${ext2}`);
       i2++;
     } catch {
       return candidate;
@@ -78167,7 +78914,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 = path57__namespace.extname(filename).slice(1);
+        const ext2 = path58__namespace.extname(filename).slice(1);
         const isBinary3 = isLikelyBinary(code);
         const inferred = isBinary3 ? "bin" : inferExtensionFromContent(language, code) || "txt";
         const finalExt = coerceExtension(ext2, inferred);
@@ -78180,22 +78927,22 @@ async function handleCodeCommand(prompt) {
         files += 1;
         if (progress) clearInterval(progress);
         if (isTTY) rl__namespace.cursorTo(process.stdout, 0);
-        console.log(`Saved 1 file: ${path57__namespace.basename(filepath)} (${language}${isBinary3 ? ", binary-like" : ""})`);
+        console.log(`Saved 1 file: ${path58__namespace.basename(filepath)} (${language}${isBinary3 ? ", binary-like" : ""})`);
         textLog.path(filepath);
         const pm = getProviderManager();
         const provider = pm.getLastUsedProvider() || "fallback";
         const model = pm.getLastUsedModel() || "n/a";
         const source = pm.getConfigSource();
-        const summary = { filename: path57__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 };
+        const summary = { filename: path58__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);
+          TelemetryCollector2.getInstance().trackCodeSaved(summary);
         } catch {
         }
       }
       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 };
       try {
-        TelemetryCollector.getInstance().trackCodeSavedBatch(batch);
+        TelemetryCollector2.getInstance().trackCodeSavedBatch(batch);
       } catch {
       }
     } catch (saveError) {
@@ -78224,7 +78971,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 = path57__namespace.extname(filename).slice(1);
+        const ext2 = path58__namespace.extname(filename).slice(1);
         const isBinary3 = isLikelyBinary(code);
         const inferred = isBinary3 ? "bin" : inferExtensionFromContent(language, code) || "txt";
         const finalExt = coerceExtension(ext2, inferred);
@@ -78237,22 +78984,22 @@ async function handleCodeCommand(prompt) {
         files += 1;
         if (progress) clearInterval(progress);
         if (isTTY) rl__namespace.cursorTo(process.stdout, 0);
-        console.log(`Saved 1 file: ${path57__namespace.basename(filepath)} (${language}${isBinary3 ? ", binary-like" : ""})`);
+        console.log(`Saved 1 file: ${path58__namespace.basename(filepath)} (${language}${isBinary3 ? ", binary-like" : ""})`);
         textLog.path(filepath);
         const pm = getProviderManager();
         const provider = pm.getLastUsedProvider() || "unknown";
         const model = pm.getLastUsedModel() || "auto";
         const source = pm.getConfigSource();
-        const summary = { filename: path57__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 };
+        const summary = { filename: path58__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);
+          TelemetryCollector2.getInstance().trackCodeSaved(summary);
         } catch {
         }
       }
       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 };
       try {
-        TelemetryCollector.getInstance().trackCodeSavedBatch(batch);
+        TelemetryCollector2.getInstance().trackCodeSavedBatch(batch);
       } catch {
       }
       console.log(chalk37__default.default.gray(`[code] done \xB7 ${Date.now() - startedAt}ms`));
@@ -78275,7 +79022,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 = path57__namespace.extname(filename).slice(1);
+        const ext2 = path58__namespace.extname(filename).slice(1);
         const isBinary3 = isLikelyBinary(code);
         const inferred = isBinary3 ? "bin" : inferExtensionFromContent(language, code) || "txt";
         const finalExt = coerceExtension(ext2, inferred);
@@ -78288,22 +79035,22 @@ async function handleCodeCommand(prompt) {
         files += 1;
         if (progress) clearInterval(progress);
         if (isTTY) rl__namespace.cursorTo(process.stdout, 0);
-        console.log(`Saved 1 file: ${path57__namespace.basename(filepath)} (${language}${isBinary3 ? ", binary-like" : ""})`);
+        console.log(`Saved 1 file: ${path58__namespace.basename(filepath)} (${language}${isBinary3 ? ", binary-like" : ""})`);
         textLog.path(filepath);
         const pm = getProviderManager();
         const provider = pm.getLastUsedProvider() || "fallback";
         const model = pm.getLastUsedModel() || "n/a";
         const source = pm.getConfigSource();
-        const summary = { filename: path57__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 };
+        const summary = { filename: path58__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);
+          TelemetryCollector2.getInstance().trackCodeSaved(summary);
         } catch {
         }
       }
       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 };
       try {
-        TelemetryCollector.getInstance().trackCodeSavedBatch(batch);
+        TelemetryCollector2.getInstance().trackCodeSavedBatch(batch);
       } catch {
       }
     } catch (saveError) {
@@ -78359,7 +79106,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 = path57__namespace.extname(filename).slice(1);
+        const ext2 = path58__namespace.extname(filename).slice(1);
         const isBinary3 = isLikelyBinary(code);
         const inferred = isBinary3 ? "bin" : inferExtensionFromContent(language, code) || "txt";
         const finalExt = coerceExtension(ext2, inferred);
@@ -78372,22 +79119,22 @@ ${e2.stack}`));
         files += 1;
         if (progress) clearInterval(progress);
         if (isTTY) rl__namespace.cursorTo(process.stdout, 0);
-        console.log(`Saved 1 file: ${path57__namespace.basename(filepath)} (${language}${isBinary3 ? ", binary-like" : ""})`);
+        console.log(`Saved 1 file: ${path58__namespace.basename(filepath)} (${language}${isBinary3 ? ", binary-like" : ""})`);
         textLog.path(filepath);
         const pm = getProviderManager();
         const provider = pm.getLastUsedProvider() || "fallback";
         const model = pm.getLastUsedModel() || "n/a";
         const source = pm.getConfigSource();
-        const summary = { filename: path57__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 };
+        const summary = { filename: path58__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);
+          TelemetryCollector2.getInstance().trackCodeSaved(summary);
         } catch {
         }
       }
       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 };
       try {
-        TelemetryCollector.getInstance().trackCodeSavedBatch(batch);
+        TelemetryCollector2.getInstance().trackCodeSavedBatch(batch);
       } catch {
       }
     } catch (saveError) {
@@ -78836,7 +79583,7 @@ async function streamAnswer(text, opts = {}) {
           for (const { language, code, extension, filename: suggested } of artifacts) {
             let filename = generateCodeFilename(text, language, extension, code, suggested);
             filename = sanitizeFilenameStrict(filename);
-            const ext2 = path57__namespace.extname(filename).slice(1);
+            const ext2 = path58__namespace.extname(filename).slice(1);
             const isBinary3 = isLikelyBinary(code);
             const inferred = isBinary3 ? "bin" : inferExtensionFromContent(language, code) || "txt";
             const finalExt = coerceExtension(ext2, inferred);
@@ -78845,13 +79592,13 @@ async function streamAnswer(text, opts = {}) {
             filepath = await ensureUniquePath(filepath);
             try {
               await fsp__namespace.writeFile(filepath, code, "utf-8");
-              savedFiles.push({ filepath, filename: path57__namespace.basename(filepath), language, code, ok: true, isBinary: isBinary3 });
+              savedFiles.push({ filepath, filename: path58__namespace.basename(filepath), language, code, ok: true, isBinary: isBinary3 });
               okCount++;
               console.log(chalk37__default.default.white(`OK: saved ${filepath} (${language}${isBinary3 ? ", binary-like" : ""})`));
             } catch (e2) {
               errCount++;
               const msg2 = e2?.message || "failed to write";
-              savedFiles.push({ filepath, filename: path57__namespace.basename(filepath), language, code, ok: false, error: msg2, isBinary: isBinary3 });
+              savedFiles.push({ filepath, filename: path58__namespace.basename(filepath), language, code, ok: false, error: msg2, isBinary: isBinary3 });
               console.log(chalk37__default.default.white(`ERROR: failed ${filepath} (${language}) - ${msg2}`));
             }
           }
@@ -79185,24 +79932,24 @@ function createCLI() {
     if (options.server) {
       console.log(chalk37__default.default.white("Starting MARIA server mode..."));
       try {
-        const distDir = path57__namespace.dirname(process.argv[1] || process.cwd());
+        const distDir = path58__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
-          path57__namespace.join("server", "express-server.js"),
-          path57__namespace.join("server", "express-server.cjs")
+          path58__namespace.join("server", "express-server.js"),
+          path58__namespace.join("server", "express-server.cjs")
         ];
         const candidateDirs = [
           distDir,
-          path57__namespace.resolve(distDir, ".."),
+          path58__namespace.resolve(distDir, ".."),
           process.cwd()
         ];
         let serverPath = null;
         for (const dir of candidateDirs) {
           for (const name2 of candidateNames) {
-            const p = path57__namespace.join(dir, name2);
+            const p = path58__namespace.join(dir, name2);
             try {
               await fsp__namespace.access(p);
               serverPath = p;
@@ -79222,7 +79969,7 @@ function createCLI() {
         const serverProcess = spawn4("node", [serverPath], {
           stdio: "inherit",
           env: process.env,
-          cwd: path57__namespace.dirname(serverPath)
+          cwd: path58__namespace.dirname(serverPath)
         });
         let shutdownTimer = null;
         const forceExit = (defaultCode) => {